GitHub/flatbuffers
1
0
Fork 0
mirror of https://github.com/google/flatbuffers.git synced 2025-04-08 09:12:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

[Rust] Add the Allocator trait for the builder API (#8106)

Browse Source 
* Add an Allocator trait for FlatBufferBuilder

* Update rust generated code
This commit is contained in:
adsnaider 2023-10-07 14:28:52 -05:00 committed by GitHub
parent f4e23bf91e
commit 205285c35c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
56 changed files with 658 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

356
rust/flatbuffers/src/builder.rs
View File

@ -17,8 +17,11 @@
#[cfg(not(feature = "std"))] #[cfg(not(feature = "std"))]
use alloc::{vec, vec::Vec}; use alloc::{vec, vec::Vec};
use core::cmp::max; use core::cmp::max;
use core::convert::Infallible;
use core::fmt::{Debug, Display};
use core::iter::{DoubleEndedIterator, ExactSizeIterator}; use core::iter::{DoubleEndedIterator, ExactSizeIterator};
use core::marker::PhantomData; use core::marker::PhantomData;
use core::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut, Sub, SubAssign};
use core::ptr::write_bytes; use core::ptr::write_bytes;
use crate::endian_scalar::emplace_scalar; use crate::endian_scalar::emplace_scalar;
@ -30,6 +33,90 @@ use crate::vector::Vector;
use crate::vtable::{field_index_to_field_offset, VTable}; use crate::vtable::{field_index_to_field_offset, VTable};
use crate::vtable_writer::VTableWriter; use crate::vtable_writer::VTableWriter;
/// Trait to implement custom allocation strategies for [`FlatBufferBuilder`].
///
/// An implementation can be used with [`FlatBufferBuilder::new_in`], enabling a custom allocation
/// strategy for the [`FlatBufferBuilder`].
///
/// # Safety
///
/// The implementation of the allocator must match the defined behavior as described by the
/// comments.
pub unsafe trait Allocator: DerefMut<Target = [u8]> {
/// A type describing allocation failures
type Error: Display + Debug;
/// Grows the buffer, with the old contents being moved to the end.
///
/// NOTE: While not unsound, an implementation that doesn't grow the
/// internal buffer will get stuck in an infinite loop.
fn grow_downwards(&mut self) -> Result<(), Self::Error>;
/// Returns the size of the internal buffer in bytes.
fn len(&self) -> usize;
}
/// Default [`FlatBufferBuilder`] allocator backed by a [`Vec<u8>`].
#[derive(Default)]
pub struct DefaultAllocator(Vec<u8>);
impl DefaultAllocator {
/// Builds the allocator from an existing buffer.
pub fn from_vec(buffer: Vec<u8>) -> Self {
Self(buffer)
}
}
impl Deref for DefaultAllocator {
type Target = [u8];
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for DefaultAllocator {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
// SAFETY: The methods are implemented as described by the documentation.
unsafe impl Allocator for DefaultAllocator {
type Error = Infallible;
fn grow_downwards(&mut self) -> Result<(), Self::Error> {
let old_len = self.0.len();
let new_len = max(1, old_len * 2);
self.0.resize(new_len, 0);
if new_len == 1 {
return Ok(());
}
// calculate the midpoint, and safely copy the old end data to the new
// end position:
let middle = new_len / 2;
{
let (left, right) = &mut self.0[..].split_at_mut(middle);
right.copy_from_slice(left);
}
// finally, zero out the old end data.
{
let ptr = self.0[..middle].as_mut_ptr();
// Safety:
// ptr is byte aligned and of length middle
unsafe {
write_bytes(ptr, 0, middle);
}
}
Ok(())
}
fn len(&self) -> usize {
self.0.len()
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)] #[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct FieldLoc { struct FieldLoc {
off: UOffsetT, off: UOffsetT,
@ -40,9 +127,9 @@ struct FieldLoc {
/// state. It has an owned `Vec<u8>` that grows as needed (up to the hardcoded /// state. It has an owned `Vec<u8>` that grows as needed (up to the hardcoded
/// limit of 2GiB, which is set by the FlatBuffers format). /// limit of 2GiB, which is set by the FlatBuffers format).
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub struct FlatBufferBuilder<'fbb> { pub struct FlatBufferBuilder<'fbb, A: Allocator = DefaultAllocator> {
owned_buf: Vec<u8>, allocator: A,
head: usize, head: ReverseIndex,
field_locs: Vec<FieldLoc>, field_locs: Vec<FieldLoc>,
written_vtable_revpos: Vec<UOffsetT>, written_vtable_revpos: Vec<UOffsetT>,
@ -57,7 +144,7 @@ pub struct FlatBufferBuilder<'fbb> {
_phantom: PhantomData<&'fbb ()>, _phantom: PhantomData<&'fbb ()>,
} }
impl<'fbb> FlatBufferBuilder<'fbb> { impl<'fbb> FlatBufferBuilder<'fbb, DefaultAllocator> {
/// Create a FlatBufferBuilder that is ready for writing. /// Create a FlatBufferBuilder that is ready for writing.
pub fn new() -> Self { pub fn new() -> Self {
Self::with_capacity(0) Self::with_capacity(0)
@ -77,14 +164,29 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
/// an existing vector. /// an existing vector.
pub fn from_vec(buffer: Vec<u8>) -> Self { pub fn from_vec(buffer: Vec<u8>) -> Self {
// we need to check the size here because we create the backing buffer // we need to check the size here because we create the backing buffer
// directly, bypassing the typical way of using grow_owned_buf: // directly, bypassing the typical way of using grow_allocator:
assert!( assert!(
buffer.len() <= FLATBUFFERS_MAX_BUFFER_SIZE, buffer.len() <= FLATBUFFERS_MAX_BUFFER_SIZE,
"cannot initialize buffer bigger than 2 gigabytes" "cannot initialize buffer bigger than 2 gigabytes"
); );
let head = buffer.len(); let allocator = DefaultAllocator::from_vec(buffer);
Self::new_in(allocator)
}
/// Destroy the FlatBufferBuilder, returning its internal byte vector
/// and the index into it that represents the start of valid data.
pub fn collapse(self) -> (Vec<u8>, usize) {
let index = self.head.to_forward_index(&self.allocator);
(self.allocator.0, index)
}
}
impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
/// Create a [`FlatBufferBuilder`] that is ready for writing with a custom [`Allocator`].
pub fn new_in(allocator: A) -> Self {
let head = ReverseIndex::end();
FlatBufferBuilder { FlatBufferBuilder {
owned_buf: buffer, allocator,
head, head,
field_locs: Vec::new(), field_locs: Vec::new(),
@ -101,6 +203,13 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
} }
} }
/// Destroy the [`FlatBufferBuilder`], returning its [`Allocator`] and the index
/// into it that represents the start of valid data.
pub fn collapse_in(self) -> (A, usize) {
let index = self.head.to_forward_index(&self.allocator);
(self.allocator, index)
}
/// Reset the FlatBufferBuilder internal state. Use this method after a /// Reset the FlatBufferBuilder internal state. Use this method after a
/// call to a `finish` function in order to re-use a FlatBufferBuilder. /// call to a `finish` function in order to re-use a FlatBufferBuilder.
/// ///
@ -114,17 +223,11 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
/// new object. /// new object.
pub fn reset(&mut self) { pub fn reset(&mut self) {
// memset only the part of the buffer that could be dirty: // memset only the part of the buffer that could be dirty:
{ self.allocator[self.head.range_to_end()]
let to_clear = self.owned_buf.len() - self.head; .iter_mut()
let ptr = self.owned_buf[self.head..].as_mut_ptr(); .for_each(|x| *x = 0);
// Safety:
// Verified ptr is valid for `to_clear` above
unsafe {
write_bytes(ptr, 0, to_clear);
}
}
self.head = self.owned_buf.len(); self.head = ReverseIndex::end();
self.written_vtable_revpos.clear(); self.written_vtable_revpos.clear();
self.nested = false; self.nested = false;
@ -134,12 +237,6 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
self.strings_pool.clear(); self.strings_pool.clear();
} }
/// Destroy the FlatBufferBuilder, returning its internal byte vector
/// and the index into it that represents the start of valid data.
pub fn collapse(self) -> (Vec<u8>, usize) {
(self.owned_buf, self.head)
}
/// Push a Push'able value onto the front of the in-progress data. /// Push a Push'able value onto the front of the in-progress data.
/// ///
/// This function uses traits to provide a unified API for writing /// This function uses traits to provide a unified API for writing
@ -150,7 +247,7 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
self.align(sz, P::alignment()); self.align(sz, P::alignment());
self.make_space(sz); self.make_space(sz);
{ {
let (dst, rest) = self.owned_buf[self.head..].split_at_mut(sz); let (dst, rest) = self.allocator[self.head.range_to_end()].split_at_mut(sz);
// Safety: // Safety:
// Called make_space above // Called make_space above
unsafe { x.push(dst, rest.len()) }; unsafe { x.push(dst, rest.len()) };
@ -254,9 +351,9 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
"create_shared_string can not be called when a table or vector is under construction", "create_shared_string can not be called when a table or vector is under construction",
); );
// Saves a ref to owned_buf since rust doesnt like us refrencing it // Saves a ref to allocator since rust doesnt like us refrencing it
// in the binary_search_by code. // in the binary_search_by code.
let buf = &self.owned_buf; let buf = &self.allocator;
let found = self.strings_pool.binary_search_by(|offset| { let found = self.strings_pool.binary_search_by(|offset| {
let ptr = offset.value() as usize; let ptr = offset.value() as usize;
@ -324,9 +421,9 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
self.ensure_capacity(slice_size + UOffsetT::size()); self.ensure_capacity(slice_size + UOffsetT::size());
self.head -= slice_size; self.head -= slice_size;
let mut written_len = self.owned_buf.len() - self.head; let mut written_len = self.head.distance_to_end();
let buf = &mut self.owned_buf[self.head..self.head + slice_size]; let buf = &mut self.allocator[self.head.range_to(self.head + slice_size)];
for (item, out) in items.iter().zip(buf.chunks_exact_mut(elem_size)) { for (item, out) in items.iter().zip(buf.chunks_exact_mut(elem_size)) {
written_len -= elem_size; written_len -= elem_size;
@ -373,7 +470,7 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
/// whether it has been finished. /// whether it has been finished.
#[inline] #[inline]
pub fn unfinished_data(&self) -> &[u8] { pub fn unfinished_data(&self) -> &[u8] {
&self.owned_buf[self.head..] &self.allocator[self.head.range_to_end()]
} }
/// Get the byte slice for the data that has been written after a call to /// Get the byte slice for the data that has been written after a call to
/// one of the `finish` functions. /// one of the `finish` functions.
@ -382,7 +479,7 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
#[inline] #[inline]
pub fn finished_data(&self) -> &[u8] { pub fn finished_data(&self) -> &[u8] {
self.assert_finished("finished_bytes cannot be called when the buffer is not yet finished"); self.assert_finished("finished_bytes cannot be called when the buffer is not yet finished");
&self.owned_buf[self.head..] &self.allocator[self.head.range_to_end()]
} }
/// Returns a mutable view of a finished buffer and location of where the flatbuffer starts. /// Returns a mutable view of a finished buffer and location of where the flatbuffer starts.
/// Note that modifying the flatbuffer data may corrupt it. /// Note that modifying the flatbuffer data may corrupt it.
@ -390,7 +487,8 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
/// Panics if the flatbuffer is not finished. /// Panics if the flatbuffer is not finished.
#[inline] #[inline]
pub fn mut_finished_buffer(&mut self) -> (&mut [u8], usize) { pub fn mut_finished_buffer(&mut self) -> (&mut [u8], usize) {
(&mut self.owned_buf, self.head) let index = self.head.to_forward_index(&self.allocator);
(&mut self.allocator[..], index)
} }
/// Assert that a field is present in the just-finished Table. /// Assert that a field is present in the just-finished Table.
/// ///
@ -405,13 +503,13 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
let idx = self.used_space() - tab_revloc.value() as usize; let idx = self.used_space() - tab_revloc.value() as usize;
// Safety: // Safety:
// The value of TableFinishedWIPOffset is the offset from the end of owned_buf // The value of TableFinishedWIPOffset is the offset from the end of the allocator
// to an SOffsetT pointing to a valid VTable // to an SOffsetT pointing to a valid VTable
// //
// `self.owned_buf.len() = self.used_space() + self.head` // `self.allocator.len() = self.used_space() + self.head`
// `self.owned_buf.len() - tab_revloc = self.used_space() - tab_revloc + self.head` // `self.allocator.len() - tab_revloc = self.used_space() - tab_revloc + self.head`
// `self.owned_buf.len() - tab_revloc = idx + self.head` // `self.allocator.len() - tab_revloc = idx + self.head`
let tab = unsafe { Table::new(&self.owned_buf[self.head..], idx) }; let tab = unsafe { Table::new(&self.allocator[self.head.range_to_end()], idx) };
let o = tab.vtable().get(slot_byte_loc) as usize; let o = tab.vtable().get(slot_byte_loc) as usize;
assert!(o != 0, "missing required field {}", assert_msg_name); assert!(o != 0, "missing required field {}", assert_msg_name);
} }
@ -444,7 +542,7 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
#[inline] #[inline]
fn used_space(&self) -> usize { fn used_space(&self) -> usize {
self.owned_buf.len() - self.head as usize self.head.distance_to_end()
} }
#[inline] #[inline]
@ -517,7 +615,8 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
let vt_end_pos = self.head + vtable_byte_len; let vt_end_pos = self.head + vtable_byte_len;
{ {
// write the vtable header: // write the vtable header:
let vtfw = &mut VTableWriter::init(&mut self.owned_buf[vt_start_pos..vt_end_pos]); let vtfw =
&mut VTableWriter::init(&mut self.allocator[vt_start_pos.range_to(vt_end_pos)]);
vtfw.write_vtable_byte_length(vtable_byte_len as VOffsetT); vtfw.write_vtable_byte_length(vtable_byte_len as VOffsetT);
vtfw.write_object_inline_size(table_object_size as VOffsetT); vtfw.write_object_inline_size(table_object_size as VOffsetT);
@ -527,20 +626,20 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
vtfw.write_field_offset(fl.id, pos); vtfw.write_field_offset(fl.id, pos);
} }
} }
let new_vt_bytes = &self.owned_buf[vt_start_pos..vt_end_pos]; let new_vt_bytes = &self.allocator[vt_start_pos.range_to(vt_end_pos)];
let found = self let found = self
.written_vtable_revpos .written_vtable_revpos
.binary_search_by(|old_vtable_revpos: &UOffsetT| { .binary_search_by(|old_vtable_revpos: &UOffsetT| {
let old_vtable_pos = self.owned_buf.len() - *old_vtable_revpos as usize; let old_vtable_pos = self.allocator.len() - *old_vtable_revpos as usize;
// Safety: // Safety:
// Already written vtables are valid by construction // Already written vtables are valid by construction
let old_vtable = unsafe { VTable::init(&self.owned_buf, old_vtable_pos) }; let old_vtable = unsafe { VTable::init(&self.allocator, old_vtable_pos) };
new_vt_bytes.cmp(old_vtable.as_bytes()) new_vt_bytes.cmp(old_vtable.as_bytes())
}); });
let final_vtable_revpos = match found { let final_vtable_revpos = match found {
Ok(i) => { Ok(i) => {
// The new vtable is a duplicate so clear it. // The new vtable is a duplicate so clear it.
VTableWriter::init(&mut self.owned_buf[vt_start_pos..vt_end_pos]).clear(); VTableWriter::init(&mut self.allocator[vt_start_pos.range_to(vt_end_pos)]).clear();
self.head += vtable_byte_len; self.head += vtable_byte_len;
self.written_vtable_revpos[i] self.written_vtable_revpos[i]
} }
@ -552,17 +651,17 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
} }
}; };
// Write signed offset from table to its vtable. // Write signed offset from table to its vtable.
let table_pos = self.owned_buf.len() - object_revloc_to_vtable.value() as usize; let table_pos = self.allocator.len() - object_revloc_to_vtable.value() as usize;
if cfg!(debug_assertions) { if cfg!(debug_assertions) {
// Safety: // Safety:
// Verified slice length // Verified slice length
let tmp_soffset_to_vt = unsafe { let tmp_soffset_to_vt = unsafe {
read_scalar::<UOffsetT>(&self.owned_buf[table_pos..table_pos + SIZE_UOFFSET]) read_scalar::<UOffsetT>(&self.allocator[table_pos..table_pos + SIZE_UOFFSET])
}; };
assert_eq!(tmp_soffset_to_vt, 0xF0F0_F0F0); assert_eq!(tmp_soffset_to_vt, 0xF0F0_F0F0);
} }
let buf = &mut self.owned_buf[table_pos..table_pos + SIZE_SOFFSET]; let buf = &mut self.allocator[table_pos..table_pos + SIZE_SOFFSET];
// Safety: // Safety:
// Verified length of buf above // Verified length of buf above
unsafe { unsafe {
@ -579,39 +678,14 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
// Only call this when you know it is safe to double the size of the buffer. // Only call this when you know it is safe to double the size of the buffer.
#[inline] #[inline]
fn grow_owned_buf(&mut self) { fn grow_allocator(&mut self) {
let old_len = self.owned_buf.len();
let new_len = max(1, old_len * 2);
let starting_active_size = self.used_space(); let starting_active_size = self.used_space();
self.allocator
let diff = new_len - old_len; .grow_downwards()
self.owned_buf.resize(new_len, 0); .expect("Flatbuffer allocation failure");
self.head += diff;
let ending_active_size = self.used_space(); let ending_active_size = self.used_space();
debug_assert_eq!(starting_active_size, ending_active_size); debug_assert_eq!(starting_active_size, ending_active_size);
if new_len == 1 {
return;
}
// calculate the midpoint, and safely copy the old end data to the new
// end position:
let middle = new_len / 2;
{
let (left, right) = &mut self.owned_buf[..].split_at_mut(middle);
right.copy_from_slice(left);
}
// finally, zero out the old end data.
{
let ptr = self.owned_buf[..middle].as_mut_ptr();
// Safety:
// ptr is byte aligned and of length middle
unsafe {
write_bytes(ptr, 0, middle);
}
}
} }
// with or without a size prefix changes how we load the data, so finish* // with or without a size prefix changes how we load the data, so finish*
@ -676,13 +750,13 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
#[inline] #[inline]
fn push_bytes_unprefixed(&mut self, x: &[u8]) -> UOffsetT { fn push_bytes_unprefixed(&mut self, x: &[u8]) -> UOffsetT {
let n = self.make_space(x.len()); let n = self.make_space(x.len());
self.owned_buf[n..n + x.len()].copy_from_slice(x); self.allocator[n.range_to(n + x.len())].copy_from_slice(x);
n as UOffsetT n.to_forward_index(&self.allocator) as UOffsetT
} }
#[inline] #[inline]
fn make_space(&mut self, want: usize) -> usize { fn make_space(&mut self, want: usize) -> ReverseIndex {
self.ensure_capacity(want); self.ensure_capacity(want);
self.head -= want; self.head -= want;
self.head self.head
@ -699,13 +773,13 @@ impl<'fbb> FlatBufferBuilder<'fbb> {
); );
while self.unused_ready_space() < want { while self.unused_ready_space() < want {
self.grow_owned_buf(); self.grow_allocator();
} }
want want
} }
#[inline] #[inline]
fn unused_ready_space(&self) -> usize { fn unused_ready_space(&self) -> usize {
self.head self.allocator.len() - self.head.distance_to_end()
} }
#[inline] #[inline]
fn assert_nested(&self, fn_name: &'static str) { fn assert_nested(&self, fn_name: &'static str) {
@ -754,3 +828,127 @@ impl<'fbb> Default for FlatBufferBuilder<'fbb> {
Self::with_capacity(0) Self::with_capacity(0)
} }
} }
/// An index that indexes from the reverse of a slice.
///
/// Note that while the internal representation is an index
/// from the end of a buffer, operations like `Add` and `Sub`
/// behave like a regular index:
///
/// # Examples
///
/// ```ignore
/// let buf = [0, 1, 2, 3, 4, 5];
/// let idx = ReverseIndex::end() - 2;
/// assert_eq!(&buf[idx.range_to_end()], &[4, 5]);
/// assert_eq!(idx.to_forward_index(&buf), 4);
/// ```
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct ReverseIndex(usize);
impl ReverseIndex {
/// Returns an index set to the end.
///
/// Note: Indexing this will result in an out of bounds error.
pub fn end() -> Self {
Self(0)
}
/// Returns a struct equivalent to the range `self..`
pub fn range_to_end(self) -> ReverseIndexRange {
ReverseIndexRange(self, ReverseIndex::end())
}
/// Returns a struct equivalent to the range `self..end`
pub fn range_to(self, end: ReverseIndex) -> ReverseIndexRange {
ReverseIndexRange(self, end)
}
/// Transforms this reverse index into a regular index for the given buffer.
pub fn to_forward_index<T>(self, buf: &[T]) -> usize {
buf.len() - self.0
}
/// Returns the number of elements until the end of the range.
pub fn distance_to_end(&self) -> usize {
self.0
}
}
impl Sub<usize> for ReverseIndex {
type Output = Self;
fn sub(self, rhs: usize) -> Self::Output {
Self(self.0 + rhs)
}
}
impl SubAssign<usize> for ReverseIndex {
fn sub_assign(&mut self, rhs: usize) {
*self = *self - rhs;
}
}
impl Add<usize> for ReverseIndex {
type Output = Self;
fn add(self, rhs: usize) -> Self::Output {
Self(self.0 - rhs)
}
}
impl AddAssign<usize> for ReverseIndex {
fn add_assign(&mut self, rhs: usize) {
*self = *self + rhs;
}
}
impl<T> Index<ReverseIndex> for [T] {
type Output = T;
fn index(&self, index: ReverseIndex) -> &Self::Output {
let index = index.to_forward_index(self);
&self[index]
}
}
impl<T> IndexMut<ReverseIndex> for [T] {
fn index_mut(&mut self, index: ReverseIndex) -> &mut Self::Output {
let index = index.to_forward_index(self);
&mut self[index]
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct ReverseIndexRange(ReverseIndex, ReverseIndex);
impl<T> Index<ReverseIndexRange> for [T] {
type Output = [T];
fn index(&self, index: ReverseIndexRange) -> &Self::Output {
let start = index.0.to_forward_index(self);
let end = index.1.to_forward_index(self);
&self[start..end]
}
}
impl<T> IndexMut<ReverseIndexRange> for [T] {
fn index_mut(&mut self, index: ReverseIndexRange) -> &mut Self::Output {
let start = index.0.to_forward_index(self);
let end = index.1.to_forward_index(self);
&mut self[start..end]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reverse_index_test() {
let buf = [0, 1, 2, 3, 4, 5];
let idx = ReverseIndex::end() - 2;
assert_eq!(&buf[idx.range_to_end()], &[4, 5]);
assert_eq!(&buf[idx.range_to(idx + 1)], &[4]);
assert_eq!(idx.to_forward_index(&buf), 4);
}
}

2
rust/flatbuffers/src/lib.rs
View File

@ -48,7 +48,7 @@ mod vtable;
mod vtable_writer; mod vtable_writer;
pub use crate::array::{array_init, emplace_scalar_array, Array}; pub use crate::array::{array_init, emplace_scalar_array, Array};
pub use crate::builder::FlatBufferBuilder; pub use crate::builder::{Allocator, DefaultAllocator, FlatBufferBuilder};
pub use crate::endian_scalar::{emplace_scalar, read_scalar, read_scalar_at, EndianScalar}; pub use crate::endian_scalar::{emplace_scalar, read_scalar, read_scalar_at, EndianScalar};
pub use crate::follow::{Follow, FollowStart}; pub use crate::follow::{Follow, FollowStart};
pub use crate::primitives::*; pub use crate::primitives::*;

2
samples/rust_generated/my_game/sample/equipment_generated.rs
View File

@ -115,7 +115,7 @@ impl EquipmentT {
Self::Weapon(_) => Equipment::Weapon, Self::Weapon(_) => Equipment::Weapon,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::Weapon(v) => Some(v.pack(fbb).as_union_value()), Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),

22
samples/rust_generated/my_game/sample/monster_generated.rs
View File

@ -45,8 +45,8 @@ impl<'a> Monster<'a> {
Monster { _tab: table } Monster { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args MonsterArgs<'args> args: &'args MonsterArgs<'args>
) -> flatbuffers::WIPOffset<Monster<'bldr>> { ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
@ -246,11 +246,11 @@ impl<'a> Default for MonsterArgs<'a> {
} }
} }
pub struct MonsterBuilder<'a: 'b, 'b> { pub struct MonsterBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_pos(&mut self, pos: &Vec3) { pub fn add_pos(&mut self, pos: &Vec3) {
self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos); self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
@ -292,7 +292,7 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
MonsterBuilder { MonsterBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -363,9 +363,9 @@ impl Default for MonsterT {
} }
} }
impl MonsterT { impl MonsterT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Monster<'b>> { ) -> flatbuffers::WIPOffset<Monster<'b>> {
let pos_tmp = self.pos.as_ref().map(|x| x.pack()); let pos_tmp = self.pos.as_ref().map(|x| x.pack());
let pos = pos_tmp.as_ref(); let pos = pos_tmp.as_ref();
@ -461,13 +461,13 @@ pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster {
flatbuffers::size_prefixed_root_unchecked::<Monster>(buf) flatbuffers::size_prefixed_root_unchecked::<Monster>(buf)
} }
#[inline] #[inline]
pub fn finish_monster_buffer<'a, 'b>( pub fn finish_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<Monster<'a>>) { root: flatbuffers::WIPOffset<Monster<'a>>) {
fbb.finish(root, None); fbb.finish(root, None);
} }
#[inline] #[inline]
pub fn finish_size_prefixed_monster_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<Monster<'a>>) { pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Monster<'a>>) {
fbb.finish_size_prefixed(root, None); fbb.finish_size_prefixed(root, None);
} }

