// automatically generated by the FlatBuffers compiler, do not modify use crate::include_test2_generated::*; use crate::include_test1_generated::*; use std::mem; use std::cmp::Ordering; extern crate flatbuffers; use self::flatbuffers::{EndianScalar, Follow}; #[allow(unused_imports, dead_code)] pub mod my_game { use crate::include_test2_generated::*; use crate::include_test1_generated::*; use std::mem; use std::cmp::Ordering; extern crate flatbuffers; use self::flatbuffers::{EndianScalar, Follow}; pub enum InParentNamespaceOffset {} #[derive(Copy, Clone, PartialEq)] pub struct InParentNamespace<'a> { pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for InParentNamespace<'a> { type Inner = InParentNamespace<'a>; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table { buf, loc } } } } impl<'a> InParentNamespace<'a> { pub const fn get_fully_qualified_name() -> &'static str { "MyGame.InParentNamespace" } #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { InParentNamespace { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _args: &'args InParentNamespaceArgs) -> flatbuffers::WIPOffset> { let mut builder = InParentNamespaceBuilder::new(_fbb); builder.finish() } pub fn unpack(&self) -> InParentNamespaceT { InParentNamespaceT { } } } impl flatbuffers::Verifiable for InParentNamespace<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .finish(); Ok(()) } } pub struct InParentNamespaceArgs { } impl<'a> Default for InParentNamespaceArgs { #[inline] fn default() -> Self { InParentNamespaceArgs { } } } pub struct InParentNamespaceBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> InParentNamespaceBuilder<'a, 'b> { #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> InParentNamespaceBuilder<'a, 'b> { let start = _fbb.start_table(); InParentNamespaceBuilder { fbb_: _fbb, start_: start, } } #[inline] pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } impl std::fmt::Debug for InParentNamespace<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut ds = f.debug_struct("InParentNamespace"); ds.finish() } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct InParentNamespaceT { } impl Default for InParentNamespaceT { fn default() -> Self { Self { } } } impl InParentNamespaceT { pub fn pack<'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b> ) -> flatbuffers::WIPOffset> { InParentNamespace::create(_fbb, &InParentNamespaceArgs{ }) } } #[allow(unused_imports, dead_code)] pub mod example_2 { use crate::include_test2_generated::*; use crate::include_test1_generated::*; use std::mem; use std::cmp::Ordering; extern crate flatbuffers; use self::flatbuffers::{EndianScalar, Follow}; pub enum MonsterOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Monster<'a> { pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for Monster<'a> { type Inner = Monster<'a>; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table { buf, loc } } } } impl<'a> Monster<'a> { pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example2.Monster" } #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Monster { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _args: &'args MonsterArgs) -> flatbuffers::WIPOffset> { let mut builder = MonsterBuilder::new(_fbb); builder.finish() } pub fn unpack(&self) -> MonsterT { MonsterT { } } } impl flatbuffers::Verifiable for Monster<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .finish(); Ok(()) } } pub struct MonsterArgs { } impl<'a> Default for MonsterArgs { #[inline] fn default() -> Self { MonsterArgs { } } } pub struct MonsterBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> { #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> { let start = _fbb.start_table(); MonsterBuilder { fbb_: _fbb, start_: start, } } #[inline] pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } impl std::fmt::Debug for Monster<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut ds = f.debug_struct("Monster"); ds.finish() } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct MonsterT { } impl Default for MonsterT { fn default() -> Self { Self { } } } impl MonsterT { pub fn pack<'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b> ) -> flatbuffers::WIPOffset> { Monster::create(_fbb, &MonsterArgs{ }) } } } // pub mod Example2 #[allow(unused_imports, dead_code)] pub mod example { use crate::include_test2_generated::*; use crate::include_test1_generated::*; use std::mem; use std::cmp::Ordering; extern crate flatbuffers; use self::flatbuffers::{EndianScalar, Follow}; #[allow(non_upper_case_globals)] mod bitflags_color { flatbuffers::bitflags::bitflags! { /// Composite components of Monster color. #[derive(Default)] pub struct Color: u8 { const Red = 1; /// \brief color Green /// Green is bit_flag with value (1u << 1) const Green = 2; /// \brief color Blue (1u << 3) const Blue = 8; } } } pub use self::bitflags_color::Color; impl<'a> flatbuffers::Follow<'a> for Color { type Inner = Self; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { let b = unsafe { flatbuffers::read_scalar_at::(buf, loc) }; unsafe { Self::from_bits_unchecked(b) } } } impl flatbuffers::Push for Color { type Output = Color; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { unsafe { flatbuffers::emplace_scalar::(dst, self.bits()); } } } impl flatbuffers::EndianScalar for Color { #[inline] fn to_little_endian(self) -> Self { let b = u8::to_le(self.bits()); unsafe { Self::from_bits_unchecked(b) } } #[inline] #[allow(clippy::wrong_self_convention)] fn from_little_endian(self) -> Self { let b = u8::from_le(self.bits()); unsafe { Self::from_bits_unchecked(b) } } } impl<'a> flatbuffers::Verifiable for Color { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } impl flatbuffers::SimpleToVerifyInSlice for Color {} #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MIN_RACE: i8 = -1; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MAX_RACE: i8 = 2; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_RACE: [Race; 4] = [ Race::None, Race::Human, Race::Dwarf, Race::Elf, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct Race(pub i8); #[allow(non_upper_case_globals)] impl Race { pub const None: Self = Self(-1); pub const Human: Self = Self(0); pub const Dwarf: Self = Self(1); pub const Elf: Self = Self(2); pub const ENUM_MIN: i8 = -1; pub const ENUM_MAX: i8 = 2; pub const ENUM_VALUES: &'static [Self] = &[ Self::None, Self::Human, Self::Dwarf, Self::Elf, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { Self::None => Some("None"), Self::Human => Some("Human"), Self::Dwarf => Some("Dwarf"), Self::Elf => Some("Elf"), _ => None, } } } impl std::fmt::Debug for Race { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { f.write_fmt(format_args!("", self.0)) } } } impl<'a> flatbuffers::Follow<'a> for Race { type Inner = Self; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { let b = unsafe { flatbuffers::read_scalar_at::(buf, loc) }; Self(b) } } impl flatbuffers::Push for Race { type Output = Race; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { unsafe { flatbuffers::emplace_scalar::(dst, self.0); } } } impl flatbuffers::EndianScalar for Race { #[inline] fn to_little_endian(self) -> Self { let b = i8::to_le(self.0); Self(b) } #[inline] #[allow(clippy::wrong_self_convention)] fn from_little_endian(self) -> Self { let b = i8::from_le(self.0); Self(b) } } impl<'a> flatbuffers::Verifiable for Race { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; i8::run_verifier(v, pos) } } impl flatbuffers::SimpleToVerifyInSlice for Race {} #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MIN_ANY: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MAX_ANY: u8 = 3; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_ANY: [Any; 4] = [ Any::NONE, Any::Monster, Any::TestSimpleTableWithEnum, Any::MyGame_Example2_Monster, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct Any(pub u8); #[allow(non_upper_case_globals)] impl Any { pub const NONE: Self = Self(0); pub const Monster: Self = Self(1); pub const TestSimpleTableWithEnum: Self = Self(2); pub const MyGame_Example2_Monster: Self = Self(3); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 3; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::Monster, Self::TestSimpleTableWithEnum, Self::MyGame_Example2_Monster, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { Self::NONE => Some("NONE"), Self::Monster => Some("Monster"), Self::TestSimpleTableWithEnum => Some("TestSimpleTableWithEnum"), Self::MyGame_Example2_Monster => Some("MyGame_Example2_Monster"), _ => None, } } } impl std::fmt::Debug for Any { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { f.write_fmt(format_args!("", self.0)) } } } impl<'a> flatbuffers::Follow<'a> for Any { type Inner = Self; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { let b = unsafe { flatbuffers::read_scalar_at::(buf, loc) }; Self(b) } } impl flatbuffers::Push for Any { type Output = Any; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { unsafe { flatbuffers::emplace_scalar::(dst, self.0); } } } impl flatbuffers::EndianScalar for Any { #[inline] fn to_little_endian(self) -> Self { let b = u8::to_le(self.0); Self(b) } #[inline] #[allow(clippy::wrong_self_convention)] fn from_little_endian(self) -> Self { let b = u8::from_le(self.0); Self(b) } } impl<'a> flatbuffers::Verifiable for Any { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } impl flatbuffers::SimpleToVerifyInSlice for Any {} pub struct AnyUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyT { NONE, Monster(Box), TestSimpleTableWithEnum(Box), MyGameExample2Monster(Box), } impl Default for AnyT { fn default() -> Self { Self::NONE } } impl AnyT { pub fn any_type(&self) -> Any { match self { Self::NONE => Any::NONE, Self::Monster(_) => Any::Monster, Self::TestSimpleTableWithEnum(_) => Any::TestSimpleTableWithEnum, Self::MyGameExample2Monster(_) => Any::MyGame_Example2_Monster, } } pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option> { match self { Self::NONE => None, Self::Monster(v) => Some(v.pack(fbb).as_union_value()), Self::TestSimpleTableWithEnum(v) => Some(v.pack(fbb).as_union_value()), Self::MyGameExample2Monster(v) => Some(v.pack(fbb).as_union_value()), } } /// If the union variant matches, return the owned MonsterT, setting the union to NONE. pub fn take_monster(&mut self) -> Option> { if let Self::Monster(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::Monster(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the MonsterT. pub fn as_monster(&self) -> Option<&MonsterT> { if let Self::Monster(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the MonsterT. pub fn as_monster_mut(&mut self) -> Option<&mut MonsterT> { if let Self::Monster(v) = self { Some(v.as_mut()) } else { None } } /// If the union variant matches, return the owned TestSimpleTableWithEnumT, setting the union to NONE. pub fn take_test_simple_table_with_enum(&mut self) -> Option> { if let Self::TestSimpleTableWithEnum(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::TestSimpleTableWithEnum(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the TestSimpleTableWithEnumT. pub fn as_test_simple_table_with_enum(&self) -> Option<&TestSimpleTableWithEnumT> { if let Self::TestSimpleTableWithEnum(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the TestSimpleTableWithEnumT. pub fn as_test_simple_table_with_enum_mut(&mut self) -> Option<&mut TestSimpleTableWithEnumT> { if let Self::TestSimpleTableWithEnum(v) = self { Some(v.as_mut()) } else { None } } /// If the union variant matches, return the owned super::example_2::MonsterT, setting the union to NONE. pub fn take_my_game_example_2_monster(&mut self) -> Option> { if let Self::MyGameExample2Monster(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::MyGameExample2Monster(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the super::example_2::MonsterT. pub fn as_my_game_example_2_monster(&self) -> Option<&super::example_2::MonsterT> { if let Self::MyGameExample2Monster(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the super::example_2::MonsterT. pub fn as_my_game_example_2_monster_mut(&mut self) -> Option<&mut super::example_2::MonsterT> { if let Self::MyGameExample2Monster(v) = self { Some(v.as_mut()) } else { None } } } #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MIN_ANY_UNIQUE_ALIASES: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MAX_ANY_UNIQUE_ALIASES: u8 = 3; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_ANY_UNIQUE_ALIASES: [AnyUniqueAliases; 4] = [ AnyUniqueAliases::NONE, AnyUniqueAliases::M, AnyUniqueAliases::TS, AnyUniqueAliases::M2, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct AnyUniqueAliases(pub u8); #[allow(non_upper_case_globals)] impl AnyUniqueAliases { pub const NONE: Self = Self(0); pub const M: Self = Self(1); pub const TS: Self = Self(2); pub const M2: Self = Self(3); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 3; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::M, Self::TS, Self::M2, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { Self::NONE => Some("NONE"), Self::M => Some("M"), Self::TS => Some("TS"), Self::M2 => Some("M2"), _ => None, } } } impl std::fmt::Debug for AnyUniqueAliases { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { f.write_fmt(format_args!("", self.0)) } } } impl<'a> flatbuffers::Follow<'a> for AnyUniqueAliases { type Inner = Self; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { let b = unsafe { flatbuffers::read_scalar_at::(buf, loc) }; Self(b) } } impl flatbuffers::Push for AnyUniqueAliases { type Output = AnyUniqueAliases; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { unsafe { flatbuffers::emplace_scalar::(dst, self.0); } } } impl flatbuffers::EndianScalar for AnyUniqueAliases { #[inline] fn to_little_endian(self) -> Self { let b = u8::to_le(self.0); Self(b) } #[inline] #[allow(clippy::wrong_self_convention)] fn from_little_endian(self) -> Self { let b = u8::from_le(self.0); Self(b) } } impl<'a> flatbuffers::Verifiable for AnyUniqueAliases { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } impl flatbuffers::SimpleToVerifyInSlice for AnyUniqueAliases {} pub struct AnyUniqueAliasesUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyUniqueAliasesT { NONE, M(Box), TS(Box), M2(Box), } impl Default for AnyUniqueAliasesT { fn default() -> Self { Self::NONE } } impl AnyUniqueAliasesT { pub fn any_unique_aliases_type(&self) -> AnyUniqueAliases { match self { Self::NONE => AnyUniqueAliases::NONE, Self::M(_) => AnyUniqueAliases::M, Self::TS(_) => AnyUniqueAliases::TS, Self::M2(_) => AnyUniqueAliases::M2, } } pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option> { match self { Self::NONE => None, Self::M(v) => Some(v.pack(fbb).as_union_value()), Self::TS(v) => Some(v.pack(fbb).as_union_value()), Self::M2(v) => Some(v.pack(fbb).as_union_value()), } } /// If the union variant matches, return the owned MonsterT, setting the union to NONE. pub fn take_m(&mut self) -> Option> { if let Self::M(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::M(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the MonsterT. pub fn as_m(&self) -> Option<&MonsterT> { if let Self::M(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the MonsterT. pub fn as_m_mut(&mut self) -> Option<&mut MonsterT> { if let Self::M(v) = self { Some(v.as_mut()) } else { None } } /// If the union variant matches, return the owned TestSimpleTableWithEnumT, setting the union to NONE. pub fn take_ts(&mut self) -> Option> { if let Self::TS(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::TS(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the TestSimpleTableWithEnumT. pub fn as_ts(&self) -> Option<&TestSimpleTableWithEnumT> { if let Self::TS(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the TestSimpleTableWithEnumT. pub fn as_ts_mut(&mut self) -> Option<&mut TestSimpleTableWithEnumT> { if let Self::TS(v) = self { Some(v.as_mut()) } else { None } } /// If the union variant matches, return the owned super::example_2::MonsterT, setting the union to NONE. pub fn take_m2(&mut self) -> Option> { if let Self::M2(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::M2(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the super::example_2::MonsterT. pub fn as_m2(&self) -> Option<&super::example_2::MonsterT> { if let Self::M2(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the super::example_2::MonsterT. pub fn as_m2_mut(&mut self) -> Option<&mut super::example_2::MonsterT> { if let Self::M2(v) = self { Some(v.as_mut()) } else { None } } } #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MIN_ANY_AMBIGUOUS_ALIASES: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MAX_ANY_AMBIGUOUS_ALIASES: u8 = 3; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_ANY_AMBIGUOUS_ALIASES: [AnyAmbiguousAliases; 4] = [ AnyAmbiguousAliases::NONE, AnyAmbiguousAliases::M1, AnyAmbiguousAliases::M2, AnyAmbiguousAliases::M3, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct AnyAmbiguousAliases(pub u8); #[allow(non_upper_case_globals)] impl AnyAmbiguousAliases { pub const NONE: Self = Self(0); pub const M1: Self = Self(1); pub const M2: Self = Self(2); pub const M3: Self = Self(3); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 3; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::M1, Self::M2, Self::M3, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { Self::NONE => Some("NONE"), Self::M1 => Some("M1"), Self::M2 => Some("M2"), Self::M3 => Some("M3"), _ => None, } } } impl std::fmt::Debug for AnyAmbiguousAliases { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { f.write_fmt(format_args!("", self.0)) } } } impl<'a> flatbuffers::Follow<'a> for AnyAmbiguousAliases { type Inner = Self; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { let b = unsafe { flatbuffers::read_scalar_at::(buf, loc) }; Self(b) } } impl flatbuffers::Push for AnyAmbiguousAliases { type Output = AnyAmbiguousAliases; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { unsafe { flatbuffers::emplace_scalar::(dst, self.0); } } } impl flatbuffers::EndianScalar for AnyAmbiguousAliases { #[inline] fn to_little_endian(self) -> Self { let b = u8::to_le(self.0); Self(b) } #[inline] #[allow(clippy::wrong_self_convention)] fn from_little_endian(self) -> Self { let b = u8::from_le(self.0); Self(b) } } impl<'a> flatbuffers::Verifiable for AnyAmbiguousAliases { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } impl flatbuffers::SimpleToVerifyInSlice for AnyAmbiguousAliases {} pub struct AnyAmbiguousAliasesUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyAmbiguousAliasesT { NONE, M1(Box), M2(Box), M3(Box), } impl Default for AnyAmbiguousAliasesT { fn default() -> Self { Self::NONE } } impl AnyAmbiguousAliasesT { pub fn any_ambiguous_aliases_type(&self) -> AnyAmbiguousAliases { match self { Self::NONE => AnyAmbiguousAliases::NONE, Self::M1(_) => AnyAmbiguousAliases::M1, Self::M2(_) => AnyAmbiguousAliases::M2, Self::M3(_) => AnyAmbiguousAliases::M3, } } pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option> { match self { Self::NONE => None, Self::M1(v) => Some(v.pack(fbb).as_union_value()), Self::M2(v) => Some(v.pack(fbb).as_union_value()), Self::M3(v) => Some(v.pack(fbb).as_union_value()), } } /// If the union variant matches, return the owned MonsterT, setting the union to NONE. pub fn take_m1(&mut self) -> Option> { if let Self::M1(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::M1(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the MonsterT. pub fn as_m1(&self) -> Option<&MonsterT> { if let Self::M1(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the MonsterT. pub fn as_m1_mut(&mut self) -> Option<&mut MonsterT> { if let Self::M1(v) = self { Some(v.as_mut()) } else { None } } /// If the union variant matches, return the owned MonsterT, setting the union to NONE. pub fn take_m2(&mut self) -> Option> { if let Self::M2(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::M2(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the MonsterT. pub fn as_m2(&self) -> Option<&MonsterT> { if let Self::M2(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the MonsterT. pub fn as_m2_mut(&mut self) -> Option<&mut MonsterT> { if let Self::M2(v) = self { Some(v.as_mut()) } else { None } } /// If the union variant matches, return the owned MonsterT, setting the union to NONE. pub fn take_m3(&mut self) -> Option> { if let Self::M3(_) = self { let v = std::mem::replace(self, Self::NONE); if let Self::M3(w) = v { Some(w) } else { unreachable!() } } else { None } } /// If the union variant matches, return a reference to the MonsterT. pub fn as_m3(&self) -> Option<&MonsterT> { if let Self::M3(v) = self { Some(v.as_ref()) } else { None } } /// If the union variant matches, return a mutable reference to the MonsterT. pub fn as_m3_mut(&mut self) -> Option<&mut MonsterT> { if let Self::M3(v) = self { Some(v.as_mut()) } else { None } } } // struct Test, aligned to 2 #[repr(transparent)] #[derive(Clone, Copy, PartialEq)] pub struct Test(pub [u8; 4]); impl Default for Test { fn default() -> Self { Self([0; 4]) } } impl std::fmt::Debug for Test { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.debug_struct("Test") .field("a", &self.a()) .field("b", &self.b()) .finish() } } impl flatbuffers::SimpleToVerifyInSlice for Test {} impl flatbuffers::SafeSliceAccess for Test {} impl<'a> flatbuffers::Follow<'a> for Test { type Inner = &'a Test; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { <&'a Test>::follow(buf, loc) } } impl<'a> flatbuffers::Follow<'a> for &'a Test { type Inner = &'a Test; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { flatbuffers::follow_cast_ref::(buf, loc) } } impl<'b> flatbuffers::Push for Test { type Output = Test; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(self as *const Test as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'b> flatbuffers::Push for &'b Test { type Output = Test; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(*self as *const Test as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'a> flatbuffers::Verifiable for Test { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.in_buffer::(pos) } } impl<'a> Test { #[allow(clippy::too_many_arguments)] pub fn new( a: i16, b: i8, ) -> Self { let mut s = Self([0; 4]); s.set_a(a); s.set_b(b); s } pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.Test" } pub fn a(&self) -> i16 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[0..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_a(&mut self, x: i16) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const i16 as *const u8, self.0[0..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn b(&self) -> i8 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[2..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_b(&mut self, x: i8) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const i8 as *const u8, self.0[2..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn unpack(&self) -> TestT { TestT { a: self.a(), b: self.b(), } } } #[derive(Debug, Clone, PartialEq, Default)] pub struct TestT { pub a: i16, pub b: i8, } impl TestT { pub fn pack(&self) -> Test { Test::new( self.a, self.b, ) } } // struct Vec3, aligned to 8 #[repr(transparent)] #[derive(Clone, Copy, PartialEq)] pub struct Vec3(pub [u8; 32]); impl Default for Vec3 { fn default() -> Self { Self([0; 32]) } } impl std::fmt::Debug for Vec3 { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.debug_struct("Vec3") .field("x", &self.x()) .field("y", &self.y()) .field("z", &self.z()) .field("test1", &self.test1()) .field("test2", &self.test2()) .field("test3", &self.test3()) .finish() } } impl flatbuffers::SimpleToVerifyInSlice for Vec3 {} impl flatbuffers::SafeSliceAccess for Vec3 {} impl<'a> flatbuffers::Follow<'a> for Vec3 { type Inner = &'a Vec3; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { <&'a Vec3>::follow(buf, loc) } } impl<'a> flatbuffers::Follow<'a> for &'a Vec3 { type Inner = &'a Vec3; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { flatbuffers::follow_cast_ref::(buf, loc) } } impl<'b> flatbuffers::Push for Vec3 { type Output = Vec3; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(self as *const Vec3 as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'b> flatbuffers::Push for &'b Vec3 { type Output = Vec3; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(*self as *const Vec3 as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'a> flatbuffers::Verifiable for Vec3 { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.in_buffer::(pos) } } impl<'a> Vec3 { #[allow(clippy::too_many_arguments)] pub fn new( x: f32, y: f32, z: f32, test1: f64, test2: Color, test3: &Test, ) -> Self { let mut s = Self([0; 32]); s.set_x(x); s.set_y(y); s.set_z(z); s.set_test1(test1); s.set_test2(test2); s.set_test3(&test3); s } pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.Vec3" } pub fn x(&self) -> f32 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[0..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_x(&mut self, x: f32) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const f32 as *const u8, self.0[0..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn y(&self) -> f32 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[4..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_y(&mut self, x: f32) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const f32 as *const u8, self.0[4..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn z(&self) -> f32 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[8..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_z(&mut self, x: f32) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const f32 as *const u8, self.0[8..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn test1(&self) -> f64 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[16..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_test1(&mut self, x: f64) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const f64 as *const u8, self.0[16..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn test2(&self) -> Color { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[24..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_test2(&mut self, x: Color) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const Color as *const u8, self.0[24..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn test3(&self) -> &Test { unsafe { &*(self.0[26..].as_ptr() as *const Test) } } pub fn set_test3(&mut self, x: &Test) { self.0[26..26+4].copy_from_slice(&x.0) } pub fn unpack(&self) -> Vec3T { Vec3T { x: self.x(), y: self.y(), z: self.z(), test1: self.test1(), test2: self.test2(), test3: self.test3().unpack(), } } } #[derive(Debug, Clone, PartialEq, Default)] pub struct Vec3T { pub x: f32, pub y: f32, pub z: f32, pub test1: f64, pub test2: Color, pub test3: TestT, } impl Vec3T { pub fn pack(&self) -> Vec3 { Vec3::new( self.x, self.y, self.z, self.test1, self.test2, &self.test3.pack(), ) } } // struct Ability, aligned to 4 #[repr(transparent)] #[derive(Clone, Copy, PartialEq)] pub struct Ability(pub [u8; 8]); impl Default for Ability { fn default() -> Self { Self([0; 8]) } } impl std::fmt::Debug for Ability { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.debug_struct("Ability") .field("id", &self.id()) .field("distance", &self.distance()) .finish() } } impl flatbuffers::SimpleToVerifyInSlice for Ability {} impl flatbuffers::SafeSliceAccess for Ability {} impl<'a> flatbuffers::Follow<'a> for Ability { type Inner = &'a Ability; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { <&'a Ability>::follow(buf, loc) } } impl<'a> flatbuffers::Follow<'a> for &'a Ability { type Inner = &'a Ability; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { flatbuffers::follow_cast_ref::(buf, loc) } } impl<'b> flatbuffers::Push for Ability { type Output = Ability; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(self as *const Ability as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'b> flatbuffers::Push for &'b Ability { type Output = Ability; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(*self as *const Ability as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'a> flatbuffers::Verifiable for Ability { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.in_buffer::(pos) } } impl<'a> Ability { #[allow(clippy::too_many_arguments)] pub fn new( id: u32, distance: u32, ) -> Self { let mut s = Self([0; 8]); s.set_id(id); s.set_distance(distance); s } pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.Ability" } pub fn id(&self) -> u32 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[0..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_id(&mut self, x: u32) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const u32 as *const u8, self.0[0..].as_mut_ptr(), core::mem::size_of::(), ); } } #[inline] pub fn key_compare_less_than(&self, o: &Ability) -> bool { self.id() < o.id() } #[inline] pub fn key_compare_with_value(&self, val: u32) -> ::std::cmp::Ordering { let key = self.id(); key.cmp(&val) } pub fn distance(&self) -> u32 { let mut mem = core::mem::MaybeUninit::::uninit(); unsafe { core::ptr::copy_nonoverlapping( self.0[4..].as_ptr(), mem.as_mut_ptr() as *mut u8, core::mem::size_of::(), ); mem.assume_init() }.from_little_endian() } pub fn set_distance(&mut self, x: u32) { let x_le = x.to_little_endian(); unsafe { core::ptr::copy_nonoverlapping( &x_le as *const u32 as *const u8, self.0[4..].as_mut_ptr(), core::mem::size_of::(), ); } } pub fn unpack(&self) -> AbilityT { AbilityT { id: self.id(), distance: self.distance(), } } } #[derive(Debug, Clone, PartialEq, Default)] pub struct AbilityT { pub id: u32, pub distance: u32, } impl AbilityT { pub fn pack(&self) -> Ability { Ability::new( self.id, self.distance, ) } } // struct StructOfStructs, aligned to 4 #[repr(transparent)] #[derive(Clone, Copy, PartialEq)] pub struct StructOfStructs(pub [u8; 20]); impl Default for StructOfStructs { fn default() -> Self { Self([0; 20]) } } impl std::fmt::Debug for StructOfStructs { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.debug_struct("StructOfStructs") .field("a", &self.a()) .field("b", &self.b()) .field("c", &self.c()) .finish() } } impl flatbuffers::SimpleToVerifyInSlice for StructOfStructs {} impl flatbuffers::SafeSliceAccess for StructOfStructs {} impl<'a> flatbuffers::Follow<'a> for StructOfStructs { type Inner = &'a StructOfStructs; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { <&'a StructOfStructs>::follow(buf, loc) } } impl<'a> flatbuffers::Follow<'a> for &'a StructOfStructs { type Inner = &'a StructOfStructs; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { flatbuffers::follow_cast_ref::(buf, loc) } } impl<'b> flatbuffers::Push for StructOfStructs { type Output = StructOfStructs; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(self as *const StructOfStructs as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'b> flatbuffers::Push for &'b StructOfStructs { type Output = StructOfStructs; #[inline] fn push(&self, dst: &mut [u8], _rest: &[u8]) { let src = unsafe { ::std::slice::from_raw_parts(*self as *const StructOfStructs as *const u8, Self::size()) }; dst.copy_from_slice(src); } } impl<'a> flatbuffers::Verifiable for StructOfStructs { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.in_buffer::(pos) } } impl<'a> StructOfStructs { #[allow(clippy::too_many_arguments)] pub fn new( a: &Ability, b: &Test, c: &Ability, ) -> Self { let mut s = Self([0; 20]); s.set_a(&a); s.set_b(&b); s.set_c(&c); s } pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.StructOfStructs" } pub fn a(&self) -> &Ability { unsafe { &*(self.0[0..].as_ptr() as *const Ability) } } pub fn set_a(&mut self, x: &Ability) { self.0[0..0+8].copy_from_slice(&x.0) } pub fn b(&self) -> &Test { unsafe { &*(self.0[8..].as_ptr() as *const Test) } } pub fn set_b(&mut self, x: &Test) { self.0[8..8+4].copy_from_slice(&x.0) } pub fn c(&self) -> &Ability { unsafe { &*(self.0[12..].as_ptr() as *const Ability) } } pub fn set_c(&mut self, x: &Ability) { self.0[12..12+8].copy_from_slice(&x.0) } pub fn unpack(&self) -> StructOfStructsT { StructOfStructsT { a: self.a().unpack(), b: self.b().unpack(), c: self.c().unpack(), } } } #[derive(Debug, Clone, PartialEq, Default)] pub struct StructOfStructsT { pub a: AbilityT, pub b: TestT, pub c: AbilityT, } impl StructOfStructsT { pub fn pack(&self) -> StructOfStructs { StructOfStructs::new( &self.a.pack(), &self.b.pack(), &self.c.pack(), ) } } pub enum TestSimpleTableWithEnumOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TestSimpleTableWithEnum<'a> { pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for TestSimpleTableWithEnum<'a> { type Inner = TestSimpleTableWithEnum<'a>; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table { buf, loc } } } } impl<'a> TestSimpleTableWithEnum<'a> { pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.TestSimpleTableWithEnum" } #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { TestSimpleTableWithEnum { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, args: &'args TestSimpleTableWithEnumArgs) -> flatbuffers::WIPOffset> { let mut builder = TestSimpleTableWithEnumBuilder::new(_fbb); builder.add_color(args.color); builder.finish() } pub fn unpack(&self) -> TestSimpleTableWithEnumT { let color = self.color(); TestSimpleTableWithEnumT { color, } } pub const VT_COLOR: flatbuffers::VOffsetT = 4; #[inline] pub fn color(&self) -> Color { self._tab.get::(TestSimpleTableWithEnum::VT_COLOR, Some(Color::Green)).unwrap() } } impl flatbuffers::Verifiable for TestSimpleTableWithEnum<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::(&"color", Self::VT_COLOR, false)? .finish(); Ok(()) } } pub struct TestSimpleTableWithEnumArgs { pub color: Color, } impl<'a> Default for TestSimpleTableWithEnumArgs { #[inline] fn default() -> Self { TestSimpleTableWithEnumArgs { color: Color::Green, } } } pub struct TestSimpleTableWithEnumBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> TestSimpleTableWithEnumBuilder<'a, 'b> { #[inline] pub fn add_color(&mut self, color: Color) { self.fbb_.push_slot::(TestSimpleTableWithEnum::VT_COLOR, color, Color::Green); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TestSimpleTableWithEnumBuilder<'a, 'b> { let start = _fbb.start_table(); TestSimpleTableWithEnumBuilder { fbb_: _fbb, start_: start, } } #[inline] pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } impl std::fmt::Debug for TestSimpleTableWithEnum<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut ds = f.debug_struct("TestSimpleTableWithEnum"); ds.field("color", &self.color()); ds.finish() } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TestSimpleTableWithEnumT { pub color: Color, } impl Default for TestSimpleTableWithEnumT { fn default() -> Self { Self { color: Color::Green, } } } impl TestSimpleTableWithEnumT { pub fn pack<'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b> ) -> flatbuffers::WIPOffset> { let color = self.color; TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{ color, }) } } pub enum StatOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Stat<'a> { pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for Stat<'a> { type Inner = Stat<'a>; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table { buf, loc } } } } impl<'a> Stat<'a> { pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.Stat" } #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Stat { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, args: &'args StatArgs<'args>) -> flatbuffers::WIPOffset> { let mut builder = StatBuilder::new(_fbb); builder.add_val(args.val); if let Some(x) = args.id { builder.add_id(x); } builder.add_count(args.count); builder.finish() } pub fn unpack(&self) -> StatT { let id = self.id().map(|x| { x.to_string() }); let val = self.val(); let count = self.count(); StatT { id, val, count, } } pub const VT_ID: flatbuffers::VOffsetT = 4; pub const VT_VAL: flatbuffers::VOffsetT = 6; pub const VT_COUNT: flatbuffers::VOffsetT = 8; #[inline] pub fn id(&self) -> Option<&'a str> { self._tab.get::>(Stat::VT_ID, None) } #[inline] pub fn val(&self) -> i64 { self._tab.get::(Stat::VT_VAL, Some(0)).unwrap() } #[inline] pub fn count(&self) -> u16 { self._tab.get::(Stat::VT_COUNT, Some(0)).unwrap() } #[inline] pub fn key_compare_less_than(&self, o: &Stat) -> bool { self.count() < o.count() } #[inline] pub fn key_compare_with_value(&self, val: u16) -> ::std::cmp::Ordering { let key = self.count(); key.cmp(&val) } } impl flatbuffers::Verifiable for Stat<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::>(&"id", Self::VT_ID, false)? .visit_field::(&"val", Self::VT_VAL, false)? .visit_field::(&"count", Self::VT_COUNT, false)? .finish(); Ok(()) } } pub struct StatArgs<'a> { pub id: Option>, pub val: i64, pub count: u16, } impl<'a> Default for StatArgs<'a> { #[inline] fn default() -> Self { StatArgs { id: None, val: 0, count: 0, } } } pub struct StatBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> StatBuilder<'a, 'b> { #[inline] pub fn add_id(&mut self, id: flatbuffers::WIPOffset<&'b str>) { self.fbb_.push_slot_always::>(Stat::VT_ID, id); } #[inline] pub fn add_val(&mut self, val: i64) { self.fbb_.push_slot::(Stat::VT_VAL, val, 0); } #[inline] pub fn add_count(&mut self, count: u16) { self.fbb_.push_slot::(Stat::VT_COUNT, count, 0); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatBuilder<'a, 'b> { let start = _fbb.start_table(); StatBuilder { fbb_: _fbb, start_: start, } } #[inline] pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } impl std::fmt::Debug for Stat<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut ds = f.debug_struct("Stat"); ds.field("id", &self.id()); ds.field("val", &self.val()); ds.field("count", &self.count()); ds.finish() } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct StatT { pub id: Option, pub val: i64, pub count: u16, } impl Default for StatT { fn default() -> Self { Self { id: None, val: 0, count: 0, } } } impl StatT { pub fn pack<'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b> ) -> flatbuffers::WIPOffset> { let id = self.id.as_ref().map(|x|{ _fbb.create_string(x) }); let val = self.val; let count = self.count; Stat::create(_fbb, &StatArgs{ id, val, count, }) } } pub enum ReferrableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Referrable<'a> { pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for Referrable<'a> { type Inner = Referrable<'a>; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table { buf, loc } } } } impl<'a> Referrable<'a> { pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.Referrable" } #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Referrable { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, args: &'args ReferrableArgs) -> flatbuffers::WIPOffset> { let mut builder = ReferrableBuilder::new(_fbb); builder.add_id(args.id); builder.finish() } pub fn unpack(&self) -> ReferrableT { let id = self.id(); ReferrableT { id, } } pub const VT_ID: flatbuffers::VOffsetT = 4; #[inline] pub fn id(&self) -> u64 { self._tab.get::(Referrable::VT_ID, Some(0)).unwrap() } #[inline] pub fn key_compare_less_than(&self, o: &Referrable) -> bool { self.id() < o.id() } #[inline] pub fn key_compare_with_value(&self, val: u64) -> ::std::cmp::Ordering { let key = self.id(); key.cmp(&val) } } impl flatbuffers::Verifiable for Referrable<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::(&"id", Self::VT_ID, false)? .finish(); Ok(()) } } pub struct ReferrableArgs { pub id: u64, } impl<'a> Default for ReferrableArgs { #[inline] fn default() -> Self { ReferrableArgs { id: 0, } } } pub struct ReferrableBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> ReferrableBuilder<'a, 'b> { #[inline] pub fn add_id(&mut self, id: u64) { self.fbb_.push_slot::(Referrable::VT_ID, id, 0); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ReferrableBuilder<'a, 'b> { let start = _fbb.start_table(); ReferrableBuilder { fbb_: _fbb, start_: start, } } #[inline] pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } impl std::fmt::Debug for Referrable<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut ds = f.debug_struct("Referrable"); ds.field("id", &self.id()); ds.finish() } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct ReferrableT { pub id: u64, } impl Default for ReferrableT { fn default() -> Self { Self { id: 0, } } } impl ReferrableT { pub fn pack<'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b> ) -> flatbuffers::WIPOffset> { let id = self.id; Referrable::create(_fbb, &ReferrableArgs{ id, }) } } pub enum MonsterOffset {} #[derive(Copy, Clone, PartialEq)] /// an example documentation comment: "monster object" pub struct Monster<'a> { pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for Monster<'a> { type Inner = Monster<'a>; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table { buf, loc } } } } impl<'a> Monster<'a> { pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.Monster" } #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Monster { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, args: &'args MonsterArgs<'args>) -> flatbuffers::WIPOffset> { let mut builder = MonsterBuilder::new(_fbb); builder.add_non_owning_reference(args.non_owning_reference); builder.add_co_owning_reference(args.co_owning_reference); builder.add_single_weak_reference(args.single_weak_reference); builder.add_testhashu64_fnv1a(args.testhashu64_fnv1a); builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a); builder.add_testhashu64_fnv1(args.testhashu64_fnv1); builder.add_testhashs64_fnv1(args.testhashs64_fnv1); if let Some(x) = args.scalar_key_sorted_tables { builder.add_scalar_key_sorted_tables(x); } if let Some(x) = args.testrequirednestedflatbuffer { builder.add_testrequirednestedflatbuffer(x); } if let Some(x) = args.vector_of_enums { builder.add_vector_of_enums(x); } if let Some(x) = args.any_ambiguous { builder.add_any_ambiguous(x); } if let Some(x) = args.any_unique { builder.add_any_unique(x); } if let Some(x) = args.vector_of_non_owning_references { builder.add_vector_of_non_owning_references(x); } if let Some(x) = args.vector_of_co_owning_references { builder.add_vector_of_co_owning_references(x); } if let Some(x) = args.vector_of_strong_referrables { builder.add_vector_of_strong_referrables(x); } if let Some(x) = args.vector_of_weak_references { builder.add_vector_of_weak_references(x); } if let Some(x) = args.vector_of_referrables { builder.add_vector_of_referrables(x); } if let Some(x) = args.parent_namespace_test { builder.add_parent_namespace_test(x); } if let Some(x) = args.vector_of_doubles { builder.add_vector_of_doubles(x); } if let Some(x) = args.vector_of_longs { builder.add_vector_of_longs(x); } if let Some(x) = args.test5 { builder.add_test5(x); } if let Some(x) = args.flex { builder.add_flex(x); } if let Some(x) = args.testarrayofsortedstruct { builder.add_testarrayofsortedstruct(x); } if let Some(x) = args.testarrayofstring2 { builder.add_testarrayofstring2(x); } builder.add_testf3(args.testf3); builder.add_testf2(args.testf2); builder.add_testf(args.testf); if let Some(x) = args.testarrayofbools { builder.add_testarrayofbools(x); } builder.add_testhashu32_fnv1a(args.testhashu32_fnv1a); builder.add_testhashs32_fnv1a(args.testhashs32_fnv1a); builder.add_testhashu32_fnv1(args.testhashu32_fnv1); builder.add_testhashs32_fnv1(args.testhashs32_fnv1); if let Some(x) = args.testempty { builder.add_testempty(x); } if let Some(x) = args.testnestedflatbuffer { builder.add_testnestedflatbuffer(x); } if let Some(x) = args.enemy { builder.add_enemy(x); } if let Some(x) = args.testarrayoftables { builder.add_testarrayoftables(x); } if let Some(x) = args.testarrayofstring { builder.add_testarrayofstring(x); } if let Some(x) = args.test4 { builder.add_test4(x); } if let Some(x) = args.test { builder.add_test(x); } if let Some(x) = args.inventory { builder.add_inventory(x); } if let Some(x) = args.name { builder.add_name(x); } if let Some(x) = args.pos { builder.add_pos(x); } builder.add_hp(args.hp); builder.add_mana(args.mana); builder.add_signed_enum(args.signed_enum); builder.add_any_ambiguous_type(args.any_ambiguous_type); builder.add_any_unique_type(args.any_unique_type); builder.add_testbool(args.testbool); builder.add_test_type(args.test_type); builder.add_color(args.color); builder.finish() } pub fn unpack(&self) -> MonsterT { let pos = self.pos().map(|x| { x.unpack() }); let mana = self.mana(); let hp = self.hp(); let name = { let x = self.name(); x.to_string() }; let inventory = self.inventory().map(|x| { x.to_vec() }); let color = self.color(); let test = match self.test_type() { Any::NONE => AnyT::NONE, Any::Monster => AnyT::Monster(Box::new( self.test_as_monster() .expect("Invalid union table, expected `Any::Monster`.") .unpack() )), Any::TestSimpleTableWithEnum => AnyT::TestSimpleTableWithEnum(Box::new( self.test_as_test_simple_table_with_enum() .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`.") .unpack() )), Any::MyGame_Example2_Monster => AnyT::MyGameExample2Monster(Box::new( self.test_as_my_game_example_2_monster() .expect("Invalid union table, expected `Any::MyGame_Example2_Monster`.") .unpack() )), _ => AnyT::NONE, }; let test4 = self.test4().map(|x| { x.iter().map(|t| t.unpack()).collect() }); let testarrayofstring = self.testarrayofstring().map(|x| { x.iter().map(|s| s.to_string()).collect() }); let testarrayoftables = self.testarrayoftables().map(|x| { x.iter().map(|t| t.unpack()).collect() }); let enemy = self.enemy().map(|x| { Box::new(x.unpack()) }); let testnestedflatbuffer = self.testnestedflatbuffer().map(|x| { x.to_vec() }); let testempty = self.testempty().map(|x| { Box::new(x.unpack()) }); let testbool = self.testbool(); let testhashs32_fnv1 = self.testhashs32_fnv1(); let testhashu32_fnv1 = self.testhashu32_fnv1(); let testhashs64_fnv1 = self.testhashs64_fnv1(); let testhashu64_fnv1 = self.testhashu64_fnv1(); let testhashs32_fnv1a = self.testhashs32_fnv1a(); let testhashu32_fnv1a = self.testhashu32_fnv1a(); let testhashs64_fnv1a = self.testhashs64_fnv1a(); let testhashu64_fnv1a = self.testhashu64_fnv1a(); let testarrayofbools = self.testarrayofbools().map(|x| { x.to_vec() }); let testf = self.testf(); let testf2 = self.testf2(); let testf3 = self.testf3(); let testarrayofstring2 = self.testarrayofstring2().map(|x| { x.iter().map(|s| s.to_string()).collect() }); let testarrayofsortedstruct = self.testarrayofsortedstruct().map(|x| { x.iter().map(|t| t.unpack()).collect() }); let flex = self.flex().map(|x| { x.to_vec() }); let test5 = self.test5().map(|x| { x.iter().map(|t| t.unpack()).collect() }); let vector_of_longs = self.vector_of_longs().map(|x| { x.into_iter().collect() }); let vector_of_doubles = self.vector_of_doubles().map(|x| { x.into_iter().collect() }); let parent_namespace_test = self.parent_namespace_test().map(|x| { Box::new(x.unpack()) }); let vector_of_referrables = self.vector_of_referrables().map(|x| { x.iter().map(|t| t.unpack()).collect() }); let single_weak_reference = self.single_weak_reference(); let vector_of_weak_references = self.vector_of_weak_references().map(|x| { x.into_iter().collect() }); let vector_of_strong_referrables = self.vector_of_strong_referrables().map(|x| { x.iter().map(|t| t.unpack()).collect() }); let co_owning_reference = self.co_owning_reference(); let vector_of_co_owning_references = self.vector_of_co_owning_references().map(|x| { x.into_iter().collect() }); let non_owning_reference = self.non_owning_reference(); let vector_of_non_owning_references = self.vector_of_non_owning_references().map(|x| { x.into_iter().collect() }); let any_unique = match self.any_unique_type() { AnyUniqueAliases::NONE => AnyUniqueAliasesT::NONE, AnyUniqueAliases::M => AnyUniqueAliasesT::M(Box::new( self.any_unique_as_m() .expect("Invalid union table, expected `AnyUniqueAliases::M`.") .unpack() )), AnyUniqueAliases::TS => AnyUniqueAliasesT::TS(Box::new( self.any_unique_as_ts() .expect("Invalid union table, expected `AnyUniqueAliases::TS`.") .unpack() )), AnyUniqueAliases::M2 => AnyUniqueAliasesT::M2(Box::new( self.any_unique_as_m2() .expect("Invalid union table, expected `AnyUniqueAliases::M2`.") .unpack() )), _ => AnyUniqueAliasesT::NONE, }; let any_ambiguous = match self.any_ambiguous_type() { AnyAmbiguousAliases::NONE => AnyAmbiguousAliasesT::NONE, AnyAmbiguousAliases::M1 => AnyAmbiguousAliasesT::M1(Box::new( self.any_ambiguous_as_m1() .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`.") .unpack() )), AnyAmbiguousAliases::M2 => AnyAmbiguousAliasesT::M2(Box::new( self.any_ambiguous_as_m2() .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`.") .unpack() )), AnyAmbiguousAliases::M3 => AnyAmbiguousAliasesT::M3(Box::new( self.any_ambiguous_as_m3() .expect("Invalid union table, expected `AnyAmbiguousAliases::M3`.") .unpack() )), _ => AnyAmbiguousAliasesT::NONE, }; let vector_of_enums = self.vector_of_enums().map(|x| { x.into_iter().collect() }); let signed_enum = self.signed_enum(); let testrequirednestedflatbuffer = self.testrequirednestedflatbuffer().map(|x| { x.to_vec() }); let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| { x.iter().map(|t| t.unpack()).collect() }); MonsterT { pos, mana, hp, name, inventory, color, test, test4, testarrayofstring, testarrayoftables, enemy, testnestedflatbuffer, testempty, testbool, testhashs32_fnv1, testhashu32_fnv1, testhashs64_fnv1, testhashu64_fnv1, testhashs32_fnv1a, testhashu32_fnv1a, testhashs64_fnv1a, testhashu64_fnv1a, testarrayofbools, testf, testf2, testf3, testarrayofstring2, testarrayofsortedstruct, flex, test5, vector_of_longs, vector_of_doubles, parent_namespace_test, vector_of_referrables, single_weak_reference, vector_of_weak_references, vector_of_strong_referrables, co_owning_reference, vector_of_co_owning_references, non_owning_reference, vector_of_non_owning_references, any_unique, any_ambiguous, vector_of_enums, signed_enum, testrequirednestedflatbuffer, scalar_key_sorted_tables, } } pub const VT_POS: flatbuffers::VOffsetT = 4; pub const VT_MANA: flatbuffers::VOffsetT = 6; pub const VT_HP: flatbuffers::VOffsetT = 8; pub const VT_NAME: flatbuffers::VOffsetT = 10; pub const VT_INVENTORY: flatbuffers::VOffsetT = 14; pub const VT_COLOR: flatbuffers::VOffsetT = 16; pub const VT_TEST_TYPE: flatbuffers::VOffsetT = 18; pub const VT_TEST: flatbuffers::VOffsetT = 20; pub const VT_TEST4: flatbuffers::VOffsetT = 22; pub const VT_TESTARRAYOFSTRING: flatbuffers::VOffsetT = 24; pub const VT_TESTARRAYOFTABLES: flatbuffers::VOffsetT = 26; pub const VT_ENEMY: flatbuffers::VOffsetT = 28; pub const VT_TESTNESTEDFLATBUFFER: flatbuffers::VOffsetT = 30; pub const VT_TESTEMPTY: flatbuffers::VOffsetT = 32; pub const VT_TESTBOOL: flatbuffers::VOffsetT = 34; pub const VT_TESTHASHS32_FNV1: flatbuffers::VOffsetT = 36; pub const VT_TESTHASHU32_FNV1: flatbuffers::VOffsetT = 38; pub const VT_TESTHASHS64_FNV1: flatbuffers::VOffsetT = 40; pub const VT_TESTHASHU64_FNV1: flatbuffers::VOffsetT = 42; pub const VT_TESTHASHS32_FNV1A: flatbuffers::VOffsetT = 44; pub const VT_TESTHASHU32_FNV1A: flatbuffers::VOffsetT = 46; pub const VT_TESTHASHS64_FNV1A: flatbuffers::VOffsetT = 48; pub const VT_TESTHASHU64_FNV1A: flatbuffers::VOffsetT = 50; pub const VT_TESTARRAYOFBOOLS: flatbuffers::VOffsetT = 52; pub const VT_TESTF: flatbuffers::VOffsetT = 54; pub const VT_TESTF2: flatbuffers::VOffsetT = 56; pub const VT_TESTF3: flatbuffers::VOffsetT = 58; pub const VT_TESTARRAYOFSTRING2: flatbuffers::VOffsetT = 60; pub const VT_TESTARRAYOFSORTEDSTRUCT: flatbuffers::VOffsetT = 62; pub const VT_FLEX: flatbuffers::VOffsetT = 64; pub const VT_TEST5: flatbuffers::VOffsetT = 66; pub const VT_VECTOR_OF_LONGS: flatbuffers::VOffsetT = 68; pub const VT_VECTOR_OF_DOUBLES: flatbuffers::VOffsetT = 70; pub const VT_PARENT_NAMESPACE_TEST: flatbuffers::VOffsetT = 72; pub const VT_VECTOR_OF_REFERRABLES: flatbuffers::VOffsetT = 74; pub const VT_SINGLE_WEAK_REFERENCE: flatbuffers::VOffsetT = 76; pub const VT_VECTOR_OF_WEAK_REFERENCES: flatbuffers::VOffsetT = 78; pub const VT_VECTOR_OF_STRONG_REFERRABLES: flatbuffers::VOffsetT = 80; pub const VT_CO_OWNING_REFERENCE: flatbuffers::VOffsetT = 82; pub const VT_VECTOR_OF_CO_OWNING_REFERENCES: flatbuffers::VOffsetT = 84; pub const VT_NON_OWNING_REFERENCE: flatbuffers::VOffsetT = 86; pub const VT_VECTOR_OF_NON_OWNING_REFERENCES: flatbuffers::VOffsetT = 88; pub const VT_ANY_UNIQUE_TYPE: flatbuffers::VOffsetT = 90; pub const VT_ANY_UNIQUE: flatbuffers::VOffsetT = 92; pub const VT_ANY_AMBIGUOUS_TYPE: flatbuffers::VOffsetT = 94; pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96; pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98; pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100; pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102; pub const VT_SCALAR_KEY_SORTED_TABLES: flatbuffers::VOffsetT = 104; #[inline] pub fn pos(&self) -> Option<&'a Vec3> { self._tab.get::(Monster::VT_POS, None) } #[inline] pub fn mana(&self) -> i16 { self._tab.get::(Monster::VT_MANA, Some(150)).unwrap() } #[inline] pub fn hp(&self) -> i16 { self._tab.get::(Monster::VT_HP, Some(100)).unwrap() } #[inline] pub fn name(&self) -> &'a str { self._tab.get::>(Monster::VT_NAME, None).unwrap() } #[inline] pub fn key_compare_less_than(&self, o: &Monster) -> bool { self.name() < o.name() } #[inline] pub fn key_compare_with_value(&self, val: & str) -> ::std::cmp::Ordering { let key = self.name(); key.cmp(&val) } #[inline] pub fn inventory(&self) -> Option<&'a [u8]> { self._tab.get::>>(Monster::VT_INVENTORY, None).map(|v| v.safe_slice()) } #[inline] pub fn color(&self) -> Color { self._tab.get::(Monster::VT_COLOR, Some(Color::Blue)).unwrap() } #[inline] pub fn test_type(&self) -> Any { self._tab.get::(Monster::VT_TEST_TYPE, Some(Any::NONE)).unwrap() } #[inline] pub fn test(&self) -> Option> { self._tab.get::>>(Monster::VT_TEST, None) } #[inline] pub fn test4(&self) -> Option<&'a [Test]> { self._tab.get::>>(Monster::VT_TEST4, None).map(|v| v.safe_slice()) } #[inline] pub fn testarrayofstring(&self) -> Option>> { self._tab.get::>>>(Monster::VT_TESTARRAYOFSTRING, None) } /// an example documentation comment: this will end up in the generated code /// multiline too #[inline] pub fn testarrayoftables(&self) -> Option>>> { self._tab.get::>>>(Monster::VT_TESTARRAYOFTABLES, None) } #[inline] pub fn enemy(&self) -> Option> { self._tab.get::>(Monster::VT_ENEMY, None) } #[inline] pub fn testnestedflatbuffer(&self) -> Option<&'a [u8]> { self._tab.get::>>(Monster::VT_TESTNESTEDFLATBUFFER, None).map(|v| v.safe_slice()) } pub fn testnestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { self.testnestedflatbuffer().map(|data| { use flatbuffers::Follow; >>::follow(data, 0) }) } #[inline] pub fn testempty(&self) -> Option> { self._tab.get::>(Monster::VT_TESTEMPTY, None) } #[inline] pub fn testbool(&self) -> bool { self._tab.get::(Monster::VT_TESTBOOL, Some(false)).unwrap() } #[inline] pub fn testhashs32_fnv1(&self) -> i32 { self._tab.get::(Monster::VT_TESTHASHS32_FNV1, Some(0)).unwrap() } #[inline] pub fn testhashu32_fnv1(&self) -> u32 { self._tab.get::(Monster::VT_TESTHASHU32_FNV1, Some(0)).unwrap() } #[inline] pub fn testhashs64_fnv1(&self) -> i64 { self._tab.get::(Monster::VT_TESTHASHS64_FNV1, Some(0)).unwrap() } #[inline] pub fn testhashu64_fnv1(&self) -> u64 { self._tab.get::(Monster::VT_TESTHASHU64_FNV1, Some(0)).unwrap() } #[inline] pub fn testhashs32_fnv1a(&self) -> i32 { self._tab.get::(Monster::VT_TESTHASHS32_FNV1A, Some(0)).unwrap() } #[inline] pub fn testhashu32_fnv1a(&self) -> u32 { self._tab.get::(Monster::VT_TESTHASHU32_FNV1A, Some(0)).unwrap() } #[inline] pub fn testhashs64_fnv1a(&self) -> i64 { self._tab.get::(Monster::VT_TESTHASHS64_FNV1A, Some(0)).unwrap() } #[inline] pub fn testhashu64_fnv1a(&self) -> u64 { self._tab.get::(Monster::VT_TESTHASHU64_FNV1A, Some(0)).unwrap() } #[inline] pub fn testarrayofbools(&self) -> Option<&'a [bool]> { self._tab.get::>>(Monster::VT_TESTARRAYOFBOOLS, None).map(|v| v.safe_slice()) } #[inline] pub fn testf(&self) -> f32 { self._tab.get::(Monster::VT_TESTF, Some(3.14159)).unwrap() } #[inline] pub fn testf2(&self) -> f32 { self._tab.get::(Monster::VT_TESTF2, Some(3.0)).unwrap() } #[inline] pub fn testf3(&self) -> f32 { self._tab.get::(Monster::VT_TESTF3, Some(0.0)).unwrap() } #[inline] pub fn testarrayofstring2(&self) -> Option>> { self._tab.get::>>>(Monster::VT_TESTARRAYOFSTRING2, None) } #[inline] pub fn testarrayofsortedstruct(&self) -> Option<&'a [Ability]> { self._tab.get::>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, None).map(|v| v.safe_slice()) } #[inline] pub fn flex(&self) -> Option<&'a [u8]> { self._tab.get::>>(Monster::VT_FLEX, None).map(|v| v.safe_slice()) } #[inline] pub fn test5(&self) -> Option<&'a [Test]> { self._tab.get::>>(Monster::VT_TEST5, None).map(|v| v.safe_slice()) } #[inline] pub fn vector_of_longs(&self) -> Option> { self._tab.get::>>(Monster::VT_VECTOR_OF_LONGS, None) } #[inline] pub fn vector_of_doubles(&self) -> Option> { self._tab.get::>>(Monster::VT_VECTOR_OF_DOUBLES, None) } #[inline] pub fn parent_namespace_test(&self) -> Option> { self._tab.get::>(Monster::VT_PARENT_NAMESPACE_TEST, None) } #[inline] pub fn vector_of_referrables(&self) -> Option>>> { self._tab.get::>>>(Monster::VT_VECTOR_OF_REFERRABLES, None) } #[inline] pub fn single_weak_reference(&self) -> u64 { self._tab.get::(Monster::VT_SINGLE_WEAK_REFERENCE, Some(0)).unwrap() } #[inline] pub fn vector_of_weak_references(&self) -> Option> { self._tab.get::>>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, None) } #[inline] pub fn vector_of_strong_referrables(&self) -> Option>>> { self._tab.get::>>>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, None) } #[inline] pub fn co_owning_reference(&self) -> u64 { self._tab.get::(Monster::VT_CO_OWNING_REFERENCE, Some(0)).unwrap() } #[inline] pub fn vector_of_co_owning_references(&self) -> Option> { self._tab.get::>>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, None) } #[inline] pub fn non_owning_reference(&self) -> u64 { self._tab.get::(Monster::VT_NON_OWNING_REFERENCE, Some(0)).unwrap() } #[inline] pub fn vector_of_non_owning_references(&self) -> Option> { self._tab.get::>>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, None) } #[inline] pub fn any_unique_type(&self) -> AnyUniqueAliases { self._tab.get::(Monster::VT_ANY_UNIQUE_TYPE, Some(AnyUniqueAliases::NONE)).unwrap() } #[inline] pub fn any_unique(&self) -> Option> { self._tab.get::>>(Monster::VT_ANY_UNIQUE, None) } #[inline] pub fn any_ambiguous_type(&self) -> AnyAmbiguousAliases { self._tab.get::(Monster::VT_ANY_AMBIGUOUS_TYPE, Some(AnyAmbiguousAliases::NONE)).unwrap() } #[inline] pub fn any_ambiguous(&self) -> Option> { self._tab.get::>>(Monster::VT_ANY_AMBIGUOUS, None) } #[inline] pub fn vector_of_enums(&self) -> Option> { self._tab.get::>>(Monster::VT_VECTOR_OF_ENUMS, None) } #[inline] pub fn signed_enum(&self) -> Race { self._tab.get::(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap() } #[inline] pub fn testrequirednestedflatbuffer(&self) -> Option<&'a [u8]> { self._tab.get::>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None).map(|v| v.safe_slice()) } pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { self.testrequirednestedflatbuffer().map(|data| { use flatbuffers::Follow; >>::follow(data, 0) }) } #[inline] pub fn scalar_key_sorted_tables(&self) -> Option>>> { self._tab.get::>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None) } #[inline] #[allow(non_snake_case)] pub fn test_as_monster(&self) -> Option> { if self.test_type() == Any::Monster { self.test().map(Monster::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn test_as_test_simple_table_with_enum(&self) -> Option> { if self.test_type() == Any::TestSimpleTableWithEnum { self.test().map(TestSimpleTableWithEnum::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn test_as_my_game_example_2_monster(&self) -> Option> { if self.test_type() == Any::MyGame_Example2_Monster { self.test().map(super::example_2::Monster::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn any_unique_as_m(&self) -> Option> { if self.any_unique_type() == AnyUniqueAliases::M { self.any_unique().map(Monster::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn any_unique_as_ts(&self) -> Option> { if self.any_unique_type() == AnyUniqueAliases::TS { self.any_unique().map(TestSimpleTableWithEnum::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn any_unique_as_m2(&self) -> Option> { if self.any_unique_type() == AnyUniqueAliases::M2 { self.any_unique().map(super::example_2::Monster::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn any_ambiguous_as_m1(&self) -> Option> { if self.any_ambiguous_type() == AnyAmbiguousAliases::M1 { self.any_ambiguous().map(Monster::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn any_ambiguous_as_m2(&self) -> Option> { if self.any_ambiguous_type() == AnyAmbiguousAliases::M2 { self.any_ambiguous().map(Monster::init_from_table) } else { None } } #[inline] #[allow(non_snake_case)] pub fn any_ambiguous_as_m3(&self) -> Option> { if self.any_ambiguous_type() == AnyAmbiguousAliases::M3 { self.any_ambiguous().map(Monster::init_from_table) } else { None } } } impl flatbuffers::Verifiable for Monster<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::(&"pos", Self::VT_POS, false)? .visit_field::(&"mana", Self::VT_MANA, false)? .visit_field::(&"hp", Self::VT_HP, false)? .visit_field::>(&"name", Self::VT_NAME, true)? .visit_field::>>(&"inventory", Self::VT_INVENTORY, false)? .visit_field::(&"color", Self::VT_COLOR, false)? .visit_union::(&"test_type", Self::VT_TEST_TYPE, &"test", Self::VT_TEST, false, |key, v, pos| { match key { Any::Monster => v.verify_union_variant::>("Any::Monster", pos), Any::TestSimpleTableWithEnum => v.verify_union_variant::>("Any::TestSimpleTableWithEnum", pos), Any::MyGame_Example2_Monster => v.verify_union_variant::>("Any::MyGame_Example2_Monster", pos), _ => Ok(()), } })? .visit_field::>>(&"test4", Self::VT_TEST4, false)? .visit_field::>>>(&"testarrayofstring", Self::VT_TESTARRAYOFSTRING, false)? .visit_field::>>>(&"testarrayoftables", Self::VT_TESTARRAYOFTABLES, false)? .visit_field::>(&"enemy", Self::VT_ENEMY, false)? .visit_field::>>(&"testnestedflatbuffer", Self::VT_TESTNESTEDFLATBUFFER, false)? .visit_field::>(&"testempty", Self::VT_TESTEMPTY, false)? .visit_field::(&"testbool", Self::VT_TESTBOOL, false)? .visit_field::(&"testhashs32_fnv1", Self::VT_TESTHASHS32_FNV1, false)? .visit_field::(&"testhashu32_fnv1", Self::VT_TESTHASHU32_FNV1, false)? .visit_field::(&"testhashs64_fnv1", Self::VT_TESTHASHS64_FNV1, false)? .visit_field::(&"testhashu64_fnv1", Self::VT_TESTHASHU64_FNV1, false)? .visit_field::(&"testhashs32_fnv1a", Self::VT_TESTHASHS32_FNV1A, false)? .visit_field::(&"testhashu32_fnv1a", Self::VT_TESTHASHU32_FNV1A, false)? .visit_field::(&"testhashs64_fnv1a", Self::VT_TESTHASHS64_FNV1A, false)? .visit_field::(&"testhashu64_fnv1a", Self::VT_TESTHASHU64_FNV1A, false)? .visit_field::>>(&"testarrayofbools", Self::VT_TESTARRAYOFBOOLS, false)? .visit_field::(&"testf", Self::VT_TESTF, false)? .visit_field::(&"testf2", Self::VT_TESTF2, false)? .visit_field::(&"testf3", Self::VT_TESTF3, false)? .visit_field::>>>(&"testarrayofstring2", Self::VT_TESTARRAYOFSTRING2, false)? .visit_field::>>(&"testarrayofsortedstruct", Self::VT_TESTARRAYOFSORTEDSTRUCT, false)? .visit_field::>>(&"flex", Self::VT_FLEX, false)? .visit_field::>>(&"test5", Self::VT_TEST5, false)? .visit_field::>>(&"vector_of_longs", Self::VT_VECTOR_OF_LONGS, false)? .visit_field::>>(&"vector_of_doubles", Self::VT_VECTOR_OF_DOUBLES, false)? .visit_field::>(&"parent_namespace_test", Self::VT_PARENT_NAMESPACE_TEST, false)? .visit_field::>>>(&"vector_of_referrables", Self::VT_VECTOR_OF_REFERRABLES, false)? .visit_field::(&"single_weak_reference", Self::VT_SINGLE_WEAK_REFERENCE, false)? .visit_field::>>(&"vector_of_weak_references", Self::VT_VECTOR_OF_WEAK_REFERENCES, false)? .visit_field::>>>(&"vector_of_strong_referrables", Self::VT_VECTOR_OF_STRONG_REFERRABLES, false)? .visit_field::(&"co_owning_reference", Self::VT_CO_OWNING_REFERENCE, false)? .visit_field::>>(&"vector_of_co_owning_references", Self::VT_VECTOR_OF_CO_OWNING_REFERENCES, false)? .visit_field::(&"non_owning_reference", Self::VT_NON_OWNING_REFERENCE, false)? .visit_field::>>(&"vector_of_non_owning_references", Self::VT_VECTOR_OF_NON_OWNING_REFERENCES, false)? .visit_union::(&"any_unique_type", Self::VT_ANY_UNIQUE_TYPE, &"any_unique", Self::VT_ANY_UNIQUE, false, |key, v, pos| { match key { AnyUniqueAliases::M => v.verify_union_variant::>("AnyUniqueAliases::M", pos), AnyUniqueAliases::TS => v.verify_union_variant::>("AnyUniqueAliases::TS", pos), AnyUniqueAliases::M2 => v.verify_union_variant::>("AnyUniqueAliases::M2", pos), _ => Ok(()), } })? .visit_union::(&"any_ambiguous_type", Self::VT_ANY_AMBIGUOUS_TYPE, &"any_ambiguous", Self::VT_ANY_AMBIGUOUS, false, |key, v, pos| { match key { AnyAmbiguousAliases::M1 => v.verify_union_variant::>("AnyAmbiguousAliases::M1", pos), AnyAmbiguousAliases::M2 => v.verify_union_variant::>("AnyAmbiguousAliases::M2", pos), AnyAmbiguousAliases::M3 => v.verify_union_variant::>("AnyAmbiguousAliases::M3", pos), _ => Ok(()), } })? .visit_field::>>(&"vector_of_enums", Self::VT_VECTOR_OF_ENUMS, false)? .visit_field::(&"signed_enum", Self::VT_SIGNED_ENUM, false)? .visit_field::>>(&"testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)? .visit_field::>>>(&"scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)? .finish(); Ok(()) } } pub struct MonsterArgs<'a> { pub pos: Option<&'a Vec3>, pub mana: i16, pub hp: i16, pub name: Option>, pub inventory: Option>>, pub color: Color, pub test_type: Any, pub test: Option>, pub test4: Option>>, pub testarrayofstring: Option>>>, pub testarrayoftables: Option>>>>, pub enemy: Option>>, pub testnestedflatbuffer: Option>>, pub testempty: Option>>, pub testbool: bool, pub testhashs32_fnv1: i32, pub testhashu32_fnv1: u32, pub testhashs64_fnv1: i64, pub testhashu64_fnv1: u64, pub testhashs32_fnv1a: i32, pub testhashu32_fnv1a: u32, pub testhashs64_fnv1a: i64, pub testhashu64_fnv1a: u64, pub testarrayofbools: Option>>, pub testf: f32, pub testf2: f32, pub testf3: f32, pub testarrayofstring2: Option>>>, pub testarrayofsortedstruct: Option>>, pub flex: Option>>, pub test5: Option>>, pub vector_of_longs: Option>>, pub vector_of_doubles: Option>>, pub parent_namespace_test: Option>>, pub vector_of_referrables: Option>>>>, pub single_weak_reference: u64, pub vector_of_weak_references: Option>>, pub vector_of_strong_referrables: Option>>>>, pub co_owning_reference: u64, pub vector_of_co_owning_references: Option>>, pub non_owning_reference: u64, pub vector_of_non_owning_references: Option>>, pub any_unique_type: AnyUniqueAliases, pub any_unique: Option>, pub any_ambiguous_type: AnyAmbiguousAliases, pub any_ambiguous: Option>, pub vector_of_enums: Option>>, pub signed_enum: Race, pub testrequirednestedflatbuffer: Option>>, pub scalar_key_sorted_tables: Option>>>>, } impl<'a> Default for MonsterArgs<'a> { #[inline] fn default() -> Self { MonsterArgs { pos: None, mana: 150, hp: 100, name: None, // required field inventory: None, color: Color::Blue, test_type: Any::NONE, test: None, test4: None, testarrayofstring: None, testarrayoftables: None, enemy: None, testnestedflatbuffer: None, testempty: None, testbool: false, testhashs32_fnv1: 0, testhashu32_fnv1: 0, testhashs64_fnv1: 0, testhashu64_fnv1: 0, testhashs32_fnv1a: 0, testhashu32_fnv1a: 0, testhashs64_fnv1a: 0, testhashu64_fnv1a: 0, testarrayofbools: None, testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: None, testarrayofsortedstruct: None, flex: None, test5: None, vector_of_longs: None, vector_of_doubles: None, parent_namespace_test: None, vector_of_referrables: None, single_weak_reference: 0, vector_of_weak_references: None, vector_of_strong_referrables: None, co_owning_reference: 0, vector_of_co_owning_references: None, non_owning_reference: 0, vector_of_non_owning_references: None, any_unique_type: AnyUniqueAliases::NONE, any_unique: None, any_ambiguous_type: AnyAmbiguousAliases::NONE, any_ambiguous: None, vector_of_enums: None, signed_enum: Race::None, testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, } } } pub struct MonsterBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> { #[inline] pub fn add_pos(&mut self, pos: &Vec3) { self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos); } #[inline] pub fn add_mana(&mut self, mana: i16) { self.fbb_.push_slot::(Monster::VT_MANA, mana, 150); } #[inline] pub fn add_hp(&mut self, hp: i16) { self.fbb_.push_slot::(Monster::VT_HP, hp, 100); } #[inline] pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { self.fbb_.push_slot_always::>(Monster::VT_NAME, name); } #[inline] pub fn add_inventory(&mut self, inventory: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_INVENTORY, inventory); } #[inline] pub fn add_color(&mut self, color: Color) { self.fbb_.push_slot::(Monster::VT_COLOR, color, Color::Blue); } #[inline] pub fn add_test_type(&mut self, test_type: Any) { self.fbb_.push_slot::(Monster::VT_TEST_TYPE, test_type, Any::NONE); } #[inline] pub fn add_test(&mut self, test: flatbuffers::WIPOffset) { self.fbb_.push_slot_always::>(Monster::VT_TEST, test); } #[inline] pub fn add_test4(&mut self, test4: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_TEST4, test4); } #[inline] pub fn add_testarrayofstring(&mut self, testarrayofstring: flatbuffers::WIPOffset>>) { self.fbb_.push_slot_always::>(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); } #[inline] pub fn add_testarrayoftables(&mut self, testarrayoftables: flatbuffers::WIPOffset>>>) { self.fbb_.push_slot_always::>(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); } #[inline] pub fn add_enemy(&mut self, enemy: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_ENEMY, enemy); } #[inline] pub fn add_testnestedflatbuffer(&mut self, testnestedflatbuffer: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); } #[inline] pub fn add_testempty(&mut self, testempty: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_TESTEMPTY, testempty); } #[inline] pub fn add_testbool(&mut self, testbool: bool) { self.fbb_.push_slot::(Monster::VT_TESTBOOL, testbool, false); } #[inline] pub fn add_testhashs32_fnv1(&mut self, testhashs32_fnv1: i32) { self.fbb_.push_slot::(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0); } #[inline] pub fn add_testhashu32_fnv1(&mut self, testhashu32_fnv1: u32) { self.fbb_.push_slot::(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0); } #[inline] pub fn add_testhashs64_fnv1(&mut self, testhashs64_fnv1: i64) { self.fbb_.push_slot::(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0); } #[inline] pub fn add_testhashu64_fnv1(&mut self, testhashu64_fnv1: u64) { self.fbb_.push_slot::(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0); } #[inline] pub fn add_testhashs32_fnv1a(&mut self, testhashs32_fnv1a: i32) { self.fbb_.push_slot::(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0); } #[inline] pub fn add_testhashu32_fnv1a(&mut self, testhashu32_fnv1a: u32) { self.fbb_.push_slot::(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0); } #[inline] pub fn add_testhashs64_fnv1a(&mut self, testhashs64_fnv1a: i64) { self.fbb_.push_slot::(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0); } #[inline] pub fn add_testhashu64_fnv1a(&mut self, testhashu64_fnv1a: u64) { self.fbb_.push_slot::(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0); } #[inline] pub fn add_testarrayofbools(&mut self, testarrayofbools: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools); } #[inline] pub fn add_testf(&mut self, testf: f32) { self.fbb_.push_slot::(Monster::VT_TESTF, testf, 3.14159); } #[inline] pub fn add_testf2(&mut self, testf2: f32) { self.fbb_.push_slot::(Monster::VT_TESTF2, testf2, 3.0); } #[inline] pub fn add_testf3(&mut self, testf3: f32) { self.fbb_.push_slot::(Monster::VT_TESTF3, testf3, 0.0); } #[inline] pub fn add_testarrayofstring2(&mut self, testarrayofstring2: flatbuffers::WIPOffset>>) { self.fbb_.push_slot_always::>(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); } #[inline] pub fn add_testarrayofsortedstruct(&mut self, testarrayofsortedstruct: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); } #[inline] pub fn add_flex(&mut self, flex: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_FLEX, flex); } #[inline] pub fn add_test5(&mut self, test5: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_TEST5, test5); } #[inline] pub fn add_vector_of_longs(&mut self, vector_of_longs: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); } #[inline] pub fn add_vector_of_doubles(&mut self, vector_of_doubles: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles); } #[inline] pub fn add_parent_namespace_test(&mut self, parent_namespace_test: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); } #[inline] pub fn add_vector_of_referrables(&mut self, vector_of_referrables: flatbuffers::WIPOffset>>>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables); } #[inline] pub fn add_single_weak_reference(&mut self, single_weak_reference: u64) { self.fbb_.push_slot::(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0); } #[inline] pub fn add_vector_of_weak_references(&mut self, vector_of_weak_references: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references); } #[inline] pub fn add_vector_of_strong_referrables(&mut self, vector_of_strong_referrables: flatbuffers::WIPOffset>>>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables); } #[inline] pub fn add_co_owning_reference(&mut self, co_owning_reference: u64) { self.fbb_.push_slot::(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0); } #[inline] pub fn add_vector_of_co_owning_references(&mut self, vector_of_co_owning_references: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references); } #[inline] pub fn add_non_owning_reference(&mut self, non_owning_reference: u64) { self.fbb_.push_slot::(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0); } #[inline] pub fn add_vector_of_non_owning_references(&mut self, vector_of_non_owning_references: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references); } #[inline] pub fn add_any_unique_type(&mut self, any_unique_type: AnyUniqueAliases) { self.fbb_.push_slot::(Monster::VT_ANY_UNIQUE_TYPE, any_unique_type, AnyUniqueAliases::NONE); } #[inline] pub fn add_any_unique(&mut self, any_unique: flatbuffers::WIPOffset) { self.fbb_.push_slot_always::>(Monster::VT_ANY_UNIQUE, any_unique); } #[inline] pub fn add_any_ambiguous_type(&mut self, any_ambiguous_type: AnyAmbiguousAliases) { self.fbb_.push_slot::(Monster::VT_ANY_AMBIGUOUS_TYPE, any_ambiguous_type, AnyAmbiguousAliases::NONE); } #[inline] pub fn add_any_ambiguous(&mut self, any_ambiguous: flatbuffers::WIPOffset) { self.fbb_.push_slot_always::>(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); } #[inline] pub fn add_vector_of_enums(&mut self, vector_of_enums: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums); } #[inline] pub fn add_signed_enum(&mut self, signed_enum: Race) { self.fbb_.push_slot::(Monster::VT_SIGNED_ENUM, signed_enum, Race::None); } #[inline] pub fn add_testrequirednestedflatbuffer(&mut self, testrequirednestedflatbuffer: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); } #[inline] pub fn add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: flatbuffers::WIPOffset>>>) { self.fbb_.push_slot_always::>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> { let start = _fbb.start_table(); MonsterBuilder { fbb_: _fbb, start_: start, } } #[inline] pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Monster::VT_NAME,"name"); flatbuffers::WIPOffset::new(o.value()) } } impl std::fmt::Debug for Monster<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut ds = f.debug_struct("Monster"); ds.field("pos", &self.pos()); ds.field("mana", &self.mana()); ds.field("hp", &self.hp()); ds.field("name", &self.name()); ds.field("inventory", &self.inventory()); ds.field("color", &self.color()); ds.field("test_type", &self.test_type()); match self.test_type() { Any::Monster => { if let Some(x) = self.test_as_monster() { ds.field("test", &x) } else { ds.field("test", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, Any::TestSimpleTableWithEnum => { if let Some(x) = self.test_as_test_simple_table_with_enum() { ds.field("test", &x) } else { ds.field("test", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, Any::MyGame_Example2_Monster => { if let Some(x) = self.test_as_my_game_example_2_monster() { ds.field("test", &x) } else { ds.field("test", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, _ => { let x: Option<()> = None; ds.field("test", &x) }, }; ds.field("test4", &self.test4()); ds.field("testarrayofstring", &self.testarrayofstring()); ds.field("testarrayoftables", &self.testarrayoftables()); ds.field("enemy", &self.enemy()); ds.field("testnestedflatbuffer", &self.testnestedflatbuffer()); ds.field("testempty", &self.testempty()); ds.field("testbool", &self.testbool()); ds.field("testhashs32_fnv1", &self.testhashs32_fnv1()); ds.field("testhashu32_fnv1", &self.testhashu32_fnv1()); ds.field("testhashs64_fnv1", &self.testhashs64_fnv1()); ds.field("testhashu64_fnv1", &self.testhashu64_fnv1()); ds.field("testhashs32_fnv1a", &self.testhashs32_fnv1a()); ds.field("testhashu32_fnv1a", &self.testhashu32_fnv1a()); ds.field("testhashs64_fnv1a", &self.testhashs64_fnv1a()); ds.field("testhashu64_fnv1a", &self.testhashu64_fnv1a()); ds.field("testarrayofbools", &self.testarrayofbools()); ds.field("testf", &self.testf()); ds.field("testf2", &self.testf2()); ds.field("testf3", &self.testf3()); ds.field("testarrayofstring2", &self.testarrayofstring2()); ds.field("testarrayofsortedstruct", &self.testarrayofsortedstruct()); ds.field("flex", &self.flex()); ds.field("test5", &self.test5()); ds.field("vector_of_longs", &self.vector_of_longs()); ds.field("vector_of_doubles", &self.vector_of_doubles()); ds.field("parent_namespace_test", &self.parent_namespace_test()); ds.field("vector_of_referrables", &self.vector_of_referrables()); ds.field("single_weak_reference", &self.single_weak_reference()); ds.field("vector_of_weak_references", &self.vector_of_weak_references()); ds.field("vector_of_strong_referrables", &self.vector_of_strong_referrables()); ds.field("co_owning_reference", &self.co_owning_reference()); ds.field("vector_of_co_owning_references", &self.vector_of_co_owning_references()); ds.field("non_owning_reference", &self.non_owning_reference()); ds.field("vector_of_non_owning_references", &self.vector_of_non_owning_references()); ds.field("any_unique_type", &self.any_unique_type()); match self.any_unique_type() { AnyUniqueAliases::M => { if let Some(x) = self.any_unique_as_m() { ds.field("any_unique", &x) } else { ds.field("any_unique", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, AnyUniqueAliases::TS => { if let Some(x) = self.any_unique_as_ts() { ds.field("any_unique", &x) } else { ds.field("any_unique", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, AnyUniqueAliases::M2 => { if let Some(x) = self.any_unique_as_m2() { ds.field("any_unique", &x) } else { ds.field("any_unique", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, _ => { let x: Option<()> = None; ds.field("any_unique", &x) }, }; ds.field("any_ambiguous_type", &self.any_ambiguous_type()); match self.any_ambiguous_type() { AnyAmbiguousAliases::M1 => { if let Some(x) = self.any_ambiguous_as_m1() { ds.field("any_ambiguous", &x) } else { ds.field("any_ambiguous", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, AnyAmbiguousAliases::M2 => { if let Some(x) = self.any_ambiguous_as_m2() { ds.field("any_ambiguous", &x) } else { ds.field("any_ambiguous", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, AnyAmbiguousAliases::M3 => { if let Some(x) = self.any_ambiguous_as_m3() { ds.field("any_ambiguous", &x) } else { ds.field("any_ambiguous", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, _ => { let x: Option<()> = None; ds.field("any_ambiguous", &x) }, }; ds.field("vector_of_enums", &self.vector_of_enums()); ds.field("signed_enum", &self.signed_enum()); ds.field("testrequirednestedflatbuffer", &self.testrequirednestedflatbuffer()); ds.field("scalar_key_sorted_tables", &self.scalar_key_sorted_tables()); ds.finish() } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct MonsterT { pub pos: Option, pub mana: i16, pub hp: i16, pub name: String, pub inventory: Option>, pub color: Color, pub test: AnyT, pub test4: Option>, pub testarrayofstring: Option>, pub testarrayoftables: Option>, pub enemy: Option>, pub testnestedflatbuffer: Option>, pub testempty: Option>, pub testbool: bool, pub testhashs32_fnv1: i32, pub testhashu32_fnv1: u32, pub testhashs64_fnv1: i64, pub testhashu64_fnv1: u64, pub testhashs32_fnv1a: i32, pub testhashu32_fnv1a: u32, pub testhashs64_fnv1a: i64, pub testhashu64_fnv1a: u64, pub testarrayofbools: Option>, pub testf: f32, pub testf2: f32, pub testf3: f32, pub testarrayofstring2: Option>, pub testarrayofsortedstruct: Option>, pub flex: Option>, pub test5: Option>, pub vector_of_longs: Option>, pub vector_of_doubles: Option>, pub parent_namespace_test: Option>, pub vector_of_referrables: Option>, pub single_weak_reference: u64, pub vector_of_weak_references: Option>, pub vector_of_strong_referrables: Option>, pub co_owning_reference: u64, pub vector_of_co_owning_references: Option>, pub non_owning_reference: u64, pub vector_of_non_owning_references: Option>, pub any_unique: AnyUniqueAliasesT, pub any_ambiguous: AnyAmbiguousAliasesT, pub vector_of_enums: Option>, pub signed_enum: Race, pub testrequirednestedflatbuffer: Option>, pub scalar_key_sorted_tables: Option>, } impl Default for MonsterT { fn default() -> Self { Self { pos: None, mana: 150, hp: 100, name: "".to_string(), inventory: None, color: Color::Blue, test: AnyT::NONE, test4: None, testarrayofstring: None, testarrayoftables: None, enemy: None, testnestedflatbuffer: None, testempty: None, testbool: false, testhashs32_fnv1: 0, testhashu32_fnv1: 0, testhashs64_fnv1: 0, testhashu64_fnv1: 0, testhashs32_fnv1a: 0, testhashu32_fnv1a: 0, testhashs64_fnv1a: 0, testhashu64_fnv1a: 0, testarrayofbools: None, testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: None, testarrayofsortedstruct: None, flex: None, test5: None, vector_of_longs: None, vector_of_doubles: None, parent_namespace_test: None, vector_of_referrables: None, single_weak_reference: 0, vector_of_weak_references: None, vector_of_strong_referrables: None, co_owning_reference: 0, vector_of_co_owning_references: None, non_owning_reference: 0, vector_of_non_owning_references: None, any_unique: AnyUniqueAliasesT::NONE, any_ambiguous: AnyAmbiguousAliasesT::NONE, vector_of_enums: None, signed_enum: Race::None, testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, } } } impl MonsterT { pub fn pack<'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b> ) -> flatbuffers::WIPOffset> { let pos_tmp = self.pos.as_ref().map(|x| x.pack()); let pos = pos_tmp.as_ref(); let mana = self.mana; let hp = self.hp; let name = Some({ let x = &self.name; _fbb.create_string(x) }); let inventory = self.inventory.as_ref().map(|x|{ _fbb.create_vector(x) }); let color = self.color; let test_type = self.test.any_type(); let test = self.test.pack(_fbb); let test4 = self.test4.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) }); let testarrayofstring = self.testarrayofstring.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|s| s.as_ref()).collect();_fbb.create_vector_of_strings(&w) }); let testarrayoftables = self.testarrayoftables.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) }); let enemy = self.enemy.as_ref().map(|x|{ x.pack(_fbb) }); let testnestedflatbuffer = self.testnestedflatbuffer.as_ref().map(|x|{ _fbb.create_vector(x) }); let testempty = self.testempty.as_ref().map(|x|{ x.pack(_fbb) }); let testbool = self.testbool; let testhashs32_fnv1 = self.testhashs32_fnv1; let testhashu32_fnv1 = self.testhashu32_fnv1; let testhashs64_fnv1 = self.testhashs64_fnv1; let testhashu64_fnv1 = self.testhashu64_fnv1; let testhashs32_fnv1a = self.testhashs32_fnv1a; let testhashu32_fnv1a = self.testhashu32_fnv1a; let testhashs64_fnv1a = self.testhashs64_fnv1a; let testhashu64_fnv1a = self.testhashu64_fnv1a; let testarrayofbools = self.testarrayofbools.as_ref().map(|x|{ _fbb.create_vector(x) }); let testf = self.testf; let testf2 = self.testf2; let testf3 = self.testf3; let testarrayofstring2 = self.testarrayofstring2.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|s| s.as_ref()).collect();_fbb.create_vector_of_strings(&w) }); let testarrayofsortedstruct = self.testarrayofsortedstruct.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) }); let flex = self.flex.as_ref().map(|x|{ _fbb.create_vector(x) }); let test5 = self.test5.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) }); let vector_of_longs = self.vector_of_longs.as_ref().map(|x|{ _fbb.create_vector(x) }); let vector_of_doubles = self.vector_of_doubles.as_ref().map(|x|{ _fbb.create_vector(x) }); let parent_namespace_test = self.parent_namespace_test.as_ref().map(|x|{ x.pack(_fbb) }); let vector_of_referrables = self.vector_of_referrables.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) }); let single_weak_reference = self.single_weak_reference; let vector_of_weak_references = self.vector_of_weak_references.as_ref().map(|x|{ _fbb.create_vector(x) }); let vector_of_strong_referrables = self.vector_of_strong_referrables.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) }); let co_owning_reference = self.co_owning_reference; let vector_of_co_owning_references = self.vector_of_co_owning_references.as_ref().map(|x|{ _fbb.create_vector(x) }); let non_owning_reference = self.non_owning_reference; let vector_of_non_owning_references = self.vector_of_non_owning_references.as_ref().map(|x|{ _fbb.create_vector(x) }); let any_unique_type = self.any_unique.any_unique_aliases_type(); let any_unique = self.any_unique.pack(_fbb); let any_ambiguous_type = self.any_ambiguous.any_ambiguous_aliases_type(); let any_ambiguous = self.any_ambiguous.pack(_fbb); let vector_of_enums = self.vector_of_enums.as_ref().map(|x|{ _fbb.create_vector(x) }); let signed_enum = self.signed_enum; let testrequirednestedflatbuffer = self.testrequirednestedflatbuffer.as_ref().map(|x|{ _fbb.create_vector(x) }); let scalar_key_sorted_tables = self.scalar_key_sorted_tables.as_ref().map(|x|{ let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) }); Monster::create(_fbb, &MonsterArgs{ pos, mana, hp, name, inventory, color, test_type, test, test4, testarrayofstring, testarrayoftables, enemy, testnestedflatbuffer, testempty, testbool, testhashs32_fnv1, testhashu32_fnv1, testhashs64_fnv1, testhashu64_fnv1, testhashs32_fnv1a, testhashu32_fnv1a, testhashs64_fnv1a, testhashu64_fnv1a, testarrayofbools, testf, testf2, testf3, testarrayofstring2, testarrayofsortedstruct, flex, test5, vector_of_longs, vector_of_doubles, parent_namespace_test, vector_of_referrables, single_weak_reference, vector_of_weak_references, vector_of_strong_referrables, co_owning_reference, vector_of_co_owning_references, non_owning_reference, vector_of_non_owning_references, any_unique_type, any_unique, any_ambiguous_type, any_ambiguous, vector_of_enums, signed_enum, testrequirednestedflatbuffer, scalar_key_sorted_tables, }) } } pub enum TypeAliasesOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TypeAliases<'a> { pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for TypeAliases<'a> { type Inner = TypeAliases<'a>; #[inline] fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table { buf, loc } } } } impl<'a> TypeAliases<'a> { pub const fn get_fully_qualified_name() -> &'static str { "MyGame.Example.TypeAliases" } #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { TypeAliases { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, args: &'args TypeAliasesArgs<'args>) -> flatbuffers::WIPOffset> { let mut builder = TypeAliasesBuilder::new(_fbb); builder.add_f64_(args.f64_); builder.add_u64_(args.u64_); builder.add_i64_(args.i64_); if let Some(x) = args.vf64 { builder.add_vf64(x); } if let Some(x) = args.v8 { builder.add_v8(x); } builder.add_f32_(args.f32_); builder.add_u32_(args.u32_); builder.add_i32_(args.i32_); builder.add_u16_(args.u16_); builder.add_i16_(args.i16_); builder.add_u8_(args.u8_); builder.add_i8_(args.i8_); builder.finish() } pub fn unpack(&self) -> TypeAliasesT { let i8_ = self.i8_(); let u8_ = self.u8_(); let i16_ = self.i16_(); let u16_ = self.u16_(); let i32_ = self.i32_(); let u32_ = self.u32_(); let i64_ = self.i64_(); let u64_ = self.u64_(); let f32_ = self.f32_(); let f64_ = self.f64_(); let v8 = self.v8().map(|x| { x.to_vec() }); let vf64 = self.vf64().map(|x| { x.into_iter().collect() }); TypeAliasesT { i8_, u8_, i16_, u16_, i32_, u32_, i64_, u64_, f32_, f64_, v8, vf64, } } pub const VT_I8_: flatbuffers::VOffsetT = 4; pub const VT_U8_: flatbuffers::VOffsetT = 6; pub const VT_I16_: flatbuffers::VOffsetT = 8; pub const VT_U16_: flatbuffers::VOffsetT = 10; pub const VT_I32_: flatbuffers::VOffsetT = 12; pub const VT_U32_: flatbuffers::VOffsetT = 14; pub const VT_I64_: flatbuffers::VOffsetT = 16; pub const VT_U64_: flatbuffers::VOffsetT = 18; pub const VT_F32_: flatbuffers::VOffsetT = 20; pub const VT_F64_: flatbuffers::VOffsetT = 22; pub const VT_V8: flatbuffers::VOffsetT = 24; pub const VT_VF64: flatbuffers::VOffsetT = 26; #[inline] pub fn i8_(&self) -> i8 { self._tab.get::(TypeAliases::VT_I8_, Some(0)).unwrap() } #[inline] pub fn u8_(&self) -> u8 { self._tab.get::(TypeAliases::VT_U8_, Some(0)).unwrap() } #[inline] pub fn i16_(&self) -> i16 { self._tab.get::(TypeAliases::VT_I16_, Some(0)).unwrap() } #[inline] pub fn u16_(&self) -> u16 { self._tab.get::(TypeAliases::VT_U16_, Some(0)).unwrap() } #[inline] pub fn i32_(&self) -> i32 { self._tab.get::(TypeAliases::VT_I32_, Some(0)).unwrap() } #[inline] pub fn u32_(&self) -> u32 { self._tab.get::(TypeAliases::VT_U32_, Some(0)).unwrap() } #[inline] pub fn i64_(&self) -> i64 { self._tab.get::(TypeAliases::VT_I64_, Some(0)).unwrap() } #[inline] pub fn u64_(&self) -> u64 { self._tab.get::(TypeAliases::VT_U64_, Some(0)).unwrap() } #[inline] pub fn f32_(&self) -> f32 { self._tab.get::(TypeAliases::VT_F32_, Some(0.0)).unwrap() } #[inline] pub fn f64_(&self) -> f64 { self._tab.get::(TypeAliases::VT_F64_, Some(0.0)).unwrap() } #[inline] pub fn v8(&self) -> Option<&'a [i8]> { self._tab.get::>>(TypeAliases::VT_V8, None).map(|v| v.safe_slice()) } #[inline] pub fn vf64(&self) -> Option> { self._tab.get::>>(TypeAliases::VT_VF64, None) } } impl flatbuffers::Verifiable for TypeAliases<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::(&"i8_", Self::VT_I8_, false)? .visit_field::(&"u8_", Self::VT_U8_, false)? .visit_field::(&"i16_", Self::VT_I16_, false)? .visit_field::(&"u16_", Self::VT_U16_, false)? .visit_field::(&"i32_", Self::VT_I32_, false)? .visit_field::(&"u32_", Self::VT_U32_, false)? .visit_field::(&"i64_", Self::VT_I64_, false)? .visit_field::(&"u64_", Self::VT_U64_, false)? .visit_field::(&"f32_", Self::VT_F32_, false)? .visit_field::(&"f64_", Self::VT_F64_, false)? .visit_field::>>(&"v8", Self::VT_V8, false)? .visit_field::>>(&"vf64", Self::VT_VF64, false)? .finish(); Ok(()) } } pub struct TypeAliasesArgs<'a> { pub i8_: i8, pub u8_: u8, pub i16_: i16, pub u16_: u16, pub i32_: i32, pub u32_: u32, pub i64_: i64, pub u64_: u64, pub f32_: f32, pub f64_: f64, pub v8: Option>>, pub vf64: Option>>, } impl<'a> Default for TypeAliasesArgs<'a> { #[inline] fn default() -> Self { TypeAliasesArgs { i8_: 0, u8_: 0, i16_: 0, u16_: 0, i32_: 0, u32_: 0, i64_: 0, u64_: 0, f32_: 0.0, f64_: 0.0, v8: None, vf64: None, } } } pub struct TypeAliasesBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> TypeAliasesBuilder<'a, 'b> { #[inline] pub fn add_i8_(&mut self, i8_: i8) { self.fbb_.push_slot::(TypeAliases::VT_I8_, i8_, 0); } #[inline] pub fn add_u8_(&mut self, u8_: u8) { self.fbb_.push_slot::(TypeAliases::VT_U8_, u8_, 0); } #[inline] pub fn add_i16_(&mut self, i16_: i16) { self.fbb_.push_slot::(TypeAliases::VT_I16_, i16_, 0); } #[inline] pub fn add_u16_(&mut self, u16_: u16) { self.fbb_.push_slot::(TypeAliases::VT_U16_, u16_, 0); } #[inline] pub fn add_i32_(&mut self, i32_: i32) { self.fbb_.push_slot::(TypeAliases::VT_I32_, i32_, 0); } #[inline] pub fn add_u32_(&mut self, u32_: u32) { self.fbb_.push_slot::(TypeAliases::VT_U32_, u32_, 0); } #[inline] pub fn add_i64_(&mut self, i64_: i64) { self.fbb_.push_slot::(TypeAliases::VT_I64_, i64_, 0); } #[inline] pub fn add_u64_(&mut self, u64_: u64) { self.fbb_.push_slot::(TypeAliases::VT_U64_, u64_, 0); } #[inline] pub fn add_f32_(&mut self, f32_: f32) { self.fbb_.push_slot::(TypeAliases::VT_F32_, f32_, 0.0); } #[inline] pub fn add_f64_(&mut self, f64_: f64) { self.fbb_.push_slot::(TypeAliases::VT_F64_, f64_, 0.0); } #[inline] pub fn add_v8(&mut self, v8: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(TypeAliases::VT_V8, v8); } #[inline] pub fn add_vf64(&mut self, vf64: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(TypeAliases::VT_VF64, vf64); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TypeAliasesBuilder<'a, 'b> { let start = _fbb.start_table(); TypeAliasesBuilder { fbb_: _fbb, start_: start, } } #[inline] pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } impl std::fmt::Debug for TypeAliases<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut ds = f.debug_struct("TypeAliases"); ds.field("i8_", &self.i8_()); ds.field("u8_", &self.u8_()); ds.field("i16_", &self.i16_()); ds.field("u16_", &self.u16_()); ds.field("i32_", &self.i32_()); ds.field("u32_", &self.u32_()); ds.field("i64_", &self.i64_()); ds.field("u64_", &self.u64_()); ds.field("f32_", &self.f32_()); ds.field("f64_", &self.f64_()); ds.field("v8", &self.v8()); ds.field("vf64", &self.vf64()); ds.finish() } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TypeAliasesT { pub i8_: i8, pub u8_: u8, pub i16_: i16, pub u16_: u16, pub i32_: i32, pub u32_: u32, pub i64_: i64, pub u64_: u64, pub f32_: f32, pub f64_: f64, pub v8: Option>, pub vf64: Option>, } impl Default for TypeAliasesT { fn default() -> Self { Self { i8_: 0, u8_: 0, i16_: 0, u16_: 0, i32_: 0, u32_: 0, i64_: 0, u64_: 0, f32_: 0.0, f64_: 0.0, v8: None, vf64: None, } } } impl TypeAliasesT { pub fn pack<'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b> ) -> flatbuffers::WIPOffset> { let i8_ = self.i8_; let u8_ = self.u8_; let i16_ = self.i16_; let u16_ = self.u16_; let i32_ = self.i32_; let u32_ = self.u32_; let i64_ = self.i64_; let u64_ = self.u64_; let f32_ = self.f32_; let f64_ = self.f64_; let v8 = self.v8.as_ref().map(|x|{ _fbb.create_vector(x) }); let vf64 = self.vf64.as_ref().map(|x|{ _fbb.create_vector(x) }); TypeAliases::create(_fbb, &TypeAliasesArgs{ i8_, u8_, i16_, u16_, i32_, u32_, i64_, u64_, f32_, f64_, v8, vf64, }) } } #[inline] #[deprecated(since="2.0.0", note="Deprecated in favor of `root_as...` methods.")] pub fn get_root_as_monster<'a>(buf: &'a [u8]) -> Monster<'a> { unsafe { flatbuffers::root_unchecked::>(buf) } } #[inline] #[deprecated(since="2.0.0", note="Deprecated in favor of `root_as...` methods.")] pub fn get_size_prefixed_root_as_monster<'a>(buf: &'a [u8]) -> Monster<'a> { unsafe { flatbuffers::size_prefixed_root_unchecked::>(buf) } } #[inline] /// Verifies that a buffer of bytes contains a `Monster` /// and returns it. /// Note that verification is still experimental and may not /// catch every error, or be maximally performant. For the /// previous, unchecked, behavior use /// `root_as_monster_unchecked`. pub fn root_as_monster(buf: &[u8]) -> Result { flatbuffers::root::(buf) } #[inline] /// Verifies that a buffer of bytes contains a size prefixed /// `Monster` and returns it. /// Note that verification is still experimental and may not /// catch every error, or be maximally performant. For the /// previous, unchecked, behavior use /// `size_prefixed_root_as_monster_unchecked`. pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result { flatbuffers::size_prefixed_root::(buf) } #[inline] /// Verifies, with the given options, that a buffer of bytes /// contains a `Monster` and returns it. /// Note that verification is still experimental and may not /// catch every error, or be maximally performant. For the /// previous, unchecked, behavior use /// `root_as_monster_unchecked`. pub fn root_as_monster_with_opts<'b, 'o>( opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], ) -> Result, flatbuffers::InvalidFlatbuffer> { flatbuffers::root_with_opts::>(opts, buf) } #[inline] /// Verifies, with the given verifier options, that a buffer of /// bytes contains a size prefixed `Monster` and returns /// it. Note that verification is still experimental and may not /// catch every error, or be maximally performant. For the /// previous, unchecked, behavior use /// `root_as_monster_unchecked`. pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>( opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], ) -> Result, flatbuffers::InvalidFlatbuffer> { flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } #[inline] /// Assumes, without verification, that a buffer of bytes contains a Monster and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid `Monster`. pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster { flatbuffers::root_unchecked::(buf) } #[inline] /// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`. pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster { flatbuffers::size_prefixed_root_unchecked::(buf) } pub const MONSTER_IDENTIFIER: &str = "MONS"; #[inline] pub fn monster_buffer_has_identifier(buf: &[u8]) -> bool { flatbuffers::buffer_has_identifier(buf, MONSTER_IDENTIFIER, false) } #[inline] pub fn monster_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool { flatbuffers::buffer_has_identifier(buf, MONSTER_IDENTIFIER, true) } pub const MONSTER_EXTENSION: &str = "mon"; #[inline] pub fn finish_monster_buffer<'a, 'b>( fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset>) { fbb.finish(root, Some(MONSTER_IDENTIFIER)); } #[inline] pub fn finish_size_prefixed_monster_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset>) { fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER)); } } // pub mod Example } // pub mod MyGame