16
samples/rust_generated/my_game/sample/weapon_generated.rs
View File

@ -37,8 +37,8 @@ impl<'a> Weapon<'a> {
Weapon { _tab: table } Weapon { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args WeaponArgs<'args> args: &'args WeaponArgs<'args>
) -> flatbuffers::WIPOffset<Weapon<'bldr>> { ) -> flatbuffers::WIPOffset<Weapon<'bldr>> {
let mut builder = WeaponBuilder::new(_fbb); let mut builder = WeaponBuilder::new(_fbb);
@ -101,11 +101,11 @@ impl<'a> Default for WeaponArgs<'a> {
} }
} }
pub struct WeaponBuilder<'a: 'b, 'b> { pub struct WeaponBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> WeaponBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> WeaponBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
@ -115,7 +115,7 @@ impl<'a: 'b, 'b> WeaponBuilder<'a, 'b> {
self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0); self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> WeaponBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
WeaponBuilder { WeaponBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -152,9 +152,9 @@ impl Default for WeaponT {
} }
} }
impl WeaponT { impl WeaponT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Weapon<'b>> { ) -> flatbuffers::WIPOffset<Weapon<'b>> {
let name = self.name.as_ref().map(|x|{ let name = self.name.as_ref().map(|x|{
_fbb.create_string(x) _fbb.create_string(x)

39
src/idl_gen_rust.cpp
View File

@ -989,7 +989,8 @@ class RustGenerator : public BaseGenerator {
code_ += " }"; code_ += " }";
// Pack flatbuffers union value // Pack flatbuffers union value
code_ += code_ +=
" pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder)" " pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut "
"flatbuffers::FlatBufferBuilder<'b, A>)"
" -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>" " -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>"
" {"; " {";
code_ += " match self {"; code_ += " match self {";
@ -1717,8 +1718,11 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("MAYBE_LT", code_.SetValue("MAYBE_LT",
TableBuilderArgsNeedsLifetime(struct_def) ? "<'args>" : ""); TableBuilderArgsNeedsLifetime(struct_def) ? "<'args>" : "");
code_ += " #[allow(unused_mut)]"; code_ += " #[allow(unused_mut)]";
code_ += " pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>("; code_ +=
code_ += " _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,"; " pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: "
"flatbuffers::Allocator + 'bldr>(";
code_ +=
" _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,";
code_ += " {{MAYBE_US}}args: &'args {{STRUCT_TY}}Args{{MAYBE_LT}}"; code_ += " {{MAYBE_US}}args: &'args {{STRUCT_TY}}Args{{MAYBE_LT}}";
code_ += " ) -> flatbuffers::WIPOffset<{{STRUCT_TY}}<'bldr>> {"; code_ += " ) -> flatbuffers::WIPOffset<{{STRUCT_TY}}<'bldr>> {";
@ -2117,15 +2121,20 @@ class RustGenerator : public BaseGenerator {
} }
// Generate a builder struct: // Generate a builder struct:
code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}Builder<'a: 'b, 'b> {"; code_ +=
code_ += " fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,"; "{{ACCESS_TYPE}} struct {{STRUCT_TY}}Builder<'a: 'b, 'b, A: "
"flatbuffers::Allocator + 'a> {";
code_ += " fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,";
code_ += code_ +=
" start_: flatbuffers::WIPOffset<" " start_: flatbuffers::WIPOffset<"
"flatbuffers::TableUnfinishedWIPOffset>,"; "flatbuffers::TableUnfinishedWIPOffset>,";
code_ += "}"; code_ += "}";
// Generate builder functions: // Generate builder functions:
code_ += "impl<'a: 'b, 'b> {{STRUCT_TY}}Builder<'a, 'b> {"; code_ +=
"impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> "
"{{STRUCT_TY}}Builder<'a, "
"'b, A> {";
ForAllTableFields(struct_def, [&](const FieldDef &field) { ForAllTableFields(struct_def, [&](const FieldDef &field) {
const bool is_scalar = IsScalar(field.value.type.base_type); const bool is_scalar = IsScalar(field.value.type.base_type);
std::string offset = namer_.LegacyRustFieldOffsetName(field); std::string offset = namer_.LegacyRustFieldOffsetName(field);
@ -2160,8 +2169,8 @@ class RustGenerator : public BaseGenerator {
// Struct initializer (all fields required); // Struct initializer (all fields required);
code_ += " #[inline]"; code_ += " #[inline]";
code_ += code_ +=
" pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> " " pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> "
"{{STRUCT_TY}}Builder<'a, 'b> {"; "{{STRUCT_TY}}Builder<'a, 'b, A> {";
code_.SetValue("NUM_FIELDS", NumToString(struct_def.fields.vec.size())); code_.SetValue("NUM_FIELDS", NumToString(struct_def.fields.vec.size()));
code_ += " let start = _fbb.start_table();"; code_ += " let start = _fbb.start_table();";
code_ += " {{STRUCT_TY}}Builder {"; code_ += " {{STRUCT_TY}}Builder {";
@ -2264,9 +2273,9 @@ class RustGenerator : public BaseGenerator {
// Generate pack function. // Generate pack function.
code_ += "impl {{STRUCT_OTY}} {"; code_ += "impl {{STRUCT_OTY}} {";
code_ += " pub fn pack<'b>("; code_ += " pub fn pack<'b, A: flatbuffers::Allocator + 'b>(";
code_ += " &self,"; code_ += " &self,";
code_ += " _fbb: &mut flatbuffers::FlatBufferBuilder<'b>"; code_ += " _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>";
code_ += " ) -> flatbuffers::WIPOffset<{{STRUCT_TY}}<'b>> {"; code_ += " ) -> flatbuffers::WIPOffset<{{STRUCT_TY}}<'b>> {";
// First we generate variables for each field and then later assemble them // First we generate variables for each field and then later assemble them
// using "StructArgs" to more easily manage ownership of the builder. // using "StructArgs" to more easily manage ownership of the builder.
@ -2551,8 +2560,10 @@ class RustGenerator : public BaseGenerator {
// Finish a buffer with a given root object: // Finish a buffer with a given root object:
code_ += "#[inline]"; code_ += "#[inline]";
code_ += "pub fn finish_{{STRUCT_FN}}_buffer<'a, 'b>("; code_ +=
code_ += " fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,"; "pub fn finish_{{STRUCT_FN}}_buffer<'a, 'b, A: "
"flatbuffers::Allocator + 'a>(";
code_ += " fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,";
code_ += " root: flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {"; code_ += " root: flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {";
if (parser_.file_identifier_.length()) { if (parser_.file_identifier_.length()) {
code_ += " fbb.finish(root, Some({{STRUCT_CONST}}_IDENTIFIER));"; code_ += " fbb.finish(root, Some({{STRUCT_CONST}}_IDENTIFIER));";
@ -2564,8 +2575,8 @@ class RustGenerator : public BaseGenerator {
code_ += "#[inline]"; code_ += "#[inline]";
code_ += code_ +=
"pub fn finish_size_prefixed_{{STRUCT_FN}}_buffer" "pub fn finish_size_prefixed_{{STRUCT_FN}}_buffer"
"<'a, 'b>(" "<'a, 'b, A: flatbuffers::Allocator + 'a>("
"fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, " "fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, "
"root: flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {"; "root: flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {";
if (parser_.file_identifier_.length()) { if (parser_.file_identifier_.length()) {
code_ += code_ +=

22
tests/arrays_test/my_game/example/array_table_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> ArrayTable<'a> {
ArrayTable { _tab: table } ArrayTable { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ArrayTableArgs<'args> args: &'args ArrayTableArgs<'args>
) -> flatbuffers::WIPOffset<ArrayTable<'bldr>> { ) -> flatbuffers::WIPOffset<ArrayTable<'bldr>> {
let mut builder = ArrayTableBuilder::new(_fbb); let mut builder = ArrayTableBuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for ArrayTableArgs<'a> {
} }
} }
pub struct ArrayTableBuilder<'a: 'b, 'b> { pub struct ArrayTableBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> ArrayTableBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ArrayTableBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_a(&mut self, a: &ArrayStruct) { pub fn add_a(&mut self, a: &ArrayStruct) {
self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a); self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ArrayTableBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayTableBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
ArrayTableBuilder { ArrayTableBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for ArrayTableT {
} }
} }
impl ArrayTableT { impl ArrayTableT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<ArrayTable<'b>> { ) -> flatbuffers::WIPOffset<ArrayTable<'b>> {
let a_tmp = self.a.as_ref().map(|x| x.pack()); let a_tmp = self.a.as_ref().map(|x| x.pack());
let a = a_tmp.as_ref(); let a = a_tmp.as_ref();
@ -217,13 +217,13 @@ pub fn array_table_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
pub const ARRAY_TABLE_EXTENSION: &str = "mon"; pub const ARRAY_TABLE_EXTENSION: &str = "mon";
#[inline] #[inline]
pub fn finish_array_table_buffer<'a, 'b>( pub fn finish_array_table_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<ArrayTable<'a>>) { root: flatbuffers::WIPOffset<ArrayTable<'a>>) {
fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER)); fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER));
} }
#[inline] #[inline]
pub fn finish_size_prefixed_array_table_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<ArrayTable<'a>>) { pub fn finish_size_prefixed_array_table_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<ArrayTable<'a>>) {
fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER)); fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER));
} }

16
tests/include_test1/my_game/other_name_space/table_b_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TableB<'a> {
TableB { _tab: table } TableB { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableBArgs<'args> args: &'args TableBArgs<'args>
) -> flatbuffers::WIPOffset<TableB<'bldr>> { ) -> flatbuffers::WIPOffset<TableB<'bldr>> {
let mut builder = TableBBuilder::new(_fbb); let mut builder = TableBBuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for TableBArgs<'a> {
} }
} }
pub struct TableBBuilder<'a: 'b, 'b> { pub struct TableBBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableBBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) { pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableBBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableBBuilder { TableBBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for TableBT {
} }
} }
impl TableBT { impl TableBT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableB<'b>> { ) -> flatbuffers::WIPOffset<TableB<'b>> {
let a = self.a.as_ref().map(|x|{ let a = self.a.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/include_test1/table_a_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TableA<'a> {
TableA { _tab: table } TableA { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableAArgs<'args> args: &'args TableAArgs<'args>
) -> flatbuffers::WIPOffset<TableA<'bldr>> { ) -> flatbuffers::WIPOffset<TableA<'bldr>> {
let mut builder = TableABuilder::new(_fbb); let mut builder = TableABuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for TableAArgs<'a> {
} }
} }
pub struct TableABuilder<'a: 'b, 'b> { pub struct TableABuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableABuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) { pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableABuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableABuilder { TableABuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for TableAT {
} }
} }
impl TableAT { impl TableAT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableA<'b>> { ) -> flatbuffers::WIPOffset<TableA<'b>> {
let b = self.b.as_ref().map(|x|{ let b = self.b.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/include_test2/my_game/other_name_space/table_b_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TableB<'a> {
TableB { _tab: table } TableB { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableBArgs<'args> args: &'args TableBArgs<'args>
) -> flatbuffers::WIPOffset<TableB<'bldr>> { ) -> flatbuffers::WIPOffset<TableB<'bldr>> {
let mut builder = TableBBuilder::new(_fbb); let mut builder = TableBBuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for TableBArgs<'a> {
} }
} }
pub struct TableBBuilder<'a: 'b, 'b> { pub struct TableBBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableBBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) { pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableBBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableBBuilder { TableBBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for TableBT {
} }
} }
impl TableBT { impl TableBT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableB<'b>> { ) -> flatbuffers::WIPOffset<TableB<'b>> {
let a = self.a.as_ref().map(|x|{ let a = self.a.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/include_test2/table_a_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TableA<'a> {
TableA { _tab: table } TableA { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableAArgs<'args> args: &'args TableAArgs<'args>
) -> flatbuffers::WIPOffset<TableA<'bldr>> { ) -> flatbuffers::WIPOffset<TableA<'bldr>> {
let mut builder = TableABuilder::new(_fbb); let mut builder = TableABuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for TableAArgs<'a> {
} }
} }
pub struct TableABuilder<'a: 'b, 'b> { pub struct TableABuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableABuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) { pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableABuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableABuilder { TableABuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for TableAT {
} }
} }
impl TableAT { impl TableAT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableA<'b>> { ) -> flatbuffers::WIPOffset<TableA<'b>> {
let b = self.b.as_ref().map(|x|{ let b = self.b.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/keyword_test/keyword_test/keywords_in_table_generated.rs
View File

@ -39,8 +39,8 @@ impl<'a> KeywordsInTable<'a> {
KeywordsInTable { _tab: table } KeywordsInTable { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args KeywordsInTableArgs args: &'args KeywordsInTableArgs
) -> flatbuffers::WIPOffset<KeywordsInTable<'bldr>> { ) -> flatbuffers::WIPOffset<KeywordsInTable<'bldr>> {
let mut builder = KeywordsInTableBuilder::new(_fbb); let mut builder = KeywordsInTableBuilder::new(_fbb);
@ -127,11 +127,11 @@ impl<'a> Default for KeywordsInTableArgs {
} }
} }
pub struct KeywordsInTableBuilder<'a: 'b, 'b> { pub struct KeywordsInTableBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> KeywordsInTableBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> KeywordsInTableBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_is(&mut self, is: ABC) { pub fn add_is(&mut self, is: ABC) {
self.fbb_.push_slot::<ABC>(KeywordsInTable::VT_IS, is, ABC::void); self.fbb_.push_slot::<ABC>(KeywordsInTable::VT_IS, is, ABC::void);
@ -149,7 +149,7 @@ impl<'a: 'b, 'b> KeywordsInTableBuilder<'a, 'b> {
self.fbb_.push_slot::<bool>(KeywordsInTable::VT_DEFAULT, default, false); self.fbb_.push_slot::<bool>(KeywordsInTable::VT_DEFAULT, default, false);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> KeywordsInTableBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> KeywordsInTableBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
KeywordsInTableBuilder { KeywordsInTableBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -192,9 +192,9 @@ impl Default for KeywordsInTableT {
} }
} }
impl KeywordsInTableT { impl KeywordsInTableT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<KeywordsInTable<'b>> { ) -> flatbuffers::WIPOffset<KeywordsInTable<'b>> {
let is = self.is; let is = self.is;
let private = self.private; let private = self.private;

2
tests/keyword_test/keyword_test/keywords_in_union_generated.rs
View File

@ -121,7 +121,7 @@ impl KeywordsInUnionT {
Self::Internal(_) => KeywordsInUnion::internal, Self::Internal(_) => KeywordsInUnion::internal,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::Static_(v) => Some(v.pack(fbb).as_union_value()), Self::Static_(v) => Some(v.pack(fbb).as_union_value()),

16
tests/keyword_test/keyword_test/table_2_generated.rs
View File

@ -37,8 +37,8 @@ impl<'a> Table2<'a> {
Table2 { _tab: table } Table2 { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args Table2Args args: &'args Table2Args
) -> flatbuffers::WIPOffset<Table2<'bldr>> { ) -> flatbuffers::WIPOffset<Table2<'bldr>> {
let mut builder = Table2Builder::new(_fbb); let mut builder = Table2Builder::new(_fbb);
@ -145,11 +145,11 @@ impl<'a> Default for Table2Args {
} }
} }
pub struct Table2Builder<'a: 'b, 'b> { pub struct Table2Builder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> Table2Builder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> Table2Builder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_type_type(&mut self, type_type: KeywordsInUnion) { pub fn add_type_type(&mut self, type_type: KeywordsInUnion) {
self.fbb_.push_slot::<KeywordsInUnion>(Table2::VT_TYPE_TYPE, type_type, KeywordsInUnion::NONE); self.fbb_.push_slot::<KeywordsInUnion>(Table2::VT_TYPE_TYPE, type_type, KeywordsInUnion::NONE);
@ -159,7 +159,7 @@ impl<'a: 'b, 'b> Table2Builder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Table2::VT_TYPE_, type_); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Table2::VT_TYPE_, type_);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> Table2Builder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> Table2Builder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
Table2Builder { Table2Builder {
fbb_: _fbb, fbb_: _fbb,
@ -213,9 +213,9 @@ impl Default for Table2T {
} }
} }
impl Table2T { impl Table2T {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Table2<'b>> { ) -> flatbuffers::WIPOffset<Table2<'b>> {
let type_type = self.type_.keywords_in_union_type(); let type_type = self.type_.keywords_in_union_type();
let type_ = self.type_.pack(_fbb); let type_ = self.type_.pack(_fbb);

2
tests/monster_test/my_game/example/any_ambiguous_aliases_generated.rs
View File

@ -127,7 +127,7 @@ impl AnyAmbiguousAliasesT {
Self::M3(_) => AnyAmbiguousAliases::M3, Self::M3(_) => AnyAmbiguousAliases::M3,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::M1(v) => Some(v.pack(fbb).as_union_value()), Self::M1(v) => Some(v.pack(fbb).as_union_value()),

2
tests/monster_test/my_game/example/any_generated.rs
View File

@ -127,7 +127,7 @@ impl AnyT {
Self::MyGameExample2Monster(_) => Any::MyGame_Example2_Monster, Self::MyGameExample2Monster(_) => Any::MyGame_Example2_Monster,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::Monster(v) => Some(v.pack(fbb).as_union_value()), Self::Monster(v) => Some(v.pack(fbb).as_union_value()),

2
tests/monster_test/my_game/example/any_unique_aliases_generated.rs
View File

@ -127,7 +127,7 @@ impl AnyUniqueAliasesT {
Self::M2(_) => AnyUniqueAliases::M2, Self::M2(_) => AnyUniqueAliases::M2,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::M(v) => Some(v.pack(fbb).as_union_value()), Self::M(v) => Some(v.pack(fbb).as_union_value()),

22
tests/monster_test/my_game/example/monster_generated.rs
View File

@ -97,8 +97,8 @@ impl<'a> Monster<'a> {
Monster { _tab: table } Monster { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args MonsterArgs<'args> args: &'args MonsterArgs<'args>
) -> flatbuffers::WIPOffset<Monster<'bldr>> { ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
@ -1210,11 +1210,11 @@ impl<'a> Default for MonsterArgs<'a> {
} }
} }
pub struct MonsterBuilder<'a: 'b, 'b> { pub struct MonsterBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_pos(&mut self, pos: &Vec3) { pub fn add_pos(&mut self, pos: &Vec3) {
self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos); self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
@ -1460,7 +1460,7 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY); self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
MonsterBuilder { MonsterBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -1747,9 +1747,9 @@ impl Default for MonsterT {
} }
} }
impl MonsterT { impl MonsterT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Monster<'b>> { ) -> flatbuffers::WIPOffset<Monster<'b>> {
let pos_tmp = self.pos.as_ref().map(|x| x.pack()); let pos_tmp = self.pos.as_ref().map(|x| x.pack());
let pos = pos_tmp.as_ref(); let pos = pos_tmp.as_ref();
@ -2003,13 +2003,13 @@ pub fn monster_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
pub const MONSTER_EXTENSION: &str = "mon"; pub const MONSTER_EXTENSION: &str = "mon";
#[inline] #[inline]
pub fn finish_monster_buffer<'a, 'b>( pub fn finish_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<Monster<'a>>) { root: flatbuffers::WIPOffset<Monster<'a>>) {
fbb.finish(root, Some(MONSTER_IDENTIFIER)); fbb.finish(root, Some(MONSTER_IDENTIFIER));
} }
#[inline] #[inline]
pub fn finish_size_prefixed_monster_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<Monster<'a>>) { pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Monster<'a>>) {
fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER)); fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER));
} }

16
tests/monster_test/my_game/example/referrable_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> Referrable<'a> {
Referrable { _tab: table } Referrable { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ReferrableArgs args: &'args ReferrableArgs
) -> flatbuffers::WIPOffset<Referrable<'bldr>> { ) -> flatbuffers::WIPOffset<Referrable<'bldr>> {
let mut builder = ReferrableBuilder::new(_fbb); let mut builder = ReferrableBuilder::new(_fbb);
@ -95,17 +95,17 @@ impl<'a> Default for ReferrableArgs {
} }
} }
pub struct ReferrableBuilder<'a: 'b, 'b> { pub struct ReferrableBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> ReferrableBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ReferrableBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_id(&mut self, id: u64) { pub fn add_id(&mut self, id: u64) {
self.fbb_.push_slot::<u64>(Referrable::VT_ID, id, 0); self.fbb_.push_slot::<u64>(Referrable::VT_ID, id, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ReferrableBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ReferrableBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
ReferrableBuilder { ReferrableBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -139,9 +139,9 @@ impl Default for ReferrableT {
} }
} }
impl ReferrableT { impl ReferrableT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Referrable<'b>> { ) -> flatbuffers::WIPOffset<Referrable<'b>> {
let id = self.id; let id = self.id;
Referrable::create(_fbb, &ReferrableArgs{ Referrable::create(_fbb, &ReferrableArgs{

16
tests/monster_test/my_game/example/stat_generated.rs
View File

@ -38,8 +38,8 @@ impl<'a> Stat<'a> {
Stat { _tab: table } Stat { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args StatArgs<'args> args: &'args StatArgs<'args>
) -> flatbuffers::WIPOffset<Stat<'bldr>> { ) -> flatbuffers::WIPOffset<Stat<'bldr>> {
let mut builder = StatBuilder::new(_fbb); let mut builder = StatBuilder::new(_fbb);
@ -125,11 +125,11 @@ impl<'a> Default for StatArgs<'a> {
} }
} }
pub struct StatBuilder<'a: 'b, 'b> { pub struct StatBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> StatBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> StatBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_id(&mut self, id: flatbuffers::WIPOffset<&'b str>) { pub fn add_id(&mut self, id: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Stat::VT_ID, id); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Stat::VT_ID, id);
@ -143,7 +143,7 @@ impl<'a: 'b, 'b> StatBuilder<'a, 'b> {
self.fbb_.push_slot::<u16>(Stat::VT_COUNT, count, 0); self.fbb_.push_slot::<u16>(Stat::VT_COUNT, count, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> StatBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
StatBuilder { StatBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -183,9 +183,9 @@ impl Default for StatT {
} }
} }
impl StatT { impl StatT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Stat<'b>> { ) -> flatbuffers::WIPOffset<Stat<'b>> {
let id = self.id.as_ref().map(|x|{ let id = self.id.as_ref().map(|x|{
_fbb.create_string(x) _fbb.create_string(x)

16
tests/monster_test/my_game/example/test_simple_table_with_enum_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TestSimpleTableWithEnum<'a> {
TestSimpleTableWithEnum { _tab: table } TestSimpleTableWithEnum { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TestSimpleTableWithEnumArgs args: &'args TestSimpleTableWithEnumArgs
) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'bldr>> { ) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'bldr>> {
let mut builder = TestSimpleTableWithEnumBuilder::new(_fbb); let mut builder = TestSimpleTableWithEnumBuilder::new(_fbb);
@ -85,17 +85,17 @@ impl<'a> Default for TestSimpleTableWithEnumArgs {
} }
} }
pub struct TestSimpleTableWithEnumBuilder<'a: 'b, 'b> { pub struct TestSimpleTableWithEnumBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TestSimpleTableWithEnumBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TestSimpleTableWithEnumBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_color(&mut self, color: Color) { pub fn add_color(&mut self, color: Color) {
self.fbb_.push_slot::<Color>(TestSimpleTableWithEnum::VT_COLOR, color, Color::Green); self.fbb_.push_slot::<Color>(TestSimpleTableWithEnum::VT_COLOR, color, Color::Green);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TestSimpleTableWithEnumBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TestSimpleTableWithEnumBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TestSimpleTableWithEnumBuilder { TestSimpleTableWithEnumBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -129,9 +129,9 @@ impl Default for TestSimpleTableWithEnumT {
} }
} }
impl TestSimpleTableWithEnumT { impl TestSimpleTableWithEnumT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'b>> { ) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'b>> {
let color = self.color; let color = self.color;
TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{ TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{

16
tests/monster_test/my_game/example/type_aliases_generated.rs
View File

@ -47,8 +47,8 @@ impl<'a> TypeAliases<'a> {
TypeAliases { _tab: table } TypeAliases { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TypeAliasesArgs<'args> args: &'args TypeAliasesArgs<'args>
) -> flatbuffers::WIPOffset<TypeAliases<'bldr>> { ) -> flatbuffers::WIPOffset<TypeAliases<'bldr>> {
let mut builder = TypeAliasesBuilder::new(_fbb); let mut builder = TypeAliasesBuilder::new(_fbb);
@ -243,11 +243,11 @@ impl<'a> Default for TypeAliasesArgs<'a> {
} }
} }
pub struct TypeAliasesBuilder<'a: 'b, 'b> { pub struct TypeAliasesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TypeAliasesBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TypeAliasesBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_i8_(&mut self, i8_: i8) { pub fn add_i8_(&mut self, i8_: i8) {
self.fbb_.push_slot::<i8>(TypeAliases::VT_I8_, i8_, 0); self.fbb_.push_slot::<i8>(TypeAliases::VT_I8_, i8_, 0);
@ -297,7 +297,7 @@ impl<'a: 'b, 'b> TypeAliasesBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TypeAliasesBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TypeAliasesBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TypeAliasesBuilder { TypeAliasesBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -364,9 +364,9 @@ impl Default for TypeAliasesT {
} }
} }
impl TypeAliasesT { impl TypeAliasesT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TypeAliases<'b>> { ) -> flatbuffers::WIPOffset<TypeAliases<'b>> {
let i8_ = self.i8_; let i8_ = self.i8_;
let u8_ = self.u8_; let u8_ = self.u8_;

16
tests/monster_test/my_game/example_2/monster_generated.rs
View File

@ -35,8 +35,8 @@ impl<'a> Monster<'a> {
Monster { _tab: table } Monster { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args MonsterArgs _args: &'args MonsterArgs
) -> flatbuffers::WIPOffset<Monster<'bldr>> { ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
@ -70,13 +70,13 @@ impl<'a> Default for MonsterArgs {
} }
} }
pub struct MonsterBuilder<'a: 'b, 'b> { pub struct MonsterBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
MonsterBuilder { MonsterBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -107,9 +107,9 @@ impl Default for MonsterT {
} }
} }
impl MonsterT { impl MonsterT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Monster<'b>> { ) -> flatbuffers::WIPOffset<Monster<'b>> {
Monster::create(_fbb, &MonsterArgs{ Monster::create(_fbb, &MonsterArgs{
}) })

16
tests/monster_test/my_game/in_parent_namespace_generated.rs
View File

@ -35,8 +35,8 @@ impl<'a> InParentNamespace<'a> {
InParentNamespace { _tab: table } InParentNamespace { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args InParentNamespaceArgs _args: &'args InParentNamespaceArgs
) -> flatbuffers::WIPOffset<InParentNamespace<'bldr>> { ) -> flatbuffers::WIPOffset<InParentNamespace<'bldr>> {
let mut builder = InParentNamespaceBuilder::new(_fbb); let mut builder = InParentNamespaceBuilder::new(_fbb);
@ -70,13 +70,13 @@ impl<'a> Default for InParentNamespaceArgs {
} }
} }
pub struct InParentNamespaceBuilder<'a: 'b, 'b> { pub struct InParentNamespaceBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> InParentNamespaceBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> InParentNamespaceBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> InParentNamespaceBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> InParentNamespaceBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
InParentNamespaceBuilder { InParentNamespaceBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -107,9 +107,9 @@ impl Default for InParentNamespaceT {
} }
} }
impl InParentNamespaceT { impl InParentNamespaceT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<InParentNamespace<'b>> { ) -> flatbuffers::WIPOffset<InParentNamespace<'b>> {
InParentNamespace::create(_fbb, &InParentNamespaceArgs{ InParentNamespace::create(_fbb, &InParentNamespaceArgs{
}) })

16
tests/monster_test/my_game/other_name_space/table_b_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TableB<'a> {
TableB { _tab: table } TableB { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableBArgs<'args> args: &'args TableBArgs<'args>
) -> flatbuffers::WIPOffset<TableB<'bldr>> { ) -> flatbuffers::WIPOffset<TableB<'bldr>> {
let mut builder = TableBBuilder::new(_fbb); let mut builder = TableBBuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for TableBArgs<'a> {
} }
} }
pub struct TableBBuilder<'a: 'b, 'b> { pub struct TableBBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableBBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) { pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableBBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableBBuilder { TableBBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for TableBT {
} }
} }
impl TableBT { impl TableBT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableB<'b>> { ) -> flatbuffers::WIPOffset<TableB<'b>> {
let a = self.a.as_ref().map(|x|{ let a = self.a.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/monster_test/table_a_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TableA<'a> {
TableA { _tab: table } TableA { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableAArgs<'args> args: &'args TableAArgs<'args>
) -> flatbuffers::WIPOffset<TableA<'bldr>> { ) -> flatbuffers::WIPOffset<TableA<'bldr>> {
let mut builder = TableABuilder::new(_fbb); let mut builder = TableABuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for TableAArgs<'a> {
} }
} }
pub struct TableABuilder<'a: 'b, 'b> { pub struct TableABuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableABuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) { pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableABuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableABuilder { TableABuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for TableAT {
} }
} }
impl TableAT { impl TableAT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableA<'b>> { ) -> flatbuffers::WIPOffset<TableA<'b>> {
let b = self.b.as_ref().map(|x|{ let b = self.b.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

2
tests/monster_test_serialize/my_game/example/any_ambiguous_aliases_generated.rs
View File

@ -138,7 +138,7 @@ impl AnyAmbiguousAliasesT {
Self::M3(_) => AnyAmbiguousAliases::M3, Self::M3(_) => AnyAmbiguousAliases::M3,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::M1(v) => Some(v.pack(fbb).as_union_value()), Self::M1(v) => Some(v.pack(fbb).as_union_value()),

2
tests/monster_test_serialize/my_game/example/any_generated.rs
View File

@ -138,7 +138,7 @@ impl AnyT {
Self::MyGameExample2Monster(_) => Any::MyGame_Example2_Monster, Self::MyGameExample2Monster(_) => Any::MyGame_Example2_Monster,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::Monster(v) => Some(v.pack(fbb).as_union_value()), Self::Monster(v) => Some(v.pack(fbb).as_union_value()),

2
tests/monster_test_serialize/my_game/example/any_unique_aliases_generated.rs
View File

@ -138,7 +138,7 @@ impl AnyUniqueAliasesT {
Self::M2(_) => AnyUniqueAliases::M2, Self::M2(_) => AnyUniqueAliases::M2,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::M(v) => Some(v.pack(fbb).as_union_value()), Self::M(v) => Some(v.pack(fbb).as_union_value()),

22
tests/monster_test_serialize/my_game/example/monster_generated.rs
View File

@ -99,8 +99,8 @@ impl<'a> Monster<'a> {
Monster { _tab: table } Monster { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args MonsterArgs<'args> args: &'args MonsterArgs<'args>
) -> flatbuffers::WIPOffset<Monster<'bldr>> { ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
@ -1437,11 +1437,11 @@ impl Serialize for Monster<'_> {
} }
} }
pub struct MonsterBuilder<'a: 'b, 'b> { pub struct MonsterBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_pos(&mut self, pos: &Vec3) { pub fn add_pos(&mut self, pos: &Vec3) {
self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos); self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
@ -1687,7 +1687,7 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY); self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
MonsterBuilder { MonsterBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -1974,9 +1974,9 @@ impl Default for MonsterT {
} }
} }
impl MonsterT { impl MonsterT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Monster<'b>> { ) -> flatbuffers::WIPOffset<Monster<'b>> {
let pos_tmp = self.pos.as_ref().map(|x| x.pack()); let pos_tmp = self.pos.as_ref().map(|x| x.pack());
let pos = pos_tmp.as_ref(); let pos = pos_tmp.as_ref();
@ -2230,13 +2230,13 @@ pub fn monster_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
pub const MONSTER_EXTENSION: &str = "mon"; pub const MONSTER_EXTENSION: &str = "mon";
#[inline] #[inline]
pub fn finish_monster_buffer<'a, 'b>( pub fn finish_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<Monster<'a>>) { root: flatbuffers::WIPOffset<Monster<'a>>) {
fbb.finish(root, Some(MONSTER_IDENTIFIER)); fbb.finish(root, Some(MONSTER_IDENTIFIER));
} }
#[inline] #[inline]
pub fn finish_size_prefixed_monster_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<Monster<'a>>) { pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Monster<'a>>) {
fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER)); fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER));
} }

16
tests/monster_test_serialize/my_game/example/referrable_generated.rs
View File

@ -38,8 +38,8 @@ impl<'a> Referrable<'a> {
Referrable { _tab: table } Referrable { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ReferrableArgs args: &'args ReferrableArgs
) -> flatbuffers::WIPOffset<Referrable<'bldr>> { ) -> flatbuffers::WIPOffset<Referrable<'bldr>> {
let mut builder = ReferrableBuilder::new(_fbb); let mut builder = ReferrableBuilder::new(_fbb);
@ -108,17 +108,17 @@ impl Serialize for Referrable<'_> {
} }
} }
pub struct ReferrableBuilder<'a: 'b, 'b> { pub struct ReferrableBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> ReferrableBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ReferrableBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_id(&mut self, id: u64) { pub fn add_id(&mut self, id: u64) {
self.fbb_.push_slot::<u64>(Referrable::VT_ID, id, 0); self.fbb_.push_slot::<u64>(Referrable::VT_ID, id, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ReferrableBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ReferrableBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
ReferrableBuilder { ReferrableBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -152,9 +152,9 @@ impl Default for ReferrableT {
} }
} }
impl ReferrableT { impl ReferrableT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Referrable<'b>> { ) -> flatbuffers::WIPOffset<Referrable<'b>> {
let id = self.id; let id = self.id;
Referrable::create(_fbb, &ReferrableArgs{ Referrable::create(_fbb, &ReferrableArgs{

16
tests/monster_test_serialize/my_game/example/stat_generated.rs
View File

@ -40,8 +40,8 @@ impl<'a> Stat<'a> {
Stat { _tab: table } Stat { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args StatArgs<'args> args: &'args StatArgs<'args>
) -> flatbuffers::WIPOffset<Stat<'bldr>> { ) -> flatbuffers::WIPOffset<Stat<'bldr>> {
let mut builder = StatBuilder::new(_fbb); let mut builder = StatBuilder::new(_fbb);
@ -144,11 +144,11 @@ impl Serialize for Stat<'_> {
} }
} }
pub struct StatBuilder<'a: 'b, 'b> { pub struct StatBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> StatBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> StatBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_id(&mut self, id: flatbuffers::WIPOffset<&'b str>) { pub fn add_id(&mut self, id: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Stat::VT_ID, id); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Stat::VT_ID, id);
@ -162,7 +162,7 @@ impl<'a: 'b, 'b> StatBuilder<'a, 'b> {
self.fbb_.push_slot::<u16>(Stat::VT_COUNT, count, 0); self.fbb_.push_slot::<u16>(Stat::VT_COUNT, count, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> StatBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
StatBuilder { StatBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -202,9 +202,9 @@ impl Default for StatT {
} }
} }
impl StatT { impl StatT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Stat<'b>> { ) -> flatbuffers::WIPOffset<Stat<'b>> {
let id = self.id.as_ref().map(|x|{ let id = self.id.as_ref().map(|x|{
_fbb.create_string(x) _fbb.create_string(x)

16
tests/monster_test_serialize/my_game/example/test_simple_table_with_enum_generated.rs
View File

@ -38,8 +38,8 @@ impl<'a> TestSimpleTableWithEnum<'a> {
TestSimpleTableWithEnum { _tab: table } TestSimpleTableWithEnum { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TestSimpleTableWithEnumArgs args: &'args TestSimpleTableWithEnumArgs
) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'bldr>> { ) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'bldr>> {
let mut builder = TestSimpleTableWithEnumBuilder::new(_fbb); let mut builder = TestSimpleTableWithEnumBuilder::new(_fbb);
@ -98,17 +98,17 @@ impl Serialize for TestSimpleTableWithEnum<'_> {
} }
} }
pub struct TestSimpleTableWithEnumBuilder<'a: 'b, 'b> { pub struct TestSimpleTableWithEnumBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TestSimpleTableWithEnumBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TestSimpleTableWithEnumBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_color(&mut self, color: Color) { pub fn add_color(&mut self, color: Color) {
self.fbb_.push_slot::<Color>(TestSimpleTableWithEnum::VT_COLOR, color, Color::Green); self.fbb_.push_slot::<Color>(TestSimpleTableWithEnum::VT_COLOR, color, Color::Green);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TestSimpleTableWithEnumBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TestSimpleTableWithEnumBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TestSimpleTableWithEnumBuilder { TestSimpleTableWithEnumBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -142,9 +142,9 @@ impl Default for TestSimpleTableWithEnumT {
} }
} }
impl TestSimpleTableWithEnumT { impl TestSimpleTableWithEnumT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'b>> { ) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'b>> {
let color = self.color; let color = self.color;
TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{ TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{

16
tests/monster_test_serialize/my_game/example/type_aliases_generated.rs
View File

@ -49,8 +49,8 @@ impl<'a> TypeAliases<'a> {
TypeAliases { _tab: table } TypeAliases { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TypeAliasesArgs<'args> args: &'args TypeAliasesArgs<'args>
) -> flatbuffers::WIPOffset<TypeAliases<'bldr>> { ) -> flatbuffers::WIPOffset<TypeAliases<'bldr>> {
let mut builder = TypeAliasesBuilder::new(_fbb); let mut builder = TypeAliasesBuilder::new(_fbb);
@ -275,11 +275,11 @@ impl Serialize for TypeAliases<'_> {
} }
} }
pub struct TypeAliasesBuilder<'a: 'b, 'b> { pub struct TypeAliasesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TypeAliasesBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TypeAliasesBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_i8_(&mut self, i8_: i8) { pub fn add_i8_(&mut self, i8_: i8) {
self.fbb_.push_slot::<i8>(TypeAliases::VT_I8_, i8_, 0); self.fbb_.push_slot::<i8>(TypeAliases::VT_I8_, i8_, 0);
@ -329,7 +329,7 @@ impl<'a: 'b, 'b> TypeAliasesBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TypeAliasesBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TypeAliasesBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TypeAliasesBuilder { TypeAliasesBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -396,9 +396,9 @@ impl Default for TypeAliasesT {
} }
} }
impl TypeAliasesT { impl TypeAliasesT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TypeAliases<'b>> { ) -> flatbuffers::WIPOffset<TypeAliases<'b>> {
let i8_ = self.i8_; let i8_ = self.i8_;
let u8_ = self.u8_; let u8_ = self.u8_;

16
tests/monster_test_serialize/my_game/example_2/monster_generated.rs
View File

@ -37,8 +37,8 @@ impl<'a> Monster<'a> {
Monster { _tab: table } Monster { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args MonsterArgs _args: &'args MonsterArgs
) -> flatbuffers::WIPOffset<Monster<'bldr>> { ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
@ -82,13 +82,13 @@ impl Serialize for Monster<'_> {
} }
} }
pub struct MonsterBuilder<'a: 'b, 'b> { pub struct MonsterBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
MonsterBuilder { MonsterBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -119,9 +119,9 @@ impl Default for MonsterT {
} }
} }
impl MonsterT { impl MonsterT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Monster<'b>> { ) -> flatbuffers::WIPOffset<Monster<'b>> {
Monster::create(_fbb, &MonsterArgs{ Monster::create(_fbb, &MonsterArgs{
}) })

16
tests/monster_test_serialize/my_game/in_parent_namespace_generated.rs
View File

@ -37,8 +37,8 @@ impl<'a> InParentNamespace<'a> {
InParentNamespace { _tab: table } InParentNamespace { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args InParentNamespaceArgs _args: &'args InParentNamespaceArgs
) -> flatbuffers::WIPOffset<InParentNamespace<'bldr>> { ) -> flatbuffers::WIPOffset<InParentNamespace<'bldr>> {
let mut builder = InParentNamespaceBuilder::new(_fbb); let mut builder = InParentNamespaceBuilder::new(_fbb);
@ -82,13 +82,13 @@ impl Serialize for InParentNamespace<'_> {
} }
} }
pub struct InParentNamespaceBuilder<'a: 'b, 'b> { pub struct InParentNamespaceBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> InParentNamespaceBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> InParentNamespaceBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> InParentNamespaceBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> InParentNamespaceBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
InParentNamespaceBuilder { InParentNamespaceBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -119,9 +119,9 @@ impl Default for InParentNamespaceT {
} }
} }
impl InParentNamespaceT { impl InParentNamespaceT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<InParentNamespace<'b>> { ) -> flatbuffers::WIPOffset<InParentNamespace<'b>> {
InParentNamespace::create(_fbb, &InParentNamespaceArgs{ InParentNamespace::create(_fbb, &InParentNamespaceArgs{
}) })

16
tests/monster_test_serialize/my_game/other_name_space/table_b_generated.rs
View File

@ -38,8 +38,8 @@ impl<'a> TableB<'a> {
TableB { _tab: table } TableB { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableBArgs<'args> args: &'args TableBArgs<'args>
) -> flatbuffers::WIPOffset<TableB<'bldr>> { ) -> flatbuffers::WIPOffset<TableB<'bldr>> {
let mut builder = TableBBuilder::new(_fbb); let mut builder = TableBBuilder::new(_fbb);
@ -104,17 +104,17 @@ impl Serialize for TableB<'_> {
} }
} }
pub struct TableBBuilder<'a: 'b, 'b> { pub struct TableBBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableBBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) { pub fn add_a(&mut self, a: flatbuffers::WIPOffset<super::super::TableA<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableBBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableBBuilder { TableBBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -148,9 +148,9 @@ impl Default for TableBT {
} }
} }
impl TableBT { impl TableBT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableB<'b>> { ) -> flatbuffers::WIPOffset<TableB<'b>> {
let a = self.a.as_ref().map(|x|{ let a = self.a.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/monster_test_serialize/table_a_generated.rs
View File

@ -38,8 +38,8 @@ impl<'a> TableA<'a> {
TableA { _tab: table } TableA { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableAArgs<'args> args: &'args TableAArgs<'args>
) -> flatbuffers::WIPOffset<TableA<'bldr>> { ) -> flatbuffers::WIPOffset<TableA<'bldr>> {
let mut builder = TableABuilder::new(_fbb); let mut builder = TableABuilder::new(_fbb);
@ -104,17 +104,17 @@ impl Serialize for TableA<'_> {
} }
} }
pub struct TableABuilder<'a: 'b, 'b> { pub struct TableABuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableABuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) { pub fn add_b(&mut self, b: flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableABuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableABuilder { TableABuilder {
fbb_: _fbb, fbb_: _fbb,
@ -148,9 +148,9 @@ impl Default for TableAT {
} }
} }
impl TableAT { impl TableAT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableA<'b>> { ) -> flatbuffers::WIPOffset<TableA<'b>> {
let b = self.b.as_ref().map(|x|{ let b = self.b.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/more_defaults/more_defaults_generated.rs
View File

@ -41,8 +41,8 @@ impl<'a> MoreDefaults<'a> {
MoreDefaults { _tab: table } MoreDefaults { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args MoreDefaultsArgs<'args> args: &'args MoreDefaultsArgs<'args>
) -> flatbuffers::WIPOffset<MoreDefaults<'bldr>> { ) -> flatbuffers::WIPOffset<MoreDefaults<'bldr>> {
let mut builder = MoreDefaultsBuilder::new(_fbb); let mut builder = MoreDefaultsBuilder::new(_fbb);
@ -173,11 +173,11 @@ impl<'a> Default for MoreDefaultsArgs<'a> {
} }
} }
pub struct MoreDefaultsBuilder<'a: 'b, 'b> { pub struct MoreDefaultsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> MoreDefaultsBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> MoreDefaultsBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_ints(&mut self, ints: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i32>>) { pub fn add_ints(&mut self, ints: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i32>>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_INTS, ints); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_INTS, ints);
@ -203,7 +203,7 @@ impl<'a: 'b, 'b> MoreDefaultsBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_BOOLS, bools); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_BOOLS, bools);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MoreDefaultsBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MoreDefaultsBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
MoreDefaultsBuilder { MoreDefaultsBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -252,9 +252,9 @@ impl Default for MoreDefaultsT {
} }
} }
impl MoreDefaultsT { impl MoreDefaultsT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<MoreDefaults<'b>> { ) -> flatbuffers::WIPOffset<MoreDefaults<'b>> {
let ints = Some({ let ints = Some({
let x = &self.ints; let x = &self.ints;

16
tests/namespace_test/namespace_a/namespace_b/table_in_nested_ns_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> TableInNestedNS<'a> {
TableInNestedNS { _tab: table } TableInNestedNS { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableInNestedNSArgs args: &'args TableInNestedNSArgs
) -> flatbuffers::WIPOffset<TableInNestedNS<'bldr>> { ) -> flatbuffers::WIPOffset<TableInNestedNS<'bldr>> {
let mut builder = TableInNestedNSBuilder::new(_fbb); let mut builder = TableInNestedNSBuilder::new(_fbb);
@ -85,17 +85,17 @@ impl<'a> Default for TableInNestedNSArgs {
} }
} }
pub struct TableInNestedNSBuilder<'a: 'b, 'b> { pub struct TableInNestedNSBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableInNestedNSBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableInNestedNSBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_foo(&mut self, foo: i32) { pub fn add_foo(&mut self, foo: i32) {
self.fbb_.push_slot::<i32>(TableInNestedNS::VT_FOO, foo, 0); self.fbb_.push_slot::<i32>(TableInNestedNS::VT_FOO, foo, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableInNestedNSBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableInNestedNSBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableInNestedNSBuilder { TableInNestedNSBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -129,9 +129,9 @@ impl Default for TableInNestedNST {
} }
} }
impl TableInNestedNST { impl TableInNestedNST {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableInNestedNS<'b>> { ) -> flatbuffers::WIPOffset<TableInNestedNS<'b>> {
let foo = self.foo; let foo = self.foo;
TableInNestedNS::create(_fbb, &TableInNestedNSArgs{ TableInNestedNS::create(_fbb, &TableInNestedNSArgs{

2
tests/namespace_test/namespace_a/namespace_b/union_in_nested_ns_generated.rs
View File

@ -115,7 +115,7 @@ impl UnionInNestedNST {
Self::TableInNestedNS(_) => UnionInNestedNS::TableInNestedNS, Self::TableInNestedNS(_) => UnionInNestedNS::TableInNestedNS,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::TableInNestedNS(v) => Some(v.pack(fbb).as_union_value()), Self::TableInNestedNS(v) => Some(v.pack(fbb).as_union_value()),

16
tests/namespace_test/namespace_a/second_table_in_a_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> SecondTableInA<'a> {
SecondTableInA { _tab: table } SecondTableInA { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args SecondTableInAArgs<'args> args: &'args SecondTableInAArgs<'args>
) -> flatbuffers::WIPOffset<SecondTableInA<'bldr>> { ) -> flatbuffers::WIPOffset<SecondTableInA<'bldr>> {
let mut builder = SecondTableInABuilder::new(_fbb); let mut builder = SecondTableInABuilder::new(_fbb);
@ -87,17 +87,17 @@ impl<'a> Default for SecondTableInAArgs<'a> {
} }
} }
pub struct SecondTableInABuilder<'a: 'b, 'b> { pub struct SecondTableInABuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> SecondTableInABuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> SecondTableInABuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_refer_to_c(&mut self, refer_to_c: flatbuffers::WIPOffset<super::namespace_c::TableInC<'b >>) { pub fn add_refer_to_c(&mut self, refer_to_c: flatbuffers::WIPOffset<super::namespace_c::TableInC<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::namespace_c::TableInC>>(SecondTableInA::VT_REFER_TO_C, refer_to_c); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::namespace_c::TableInC>>(SecondTableInA::VT_REFER_TO_C, refer_to_c);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SecondTableInABuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SecondTableInABuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
SecondTableInABuilder { SecondTableInABuilder {
fbb_: _fbb, fbb_: _fbb,
@ -131,9 +131,9 @@ impl Default for SecondTableInAT {
} }
} }
impl SecondTableInAT { impl SecondTableInAT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<SecondTableInA<'b>> { ) -> flatbuffers::WIPOffset<SecondTableInA<'b>> {
let refer_to_c = self.refer_to_c.as_ref().map(|x|{ let refer_to_c = self.refer_to_c.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/namespace_test/namespace_a/table_in_first_ns_generated.rs
View File

@ -40,8 +40,8 @@ impl<'a> TableInFirstNS<'a> {
TableInFirstNS { _tab: table } TableInFirstNS { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableInFirstNSArgs<'args> args: &'args TableInFirstNSArgs<'args>
) -> flatbuffers::WIPOffset<TableInFirstNS<'bldr>> { ) -> flatbuffers::WIPOffset<TableInFirstNS<'bldr>> {
let mut builder = TableInFirstNSBuilder::new(_fbb); let mut builder = TableInFirstNSBuilder::new(_fbb);
@ -170,11 +170,11 @@ impl<'a> Default for TableInFirstNSArgs<'a> {
} }
} }
pub struct TableInFirstNSBuilder<'a: 'b, 'b> { pub struct TableInFirstNSBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableInFirstNSBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableInFirstNSBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_foo_table(&mut self, foo_table: flatbuffers::WIPOffset<namespace_b::TableInNestedNS<'b >>) { pub fn add_foo_table(&mut self, foo_table: flatbuffers::WIPOffset<namespace_b::TableInNestedNS<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<namespace_b::TableInNestedNS>>(TableInFirstNS::VT_FOO_TABLE, foo_table); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<namespace_b::TableInNestedNS>>(TableInFirstNS::VT_FOO_TABLE, foo_table);
@ -196,7 +196,7 @@ impl<'a: 'b, 'b> TableInFirstNSBuilder<'a, 'b> {
self.fbb_.push_slot_always::<&namespace_b::StructInNestedNS>(TableInFirstNS::VT_FOO_STRUCT, foo_struct); self.fbb_.push_slot_always::<&namespace_b::StructInNestedNS>(TableInFirstNS::VT_FOO_STRUCT, foo_struct);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableInFirstNSBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableInFirstNSBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableInFirstNSBuilder { TableInFirstNSBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -252,9 +252,9 @@ impl Default for TableInFirstNST {
} }
} }
impl TableInFirstNST { impl TableInFirstNST {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableInFirstNS<'b>> { ) -> flatbuffers::WIPOffset<TableInFirstNS<'b>> {
let foo_table = self.foo_table.as_ref().map(|x|{ let foo_table = self.foo_table.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

16
tests/namespace_test/namespace_c/table_in_c_generated.rs
View File

@ -37,8 +37,8 @@ impl<'a> TableInC<'a> {
TableInC { _tab: table } TableInC { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TableInCArgs<'args> args: &'args TableInCArgs<'args>
) -> flatbuffers::WIPOffset<TableInC<'bldr>> { ) -> flatbuffers::WIPOffset<TableInC<'bldr>> {
let mut builder = TableInCBuilder::new(_fbb); let mut builder = TableInCBuilder::new(_fbb);
@ -103,11 +103,11 @@ impl<'a> Default for TableInCArgs<'a> {
} }
} }
pub struct TableInCBuilder<'a: 'b, 'b> { pub struct TableInCBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> TableInCBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TableInCBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_refer_to_a1(&mut self, refer_to_a1: flatbuffers::WIPOffset<super::namespace_a::TableInFirstNS<'b >>) { pub fn add_refer_to_a1(&mut self, refer_to_a1: flatbuffers::WIPOffset<super::namespace_a::TableInFirstNS<'b >>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::namespace_a::TableInFirstNS>>(TableInC::VT_REFER_TO_A1, refer_to_a1); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::namespace_a::TableInFirstNS>>(TableInC::VT_REFER_TO_A1, refer_to_a1);
@ -117,7 +117,7 @@ impl<'a: 'b, 'b> TableInCBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::namespace_a::SecondTableInA>>(TableInC::VT_REFER_TO_A2, refer_to_a2); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::namespace_a::SecondTableInA>>(TableInC::VT_REFER_TO_A2, refer_to_a2);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TableInCBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TableInCBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
TableInCBuilder { TableInCBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -154,9 +154,9 @@ impl Default for TableInCT {
} }
} }
impl TableInCT { impl TableInCT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<TableInC<'b>> { ) -> flatbuffers::WIPOffset<TableInC<'b>> {
let refer_to_a1 = self.refer_to_a1.as_ref().map(|x|{ let refer_to_a1 = self.refer_to_a1.as_ref().map(|x|{
x.pack(_fbb) x.pack(_fbb)

22
tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs
View File

@ -71,8 +71,8 @@ impl<'a> ScalarStuff<'a> {
ScalarStuff { _tab: table } ScalarStuff { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ScalarStuffArgs args: &'args ScalarStuffArgs
) -> flatbuffers::WIPOffset<ScalarStuff<'bldr>> { ) -> flatbuffers::WIPOffset<ScalarStuff<'bldr>> {
let mut builder = ScalarStuffBuilder::new(_fbb); let mut builder = ScalarStuffBuilder::new(_fbb);
@ -575,11 +575,11 @@ impl<'a> Default for ScalarStuffArgs {
} }
} }
pub struct ScalarStuffBuilder<'a: 'b, 'b> { pub struct ScalarStuffBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> ScalarStuffBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ScalarStuffBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_just_i8(&mut self, just_i8: i8) { pub fn add_just_i8(&mut self, just_i8: i8) {
self.fbb_.push_slot::<i8>(ScalarStuff::VT_JUST_I8, just_i8, 0); self.fbb_.push_slot::<i8>(ScalarStuff::VT_JUST_I8, just_i8, 0);
@ -725,7 +725,7 @@ impl<'a: 'b, 'b> ScalarStuffBuilder<'a, 'b> {
self.fbb_.push_slot::<OptionalByte>(ScalarStuff::VT_DEFAULT_ENUM, default_enum, OptionalByte::One); self.fbb_.push_slot::<OptionalByte>(ScalarStuff::VT_DEFAULT_ENUM, default_enum, OptionalByte::One);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ScalarStuffBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ScalarStuffBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
ScalarStuffBuilder { ScalarStuffBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -864,9 +864,9 @@ impl Default for ScalarStuffT {
} }
} }
impl ScalarStuffT { impl ScalarStuffT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<ScalarStuff<'b>> { ) -> flatbuffers::WIPOffset<ScalarStuff<'b>> {
let just_i8 = self.just_i8; let just_i8 = self.just_i8;
let maybe_i8 = self.maybe_i8; let maybe_i8 = self.maybe_i8;
@ -1019,13 +1019,13 @@ pub fn scalar_stuff_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
pub const SCALAR_STUFF_EXTENSION: &str = "mon"; pub const SCALAR_STUFF_EXTENSION: &str = "mon";
#[inline] #[inline]
pub fn finish_scalar_stuff_buffer<'a, 'b>( pub fn finish_scalar_stuff_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<ScalarStuff<'a>>) { root: flatbuffers::WIPOffset<ScalarStuff<'a>>) {
fbb.finish(root, Some(SCALAR_STUFF_IDENTIFIER)); fbb.finish(root, Some(SCALAR_STUFF_IDENTIFIER));
} }
#[inline] #[inline]
pub fn finish_size_prefixed_scalar_stuff_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<ScalarStuff<'a>>) { pub fn finish_size_prefixed_scalar_stuff_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<ScalarStuff<'a>>) {
fbb.finish_size_prefixed(root, Some(SCALAR_STUFF_IDENTIFIER)); fbb.finish_size_prefixed(root, Some(SCALAR_STUFF_IDENTIFIER));
} }

16
tests/private_annotation_test/annotations_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> Annotations<'a> {
Annotations { _tab: table } Annotations { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args AnnotationsArgs args: &'args AnnotationsArgs
) -> flatbuffers::WIPOffset<Annotations<'bldr>> { ) -> flatbuffers::WIPOffset<Annotations<'bldr>> {
let mut builder = AnnotationsBuilder::new(_fbb); let mut builder = AnnotationsBuilder::new(_fbb);
@ -85,17 +85,17 @@ impl<'a> Default for AnnotationsArgs {
} }
} }
pub(crate) struct AnnotationsBuilder<'a: 'b, 'b> { pub(crate) struct AnnotationsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> AnnotationsBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> AnnotationsBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_value(&mut self, value: i32) { pub fn add_value(&mut self, value: i32) {
self.fbb_.push_slot::<i32>(Annotations::VT_VALUE, value, 0); self.fbb_.push_slot::<i32>(Annotations::VT_VALUE, value, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AnnotationsBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AnnotationsBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
AnnotationsBuilder { AnnotationsBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -129,9 +129,9 @@ impl Default for AnnotationsT {
} }
} }
impl AnnotationsT { impl AnnotationsT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Annotations<'b>> { ) -> flatbuffers::WIPOffset<Annotations<'b>> {
let value = self.value; let value = self.value;
Annotations::create(_fbb, &AnnotationsArgs{ Annotations::create(_fbb, &AnnotationsArgs{

2
tests/private_annotation_test/any_generated.rs
View File

@ -121,7 +121,7 @@ impl AnyT {
Self::Annotations(_) => Any::Annotations, Self::Annotations(_) => Any::Annotations,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::Game(v) => Some(v.pack(fbb).as_union_value()), Self::Game(v) => Some(v.pack(fbb).as_union_value()),

16
tests/private_annotation_test/game_generated.rs
View File

@ -36,8 +36,8 @@ impl<'a> Game<'a> {
Game { _tab: table } Game { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args GameArgs args: &'args GameArgs
) -> flatbuffers::WIPOffset<Game<'bldr>> { ) -> flatbuffers::WIPOffset<Game<'bldr>> {
let mut builder = GameBuilder::new(_fbb); let mut builder = GameBuilder::new(_fbb);
@ -85,17 +85,17 @@ impl<'a> Default for GameArgs {
} }
} }
pub(crate) struct GameBuilder<'a: 'b, 'b> { pub(crate) struct GameBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> GameBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GameBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_value(&mut self, value: i32) { pub fn add_value(&mut self, value: i32) {
self.fbb_.push_slot::<i32>(Game::VT_VALUE, value, 0); self.fbb_.push_slot::<i32>(Game::VT_VALUE, value, 0);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> GameBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> GameBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
GameBuilder { GameBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -129,9 +129,9 @@ impl Default for GameT {
} }
} }
impl GameT { impl GameT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<Game<'b>> { ) -> flatbuffers::WIPOffset<Game<'b>> {
let value = self.value; let value = self.value;
Game::create(_fbb, &GameArgs{ Game::create(_fbb, &GameArgs{

16
tests/rust_namer_test/rust_namer_test/field_table_generated.rs
View File

@ -35,8 +35,8 @@ impl<'a> FieldTable<'a> {
FieldTable { _tab: table } FieldTable { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args FieldTableArgs _args: &'args FieldTableArgs
) -> flatbuffers::WIPOffset<FieldTable<'bldr>> { ) -> flatbuffers::WIPOffset<FieldTable<'bldr>> {
let mut builder = FieldTableBuilder::new(_fbb); let mut builder = FieldTableBuilder::new(_fbb);
@ -70,13 +70,13 @@ impl<'a> Default for FieldTableArgs {
} }
} }
pub struct FieldTableBuilder<'a: 'b, 'b> { pub struct FieldTableBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> FieldTableBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> FieldTableBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FieldTableBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FieldTableBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
FieldTableBuilder { FieldTableBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -107,9 +107,9 @@ impl Default for FieldTableT {
} }
} }
impl FieldTableT { impl FieldTableT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<FieldTable<'b>> { ) -> flatbuffers::WIPOffset<FieldTable<'b>> {
FieldTable::create(_fbb, &FieldTableArgs{ FieldTable::create(_fbb, &FieldTableArgs{
}) })

2
tests/rust_namer_test/rust_namer_test/field_union_generated.rs
View File

@ -115,7 +115,7 @@ impl FieldUnionT {
Self::F(_) => FieldUnion::f, Self::F(_) => FieldUnion::f,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::F(v) => Some(v.pack(fbb).as_union_value()), Self::F(v) => Some(v.pack(fbb).as_union_value()),

2
tests/rust_namer_test/rust_namer_test/game_message_generated.rs
View File

@ -127,7 +127,7 @@ impl GameMessageT {
Self::PlayerInputChange(_) => GameMessage::PlayerInputChange, Self::PlayerInputChange(_) => GameMessage::PlayerInputChange,
} }
} }
pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> { pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
match self { match self {
Self::NONE => None, Self::NONE => None,
Self::PlayerStatEvent(v) => Some(v.pack(fbb).as_union_value()), Self::PlayerStatEvent(v) => Some(v.pack(fbb).as_union_value()),

16
tests/rust_namer_test/rust_namer_test/game_message_wrapper_generated.rs
View File

@ -37,8 +37,8 @@ impl<'a> GameMessageWrapper<'a> {
GameMessageWrapper { _tab: table } GameMessageWrapper { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args GameMessageWrapperArgs args: &'args GameMessageWrapperArgs
) -> flatbuffers::WIPOffset<GameMessageWrapper<'bldr>> { ) -> flatbuffers::WIPOffset<GameMessageWrapper<'bldr>> {
let mut builder = GameMessageWrapperBuilder::new(_fbb); let mut builder = GameMessageWrapperBuilder::new(_fbb);
@ -166,11 +166,11 @@ impl<'a> Default for GameMessageWrapperArgs {
} }
} }
pub struct GameMessageWrapperBuilder<'a: 'b, 'b> { pub struct GameMessageWrapperBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> GameMessageWrapperBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GameMessageWrapperBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_Message_type(&mut self, Message_type: GameMessage) { pub fn add_Message_type(&mut self, Message_type: GameMessage) {
self.fbb_.push_slot::<GameMessage>(GameMessageWrapper::VT_MESSAGE_TYPE, Message_type, GameMessage::NONE); self.fbb_.push_slot::<GameMessage>(GameMessageWrapper::VT_MESSAGE_TYPE, Message_type, GameMessage::NONE);
@ -180,7 +180,7 @@ impl<'a: 'b, 'b> GameMessageWrapperBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GameMessageWrapper::VT_MESSAGE, Message); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GameMessageWrapper::VT_MESSAGE, Message);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> GameMessageWrapperBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> GameMessageWrapperBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
GameMessageWrapperBuilder { GameMessageWrapperBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -241,9 +241,9 @@ impl Default for GameMessageWrapperT {
} }
} }
impl GameMessageWrapperT { impl GameMessageWrapperT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<GameMessageWrapper<'b>> { ) -> flatbuffers::WIPOffset<GameMessageWrapper<'b>> {
let Message_type = self.Message.game_message_type(); let Message_type = self.Message.game_message_type();
let Message = self.Message.pack(_fbb); let Message = self.Message.pack(_fbb);

16
tests/rust_namer_test/rust_namer_test/player_input_change_generated.rs
View File

@ -35,8 +35,8 @@ impl<'a> PlayerInputChange<'a> {
PlayerInputChange { _tab: table } PlayerInputChange { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args PlayerInputChangeArgs _args: &'args PlayerInputChangeArgs
) -> flatbuffers::WIPOffset<PlayerInputChange<'bldr>> { ) -> flatbuffers::WIPOffset<PlayerInputChange<'bldr>> {
let mut builder = PlayerInputChangeBuilder::new(_fbb); let mut builder = PlayerInputChangeBuilder::new(_fbb);
@ -70,13 +70,13 @@ impl<'a> Default for PlayerInputChangeArgs {
} }
} }
pub struct PlayerInputChangeBuilder<'a: 'b, 'b> { pub struct PlayerInputChangeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> PlayerInputChangeBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PlayerInputChangeBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> PlayerInputChangeBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerInputChangeBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
PlayerInputChangeBuilder { PlayerInputChangeBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -107,9 +107,9 @@ impl Default for PlayerInputChangeT {
} }
} }
impl PlayerInputChangeT { impl PlayerInputChangeT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<PlayerInputChange<'b>> { ) -> flatbuffers::WIPOffset<PlayerInputChange<'b>> {
PlayerInputChange::create(_fbb, &PlayerInputChangeArgs{ PlayerInputChange::create(_fbb, &PlayerInputChangeArgs{
}) })

16
tests/rust_namer_test/rust_namer_test/player_spectate_generated.rs
View File

@ -35,8 +35,8 @@ impl<'a> PlayerSpectate<'a> {
PlayerSpectate { _tab: table } PlayerSpectate { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args PlayerSpectateArgs _args: &'args PlayerSpectateArgs
) -> flatbuffers::WIPOffset<PlayerSpectate<'bldr>> { ) -> flatbuffers::WIPOffset<PlayerSpectate<'bldr>> {
let mut builder = PlayerSpectateBuilder::new(_fbb); let mut builder = PlayerSpectateBuilder::new(_fbb);
@ -70,13 +70,13 @@ impl<'a> Default for PlayerSpectateArgs {
} }
} }
pub struct PlayerSpectateBuilder<'a: 'b, 'b> { pub struct PlayerSpectateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> PlayerSpectateBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PlayerSpectateBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> PlayerSpectateBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerSpectateBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
PlayerSpectateBuilder { PlayerSpectateBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -107,9 +107,9 @@ impl Default for PlayerSpectateT {
} }
} }
impl PlayerSpectateT { impl PlayerSpectateT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<PlayerSpectate<'b>> { ) -> flatbuffers::WIPOffset<PlayerSpectate<'b>> {
PlayerSpectate::create(_fbb, &PlayerSpectateArgs{ PlayerSpectate::create(_fbb, &PlayerSpectateArgs{
}) })

16
tests/rust_namer_test/rust_namer_test/player_stat_event_generated.rs
View File

@ -35,8 +35,8 @@ impl<'a> PlayerStatEvent<'a> {
PlayerStatEvent { _tab: table } PlayerStatEvent { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args PlayerStatEventArgs _args: &'args PlayerStatEventArgs
) -> flatbuffers::WIPOffset<PlayerStatEvent<'bldr>> { ) -> flatbuffers::WIPOffset<PlayerStatEvent<'bldr>> {
let mut builder = PlayerStatEventBuilder::new(_fbb); let mut builder = PlayerStatEventBuilder::new(_fbb);
@ -70,13 +70,13 @@ impl<'a> Default for PlayerStatEventArgs {
} }
} }
pub struct PlayerStatEventBuilder<'a: 'b, 'b> { pub struct PlayerStatEventBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> PlayerStatEventBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PlayerStatEventBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> PlayerStatEventBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerStatEventBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
PlayerStatEventBuilder { PlayerStatEventBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -107,9 +107,9 @@ impl Default for PlayerStatEventT {
} }
} }
impl PlayerStatEventT { impl PlayerStatEventT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<PlayerStatEvent<'b>> { ) -> flatbuffers::WIPOffset<PlayerStatEvent<'b>> {
PlayerStatEvent::create(_fbb, &PlayerStatEventArgs{ PlayerStatEvent::create(_fbb, &PlayerStatEventArgs{
}) })

16
tests/rust_namer_test/rust_namer_test/root_table_generated.rs
View File

@ -37,8 +37,8 @@ impl<'a> RootTable<'a> {
RootTable { _tab: table } RootTable { _tab: table }
} }
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args RootTableArgs args: &'args RootTableArgs
) -> flatbuffers::WIPOffset<RootTable<'bldr>> { ) -> flatbuffers::WIPOffset<RootTable<'bldr>> {
let mut builder = RootTableBuilder::new(_fbb); let mut builder = RootTableBuilder::new(_fbb);
@ -124,11 +124,11 @@ impl<'a> Default for RootTableArgs {
} }
} }
pub struct RootTableBuilder<'a: 'b, 'b> { pub struct RootTableBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
} }
impl<'a: 'b, 'b> RootTableBuilder<'a, 'b> { impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RootTableBuilder<'a, 'b, A> {
#[inline] #[inline]
pub fn add_field42_type(&mut self, field42_type: FieldUnion) { pub fn add_field42_type(&mut self, field42_type: FieldUnion) {
self.fbb_.push_slot::<FieldUnion>(RootTable::VT_FIELD42_TYPE, field42_type, FieldUnion::NONE); self.fbb_.push_slot::<FieldUnion>(RootTable::VT_FIELD42_TYPE, field42_type, FieldUnion::NONE);
@ -138,7 +138,7 @@ impl<'a: 'b, 'b> RootTableBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RootTable::VT_FIELD42, field42); self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RootTable::VT_FIELD42, field42);
} }
#[inline] #[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> RootTableBuilder<'a, 'b> { pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RootTableBuilder<'a, 'b, A> {
let start = _fbb.start_table(); let start = _fbb.start_table();
RootTableBuilder { RootTableBuilder {
fbb_: _fbb, fbb_: _fbb,
@ -185,9 +185,9 @@ impl Default for RootTableT {
} }
} }
impl RootTableT { impl RootTableT {
pub fn pack<'b>( pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
&self, &self,
_fbb: &mut flatbuffers::FlatBufferBuilder<'b> _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
) -> flatbuffers::WIPOffset<RootTable<'b>> { ) -> flatbuffers::WIPOffset<RootTable<'b>> {
let field42_type = self.field42.field_union_type(); let field42_type = self.field42.field_union_type();
let field42 = self.field42.pack(_fbb); let field42 = self.field42.pack(_fbb);