From 57659d9f380ac6c0404e5ee803f05cb52007ed12 Mon Sep 17 00:00:00 2001 From: Cameron Mulhern Date: Thu, 5 Mar 2026 09:04:55 -0500 Subject: [PATCH] Updates Rust codegen to use proper indentation (#8952) * Fixes identation of generated Rust code * Regenerates generated schemas --- goldens/rust/basic_generated.rs | 574 +-- samples/rust_generated/mod.rs | 26 +- .../my_game/sample/color_generated.rs | 100 +- .../my_game/sample/equipment_generated.rs | 162 +- .../my_game/sample/monster_generated.rs | 750 +-- .../my_game/sample/vec_3_generated.rs | 282 +- .../my_game/sample/weapon_generated.rs | 234 +- src/idl_gen_rust.cpp | 772 +-- tests/arrays_test/mod.rs | 22 +- .../my_game/example/array_struct_generated.rs | 416 +- .../my_game/example/array_table_generated.rs | 222 +- .../example/nested_struct_generated.rs | 284 +- .../my_game/example/test_enum_generated.rs | 100 +- tests/include_test1/mod.rs | 18 +- .../from_include_generated.rs | 84 +- .../other_name_space/table_b_generated.rs | 188 +- .../other_name_space/unused_generated.rs | 150 +- tests/include_test1/table_a_generated.rs | 188 +- tests/include_test1_generated.rs | 862 ++-- tests/include_test2/mod.rs | 18 +- .../from_include_generated.rs | 84 +- .../other_name_space/table_b_generated.rs | 188 +- .../other_name_space/unused_generated.rs | 150 +- tests/include_test2/table_a_generated.rs | 188 +- tests/include_test2_generated.rs | 862 ++-- .../keyword_test/abc_generated.rs | 100 +- .../keywords_in_table_generated.rs | 318 +- .../keywords_in_union_generated.rs | 220 +- .../keyword_test/public_generated.rs | 84 +- .../keyword_test/table_2_generated.rs | 348 +- tests/keyword_test/mod.rs | 22 +- tests/monster_test/mod.rs | 102 +- .../my_game/example/ability_generated.rs | 238 +- .../any_ambiguous_aliases_generated.rs | 278 +- .../my_game/example/any_generated.rs | 278 +- .../example/any_unique_aliases_generated.rs | 278 +- .../my_game/example/color_generated.rs | 68 +- .../my_game/example/long_enum_generated.rs | 60 +- .../my_game/example/monster_generated.rs | 3884 +++++++-------- .../my_game/example/race_generated.rs | 108 +- .../my_game/example/referrable_generated.rs | 198 +- .../my_game/example/stat_generated.rs | 298 +- .../example/struct_of_structs_generated.rs | 192 +- .../struct_of_structs_of_structs_generated.rs | 120 +- .../my_game/example/test_generated.rs | 216 +- .../test_simple_table_with_enum_generated.rs | 180 +- .../my_game/example/type_aliases_generated.rs | 702 +-- .../my_game/example/vec_3_generated.rs | 450 +- .../my_game/example_2/monster_generated.rs | 134 +- .../my_game/in_parent_namespace_generated.rs | 134 +- .../from_include_generated.rs | 84 +- .../other_name_space/table_b_generated.rs | 188 +- .../other_name_space/unused_generated.rs | 150 +- tests/monster_test/table_a_generated.rs | 188 +- tests/monster_test_serialize/mod.rs | 102 +- .../my_game/example/ability_generated.rs | 254 +- .../any_ambiguous_aliases_generated.rs | 290 +- .../my_game/example/any_generated.rs | 290 +- .../example/any_unique_aliases_generated.rs | 290 +- .../my_game/example/color_generated.rs | 80 +- .../my_game/example/long_enum_generated.rs | 72 +- .../my_game/example/monster_generated.rs | 4328 +++++++++-------- .../my_game/example/race_generated.rs | 120 +- .../my_game/example/referrable_generated.rs | 214 +- .../my_game/example/stat_generated.rs | 326 +- .../example/struct_of_structs_generated.rs | 210 +- .../struct_of_structs_of_structs_generated.rs | 134 +- .../my_game/example/test_generated.rs | 232 +- .../test_simple_table_with_enum_generated.rs | 196 +- .../my_game/example/type_aliases_generated.rs | 756 +-- .../my_game/example/vec_3_generated.rs | 474 +- .../my_game/example_2/monster_generated.rs | 148 +- .../my_game/in_parent_namespace_generated.rs | 148 +- .../from_include_generated.rs | 96 +- .../other_name_space/table_b_generated.rs | 212 +- .../other_name_space/unused_generated.rs | 164 +- .../table_a_generated.rs | 212 +- tests/more_defaults/abc_generated.rs | 100 +- .../more_defaults/more_defaults_generated.rs | 482 +- tests/namespace_test/mod.rs | 36 +- .../enum_in_nested_ns_generated.rs | 100 +- .../struct_in_nested_ns_generated.rs | 216 +- .../table_in_nested_ns_generated.rs | 180 +- .../union_in_nested_ns_generated.rs | 162 +- .../second_table_in_a_generated.rs | 188 +- .../table_in_first_ns_generated.rs | 454 +- .../namespace_c/table_in_c_generated.rs | 242 +- tests/optional_scalars/mod.rs | 10 +- .../optional_byte_generated.rs | 100 +- .../scalar_stuff_generated.rs | 1826 +++---- tests/private_annotation_test/ab_generated.rs | 92 +- .../annotations_generated.rs | 180 +- .../private_annotation_test/any_generated.rs | 220 +- .../private_annotation_test/game_generated.rs | 180 +- .../object_generated.rs | 150 +- tests/rust_namer_test/mod.rs | 38 +- .../rust_namer_test/field_table_generated.rs | 134 +- .../rust_namer_test/field_union_generated.rs | 162 +- .../rust_namer_test/game_message_generated.rs | 278 +- .../game_message_wrapper_generated.rs | 400 +- .../player_input_change_generated.rs | 134 +- .../player_spectate_generated.rs | 134 +- .../player_stat_event_generated.rs | 134 +- .../possibly_reserved_words_generated.rs | 348 +- .../rust_namer_test/root_table_generated.rs | 296 +- 105 files changed, 16456 insertions(+), 16412 deletions(-) diff --git a/goldens/rust/basic_generated.rs b/goldens/rust/basic_generated.rs index 941408d4a..b8a699b68 100644 --- a/goldens/rust/basic_generated.rs +++ b/goldens/rust/basic_generated.rs @@ -4,315 +4,319 @@ extern crate alloc; #[allow(unused_imports, dead_code)] pub mod flatbuffers { - extern crate alloc; - - #[allow(unused_imports, dead_code)] - pub mod goldens { extern crate alloc; - pub enum GalaxyOffset {} + #[allow(unused_imports, dead_code)] + pub mod goldens { + extern crate alloc; - #[derive(Copy, Clone, PartialEq)] - pub struct Galaxy<'a> { - pub _tab: ::flatbuffers::Table<'a>, - } + pub enum GalaxyOffset {} - impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> { - type Inner = Galaxy<'a>; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } - } - - impl<'a> Galaxy<'a> { - pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - Galaxy { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args GalaxyArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = GalaxyBuilder::new(_fbb); - builder.add_num_stars(args.num_stars); - builder.finish() - } - - - #[inline] - pub fn num_stars(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Galaxy::VT_NUM_STARS, Some(0)).unwrap()} - } - } - - impl ::flatbuffers::Verifiable for Galaxy<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("num_stars", Self::VT_NUM_STARS, false)? - .finish(); - Ok(()) - } - } - - pub struct GalaxyArgs { - pub num_stars: i64, - } - - impl<'a> Default for GalaxyArgs { - #[inline] - fn default() -> Self { - GalaxyArgs { - num_stars: 0, + #[derive(Copy, Clone, PartialEq)] + pub struct Galaxy<'a> { + pub _tab: ::flatbuffers::Table<'a>, } - } - } - pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, - } + impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> { + type Inner = Galaxy<'a>; - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> { - #[inline] - pub fn add_num_stars(&mut self, num_stars: i64) { - self.fbb_.push_slot::(Galaxy::VT_NUM_STARS, num_stars, 0); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - GalaxyBuilder { - fbb_: _fbb, - start_: start, + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } - } + impl<'a> Galaxy<'a> { + pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4; - impl ::core::fmt::Debug for Galaxy<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Galaxy"); - ds.field("num_stars", &self.num_stars()); - ds.finish() - } - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Galaxy { _tab: table } + } - pub enum UniverseOffset {} - - #[derive(Copy, Clone, PartialEq)] - pub struct Universe<'a> { - pub _tab: ::flatbuffers::Table<'a>, - } - - impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> { - type Inner = Universe<'a>; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } - } - - impl<'a> Universe<'a> { - pub const VT_AGE: ::flatbuffers::VOffsetT = 4; - pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - Universe { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args UniverseArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = UniverseBuilder::new(_fbb); - builder.add_age(args.age); - if let Some(x) = args.galaxies { builder.add_galaxies(x); } - builder.finish() - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args GalaxyArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = GalaxyBuilder::new(_fbb); + builder.add_num_stars(args.num_stars); + builder.finish() + } - #[inline] - pub fn age(&self) -> f64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Universe::VT_AGE, Some(0.0)).unwrap()} - } - - #[inline] - pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Universe::VT_GALAXIES, None)} - } - } - - impl ::flatbuffers::Verifiable for Universe<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("age", Self::VT_AGE, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("galaxies", Self::VT_GALAXIES, false)? - .finish(); - Ok(()) - } - } - - pub struct UniverseArgs<'a> { - pub age: f64, - pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>>, - } - - impl<'a> Default for UniverseArgs<'a> { - #[inline] - fn default() -> Self { - UniverseArgs { - age: 0.0, - galaxies: None, + #[inline] + pub fn num_stars(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Galaxy::VT_NUM_STARS, Some(0)).unwrap()} + } } - } - } - pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, - } - - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> { - #[inline] - pub fn add_age(&mut self, age: f64) { - self.fbb_.push_slot::(Universe::VT_AGE, age, 0.0); - } - - #[inline] - pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - UniverseBuilder { - fbb_: _fbb, - start_: start, + impl ::flatbuffers::Verifiable for Galaxy<'_> { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("num_stars", Self::VT_NUM_STARS, false)? + .finish(); + Ok(()) + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } - } + pub struct GalaxyArgs { + pub num_stars: i64, + } - impl ::core::fmt::Debug for Universe<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Universe"); - ds.field("age", &self.age()); - ds.field("galaxies", &self.galaxies()); - ds.finish() - } - } + impl<'a> Default for GalaxyArgs { + #[inline] + fn default() -> Self { + GalaxyArgs { + num_stars: 0, + } + } + } - /// Verifies that a buffer of bytes contains a `Universe` - /// 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_universe_unchecked`. - #[inline] - pub fn root_as_universe(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) - } + pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + } - /// Verifies that a buffer of bytes contains a size prefixed - /// `Universe` 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_universe_unchecked`. - #[inline] - pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) - } + impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> { + #[inline] + pub fn add_num_stars(&mut self, num_stars: i64) { + self.fbb_.push_slot::(Galaxy::VT_NUM_STARS, num_stars, 0); + } - /// Verifies, with the given options, that a buffer of bytes - /// contains a `Universe` 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_universe_unchecked`. - #[inline] - pub fn root_as_universe_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + GalaxyBuilder { + fbb_: _fbb, + start_: start, + } + } - /// Verifies, with the given verifier options, that a buffer of - /// bytes contains a size prefixed `Universe` 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_universe_unchecked`. - #[inline] - pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } + } - /// Assumes, without verification, that a buffer of bytes contains a Universe and returns it. - /// # Safety - /// Callers must trust the given bytes do indeed contain a valid `Universe`. - #[inline] - pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } - } + impl ::core::fmt::Debug for Galaxy<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Galaxy"); + ds.field("num_stars", &self.num_stars()); + ds.finish() + } + } - /// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it. - /// # Safety - /// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`. - #[inline] - pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } - } + pub enum UniverseOffset {} - #[inline] - pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( - fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>) { - fbb.finish(root, None); - } + #[derive(Copy, Clone, PartialEq)] + pub struct Universe<'a> { + pub _tab: ::flatbuffers::Table<'a>, + } - #[inline] - pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset>) { - fbb.finish_size_prefixed(root, None); - } - } // pub mod goldens + impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> { + type Inner = Universe<'a>; + + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } + } + + impl<'a> Universe<'a> { + pub const VT_AGE: ::flatbuffers::VOffsetT = 4; + pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Universe { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args UniverseArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = UniverseBuilder::new(_fbb); + builder.add_age(args.age); + if let Some(x) = args.galaxies { builder.add_galaxies(x); } + builder.finish() + } + + + #[inline] + pub fn age(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Universe::VT_AGE, Some(0.0)).unwrap()} + } + + #[inline] + pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Universe::VT_GALAXIES, None)} + } + } + + impl ::flatbuffers::Verifiable for Universe<'_> { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("age", Self::VT_AGE, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("galaxies", Self::VT_GALAXIES, false)? + .finish(); + Ok(()) + } + } + + pub struct UniverseArgs<'a> { + pub age: f64, + pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>>, + } + + impl<'a> Default for UniverseArgs<'a> { + #[inline] + fn default() -> Self { + UniverseArgs { + age: 0.0, + galaxies: None, + } + } + } + + pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + } + + impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> { + #[inline] + pub fn add_age(&mut self, age: f64) { + self.fbb_.push_slot::(Universe::VT_AGE, age, 0.0); + } + + #[inline] + pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + UniverseBuilder { + 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 ::core::fmt::Debug for Universe<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Universe"); + ds.field("age", &self.age()); + ds.field("galaxies", &self.galaxies()); + ds.finish() + } + } + + /// Verifies that a buffer of bytes contains a `Universe` + /// 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_universe_unchecked`. + #[inline] + pub fn root_as_universe(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::root::(buf) + } + + /// Verifies that a buffer of bytes contains a size prefixed + /// `Universe` 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_universe_unchecked`. + #[inline] + pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::size_prefixed_root::(buf) + } + + /// Verifies, with the given options, that a buffer of bytes + /// contains a `Universe` 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_universe_unchecked`. + #[inline] + pub fn root_as_universe_with_opts<'b, 'o>( + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], + ) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::root_with_opts::>(opts, buf) + } + + /// Verifies, with the given verifier options, that a buffer of + /// bytes contains a size prefixed `Universe` 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_universe_unchecked`. + #[inline] + pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>( + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], + ) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + } + + /// Assumes, without verification, that a buffer of bytes contains a Universe and returns it. + /// # Safety + /// Callers must trust the given bytes do indeed contain a valid `Universe`. + #[inline] + pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> { + unsafe { ::flatbuffers::root_unchecked::(buf) } + } + + /// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it. + /// # Safety + /// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`. + #[inline] + pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> { + unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + } + + #[inline] + pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset> + ) { + fbb.finish(root, None); + } + + #[inline] + pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset> + ) { + fbb.finish_size_prefixed(root, None); + } + } // pub mod goldens } // pub mod flatbuffers diff --git a/samples/rust_generated/mod.rs b/samples/rust_generated/mod.rs index 5f7e92453..50e577aa1 100644 --- a/samples/rust_generated/mod.rs +++ b/samples/rust_generated/mod.rs @@ -1,18 +1,18 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod my_game { - use super::*; - pub mod sample { use super::*; - mod color_generated; - pub use self::color_generated::*; - mod equipment_generated; - pub use self::equipment_generated::*; - mod vec_3_generated; - pub use self::vec_3_generated::*; - mod monster_generated; - pub use self::monster_generated::*; - mod weapon_generated; - pub use self::weapon_generated::*; - } // sample + pub mod sample { + use super::*; + mod color_generated; + pub use self::color_generated::*; + mod equipment_generated; + pub use self::equipment_generated::*; + mod vec_3_generated; + pub use self::vec_3_generated::*; + mod monster_generated; + pub use self::monster_generated::*; + mod weapon_generated; + pub use self::weapon_generated::*; + } // sample } // my_game diff --git a/samples/rust_generated/my_game/sample/color_generated.rs b/samples/rust_generated/my_game/sample/color_generated.rs index 88ed9ea44..df74180e1 100644 --- a/samples/rust_generated/my_game/sample/color_generated.rs +++ b/samples/rust_generated/my_game/sample/color_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_COLOR: 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_COLOR: [Color; 3] = [ - Color::Red, - Color::Green, - Color::Blue, + Color::Red, + Color::Green, + Color::Blue, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub struct Color(pub i8); #[allow(non_upper_case_globals)] impl Color { - pub const Red: Self = Self(0); - pub const Green: Self = Self(1); - pub const Blue: Self = Self(2); + pub const Red: Self = Self(0); + pub const Green: Self = Self(1); + pub const Blue: Self = Self(2); - pub const ENUM_MIN: i8 = 0; - pub const ENUM_MAX: i8 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::Red, - Self::Green, - Self::Blue, - ]; + pub const ENUM_MIN: i8 = 0; + pub const ENUM_MAX: i8 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::Red, + Self::Green, + Self::Blue, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::Red => Some("Red"), - Self::Green => Some("Green"), - Self::Blue => Some("Blue"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::Red => Some("Red"), + Self::Green => Some("Green"), + Self::Blue => Some("Blue"), + _ => None, + } } - } } impl ::core::fmt::Debug for Color { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 Color { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for Color { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for Color { } impl ::flatbuffers::EndianScalar for Color { - type Scalar = i8; + type Scalar = i8; - #[inline] - fn to_little_endian(self) -> i8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i8) -> Self { - let b = i8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i8) -> Self { + let b = i8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for Color { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Color {} diff --git a/samples/rust_generated/my_game/sample/equipment_generated.rs b/samples/rust_generated/my_game/sample/equipment_generated.rs index de61cf7ec..e347757e1 100644 --- a/samples/rust_generated/my_game/sample/equipment_generated.rs +++ b/samples/rust_generated/my_game/sample/equipment_generated.rs @@ -12,8 +12,8 @@ pub const ENUM_MAX_EQUIPMENT: u8 = 1; #[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_EQUIPMENT: [Equipment; 2] = [ - Equipment::NONE, - Equipment::Weapon, + Equipment::NONE, + Equipment::Weapon, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -22,44 +22,44 @@ pub struct Equipment(pub u8); #[allow(non_upper_case_globals)] impl Equipment { - pub const NONE: Self = Self(0); - pub const Weapon: Self = Self(1); + pub const NONE: Self = Self(0); + pub const Weapon: Self = Self(1); - pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 1; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::Weapon, - ]; + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 1; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + Self::Weapon, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - Self::Weapon => Some("Weapon"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + Self::Weapon => Some("Weapon"), + _ => None, + } } - } } impl ::core::fmt::Debug for Equipment { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 Equipment { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for Equipment { @@ -72,28 +72,28 @@ impl ::flatbuffers::Push for Equipment { } impl ::flatbuffers::EndianScalar for Equipment { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for Equipment { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Equipment {} @@ -104,53 +104,53 @@ pub struct EquipmentUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum EquipmentT { - NONE, - Weapon(alloc::boxed::Box), + NONE, + Weapon(alloc::boxed::Box), } impl Default for EquipmentT { - fn default() -> Self { - Self::NONE - } + fn default() -> Self { + Self::NONE + } } impl EquipmentT { - pub fn equipment_type(&self) -> Equipment { - match self { - Self::NONE => Equipment::NONE, - Self::Weapon(_) => Equipment::Weapon, + pub fn equipment_type(&self) -> Equipment { + match self { + Self::NONE => Equipment::NONE, + Self::Weapon(_) => Equipment::Weapon, + } } - } - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - match self { - Self::NONE => None, - Self::Weapon(v) => Some(v.pack(fbb).as_union_value()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + match self { + Self::NONE => None, + Self::Weapon(v) => Some(v.pack(fbb).as_union_value()), + } } - } - /// If the union variant matches, return the owned WeaponT, setting the union to NONE. - pub fn take_weapon(&mut self) -> Option> { - if let Self::Weapon(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::Weapon(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return the owned WeaponT, setting the union to NONE. + pub fn take_weapon(&mut self) -> Option> { + if let Self::Weapon(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::Weapon(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } } - } - /// If the union variant matches, return a reference to the WeaponT. - pub fn as_weapon(&self) -> Option<&WeaponT> { - if let Self::Weapon(v) = self { Some(v.as_ref()) } else { None } - } + /// If the union variant matches, return a reference to the WeaponT. + pub fn as_weapon(&self) -> Option<&WeaponT> { + if let Self::Weapon(v) = self { Some(v.as_ref()) } else { None } + } - /// If the union variant matches, return a mutable reference to the WeaponT. - pub fn as_weapon_mut(&mut self) -> Option<&mut WeaponT> { - if let Self::Weapon(v) = self { Some(v.as_mut()) } else { None } - } + /// If the union variant matches, return a mutable reference to the WeaponT. + pub fn as_weapon_mut(&mut self) -> Option<&mut WeaponT> { + if let Self::Weapon(v) = self { Some(v.as_mut()) } else { None } + } } diff --git a/samples/rust_generated/my_game/sample/monster_generated.rs b/samples/rust_generated/my_game/sample/monster_generated.rs index 645c1c27b..fa36fbf11 100644 --- a/samples/rust_generated/my_game/sample/monster_generated.rs +++ b/samples/rust_generated/my_game/sample/monster_generated.rs @@ -7,218 +7,218 @@ pub enum MonsterOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Monster<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> { - type Inner = Monster<'a>; + type Inner = Monster<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Monster<'a> { - 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_WEAPONS: ::flatbuffers::VOffsetT = 18; - pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20; - pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22; - pub const VT_PATH: ::flatbuffers::VOffsetT = 24; + 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_WEAPONS: ::flatbuffers::VOffsetT = 18; + pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20; + pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22; + pub const VT_PATH: ::flatbuffers::VOffsetT = 24; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Sample.Monster" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args MonsterArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = MonsterBuilder::new(_fbb); - if let Some(x) = args.path { builder.add_path(x); } - if let Some(x) = args.equipped { builder.add_equipped(x); } - if let Some(x) = args.weapons { builder.add_weapons(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_equipped_type(args.equipped_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 = self.name().map(|x| { - alloc::string::ToString::to_string(x) - }); - let inventory = self.inventory().map(|x| { - x.into_iter().collect() - }); - let color = self.color(); - let weapons = self.weapons().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - let equipped = match self.equipped_type() { - Equipment::NONE => EquipmentT::NONE, - Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new( - self.equipped_as_weapon() - .expect("Invalid union table, expected `Equipment::Weapon`.") - .unpack() - )), - _ => EquipmentT::NONE, - }; - let path = self.path().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - MonsterT { - pos, - mana, - hp, - name, - inventory, - color, - weapons, - equipped, - path, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Sample.Monster" } - } - #[inline] - pub fn pos(&self) -> Option<&'a Vec3> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_POS, None)} - } - - #[inline] - pub fn mana(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_MANA, Some(150)).unwrap()} - } - - #[inline] - pub fn hp(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_HP, Some(100)).unwrap()} - } - - #[inline] - pub fn name(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)} - } - - #[inline] - pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)} - } - - #[inline] - pub fn color(&self) -> Color { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_COLOR, Some(Color::Blue)).unwrap()} - } - - #[inline] - pub fn weapons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_WEAPONS, None)} - } - - #[inline] - pub fn equipped_type(&self) -> Equipment { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()} - } - - #[inline] - pub fn equipped(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)} - } - - #[inline] - pub fn path(&self) -> Option<::flatbuffers::Vector<'a, Vec3>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Vec3>>>(Monster::VT_PATH, None)} - } - - #[inline] - #[allow(non_snake_case)] - pub fn equipped_as_weapon(&self) -> Option> { - if self.equipped_type() == Equipment::Weapon { - self.equipped().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Weapon::init_from_table(t) } - }) - } else { - None + #[inline] + pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args MonsterArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = MonsterBuilder::new(_fbb); + if let Some(x) = args.path { builder.add_path(x); } + if let Some(x) = args.equipped { builder.add_equipped(x); } + if let Some(x) = args.weapons { builder.add_weapons(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_equipped_type(args.equipped_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 = self.name().map(|x| { + alloc::string::ToString::to_string(x) + }); + let inventory = self.inventory().map(|x| { + x.into_iter().collect() + }); + let color = self.color(); + let weapons = self.weapons().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + let equipped = match self.equipped_type() { + Equipment::NONE => EquipmentT::NONE, + Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new( + self.equipped_as_weapon() + .expect("Invalid union table, expected `Equipment::Weapon`.") + .unpack() + )), + _ => EquipmentT::NONE, + }; + let path = self.path().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + MonsterT { + pos, + mana, + hp, + name, + inventory, + color, + weapons, + equipped, + path, + } + } + + #[inline] + pub fn pos(&self) -> Option<&'a Vec3> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_POS, None)} + } + + #[inline] + pub fn mana(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_MANA, Some(150)).unwrap()} + } + + #[inline] + pub fn hp(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_HP, Some(100)).unwrap()} + } + + #[inline] + pub fn name(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)} + } + + #[inline] + pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)} + } + + #[inline] + pub fn color(&self) -> Color { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_COLOR, Some(Color::Blue)).unwrap()} + } + + #[inline] + pub fn weapons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_WEAPONS, None)} + } + + #[inline] + pub fn equipped_type(&self) -> Equipment { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()} + } + + #[inline] + pub fn equipped(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)} + } + + #[inline] + pub fn path(&self) -> Option<::flatbuffers::Vector<'a, Vec3>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Vec3>>>(Monster::VT_PATH, None)} + } + + #[inline] + #[allow(non_snake_case)] + pub fn equipped_as_weapon(&self) -> Option> { + if self.equipped_type() == Equipment::Weapon { + self.equipped().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Weapon::init_from_table(t) } + }) + } else { + None + } } - } } impl ::flatbuffers::Verifiable for Monster<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - 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::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)? - .visit_field::("color", Self::VT_COLOR, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("weapons", Self::VT_WEAPONS, false)? - .visit_union::("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| { - match key { - Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Equipment::Weapon", pos), - _ => Ok(()), - } - })? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)? + .visit_field::("color", Self::VT_COLOR, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("weapons", Self::VT_WEAPONS, false)? + .visit_union::("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| { + match key { + Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Equipment::Weapon", pos), + _ => Ok(()), + } + })? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)? + .finish(); + Ok(()) + } } pub struct MonsterArgs<'a> { @@ -235,191 +235,191 @@ pub struct MonsterArgs<'a> { } impl<'a> Default for MonsterArgs<'a> { - #[inline] - fn default() -> Self { - MonsterArgs { - pos: None, - mana: 150, - hp: 100, - name: None, - inventory: None, - color: Color::Blue, - weapons: None, - equipped_type: Equipment::NONE, - equipped: None, - path: None, + #[inline] + fn default() -> Self { + MonsterArgs { + pos: None, + mana: 150, + hp: 100, + name: None, + inventory: None, + color: Color::Blue, + weapons: None, + equipped_type: Equipment::NONE, + equipped: None, + path: None, + } } - } } pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> { - #[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::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name); - } - - #[inline] - pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons); - } - - #[inline] - pub fn add_equipped_type(&mut self, equipped_type: Equipment) { - self.fbb_.push_slot::(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE); - } - - #[inline] - pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped); - } - - #[inline] - pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - MonsterBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_pos(&mut self, pos: &Vec3) { + self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[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::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name); + } + + #[inline] + pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons); + } + + #[inline] + pub fn add_equipped_type(&mut self, equipped_type: Equipment) { + self.fbb_.push_slot::(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE); + } + + #[inline] + pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped); + } + + #[inline] + pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for Monster<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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("weapons", &self.weapons()); - ds.field("equipped_type", &self.equipped_type()); - match self.equipped_type() { - Equipment::Weapon => { - if let Some(x) = self.equipped_as_weapon() { - ds.field("equipped", &x) - } else { - ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("equipped", &x) - }, - }; - ds.field("path", &self.path()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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("weapons", &self.weapons()); + ds.field("equipped_type", &self.equipped_type()); + match self.equipped_type() { + Equipment::Weapon => { + if let Some(x) = self.equipped_as_weapon() { + ds.field("equipped", &x) + } else { + ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + _ => { + let x: Option<()> = None; + ds.field("equipped", &x) + }, + }; + ds.field("path", &self.path()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct MonsterT { - pub pos: Option, - pub mana: i16, - pub hp: i16, - pub name: Option, - pub inventory: Option>, - pub color: Color, - pub weapons: Option>, - pub equipped: EquipmentT, - pub path: Option>, + pub pos: Option, + pub mana: i16, + pub hp: i16, + pub name: Option, + pub inventory: Option>, + pub color: Color, + pub weapons: Option>, + pub equipped: EquipmentT, + pub path: Option>, } impl Default for MonsterT { - fn default() -> Self { - Self { - pos: None, - mana: 150, - hp: 100, - name: None, - inventory: None, - color: Color::Blue, - weapons: None, - equipped: EquipmentT::NONE, - path: None, + fn default() -> Self { + Self { + pos: None, + mana: 150, + hp: 100, + name: None, + inventory: None, + color: Color::Blue, + weapons: None, + equipped: EquipmentT::NONE, + path: None, + } } - } } impl MonsterT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::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 = self.name.as_ref().map(|x|{ - _fbb.create_string(x) - }); - let inventory = self.inventory.as_ref().map(|x|{ - _fbb.create_vector(x) - }); - let color = self.color; - let weapons = self.weapons.as_ref().map(|x|{ - let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) - }); - let equipped_type = self.equipped.equipment_type(); - let equipped = self.equipped.pack(_fbb); - let path = self.path.as_ref().map(|x|{ - let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) - }); - Monster::create(_fbb, &MonsterArgs{ - pos, - mana, - hp, - name, - inventory, - color, - weapons, - equipped_type, - equipped, - path, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::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 = self.name.as_ref().map(|x|{ + _fbb.create_string(x) + }); + let inventory = self.inventory.as_ref().map(|x|{ + _fbb.create_vector(x) + }); + let color = self.color; + let weapons = self.weapons.as_ref().map(|x|{ + let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) + }); + let equipped_type = self.equipped.equipment_type(); + let equipped = self.equipped.pack(_fbb); + let path = self.path.as_ref().map(|x|{ + let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) + }); + Monster::create(_fbb, &MonsterArgs{ + pos, + mana, + hp, + name, + inventory, + color, + weapons, + equipped_type, + equipped, + path, + }) + } } /// Verifies that a buffer of bytes contains a `Monster` @@ -430,7 +430,7 @@ impl MonsterT { /// `root_as_monster_unchecked`. #[inline] pub fn root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) + ::flatbuffers::root::(buf) } /// Verifies that a buffer of bytes contains a size prefixed @@ -441,7 +441,7 @@ pub fn root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::Invalid /// `size_prefixed_root_as_monster_unchecked`. #[inline] pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) + ::flatbuffers::size_prefixed_root::(buf) } /// Verifies, with the given options, that a buffer of bytes @@ -452,10 +452,10 @@ pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result, ::flatbu /// `root_as_monster_unchecked`. #[inline] pub fn root_as_monster_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) + ::flatbuffers::root_with_opts::>(opts, buf) } /// Verifies, with the given verifier options, that a buffer of @@ -466,10 +466,10 @@ pub fn root_as_monster_with_opts<'b, 'o>( /// `root_as_monster_unchecked`. #[inline] pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } /// Assumes, without verification, that a buffer of bytes contains a Monster and returns it. @@ -477,7 +477,7 @@ pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>( /// Callers must trust the given bytes do indeed contain a valid `Monster`. #[inline] pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } + unsafe { ::flatbuffers::root_unchecked::(buf) } } /// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it. @@ -485,17 +485,21 @@ pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { /// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`. #[inline] pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } } #[inline] pub fn finish_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>) { - fbb.finish(root, None); + root: ::flatbuffers::WIPOffset> +) { + fbb.finish(root, None); } #[inline] -pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset>) { - fbb.finish_size_prefixed(root, None); +pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset> +) { + fbb.finish_size_prefixed(root, None); } diff --git a/samples/rust_generated/my_game/sample/vec_3_generated.rs b/samples/rust_generated/my_game/sample/vec_3_generated.rs index cc2c5c132..5b2aca7fd 100644 --- a/samples/rust_generated/my_game/sample/vec_3_generated.rs +++ b/samples/rust_generated/my_game/sample/vec_3_generated.rs @@ -8,40 +8,40 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Vec3(pub [u8; 12]); -impl Default for Vec3 { - fn default() -> Self { - Self([0; 12]) - } +impl Default for Vec3 { + fn default() -> Self { + Self([0; 12]) + } } impl ::core::fmt::Debug for Vec3 { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Vec3") - .field("x", &self.x()) - .field("y", &self.y()) - .field("z", &self.z()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Vec3") + .field("x", &self.x()) + .field("y", &self.y()) + .field("z", &self.z()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Vec3 {} impl<'a> ::flatbuffers::Follow<'a> for Vec3 { - type Inner = &'a Vec3; + type Inner = &'a Vec3; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Vec3>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Vec3>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Vec3 { - type Inner = &'a Vec3; + type Inner = &'a Vec3; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Vec3 { @@ -60,141 +60,141 @@ impl<'b> ::flatbuffers::Push for Vec3 { } impl<'a> ::flatbuffers::Verifiable for Vec3 { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> Vec3 { - #[allow(clippy::too_many_arguments)] - pub fn new( - x: f32, - y: f32, - z: f32, - ) -> Self { - let mut s = Self([0; 12]); - s.set_x(x); - s.set_y(y); - s.set_z(z); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Sample.Vec3" - } - - pub fn x(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_x(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + x: f32, + y: f32, + z: f32, + ) -> Self { + let mut s = Self([0; 12]); + s.set_x(x); + s.set_y(y); + s.set_z(z); + s } - } - pub fn y(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[4..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_y(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[4..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Sample.Vec3" } - } - pub fn z(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[8..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_z(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[8..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn x(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) } - } - pub fn unpack(&self) -> Vec3T { - Vec3T { - x: self.x(), - y: self.y(), - z: self.z(), + pub fn set_x(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn y(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[4..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_y(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[4..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn z(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[8..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_z(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[8..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> Vec3T { + Vec3T { + x: self.x(), + y: self.y(), + z: self.z(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct Vec3T { - pub x: f32, - pub y: f32, - pub z: f32, + pub x: f32, + pub y: f32, + pub z: f32, } impl Vec3T { - pub fn pack(&self) -> Vec3 { - Vec3::new( - self.x, - self.y, - self.z, - ) - } + pub fn pack(&self) -> Vec3 { + Vec3::new( + self.x, + self.y, + self.z, + ) + } } diff --git a/samples/rust_generated/my_game/sample/weapon_generated.rs b/samples/rust_generated/my_game/sample/weapon_generated.rs index d11525fe6..f6598ecd9 100644 --- a/samples/rust_generated/my_game/sample/weapon_generated.rs +++ b/samples/rust_generated/my_game/sample/weapon_generated.rs @@ -7,81 +7,81 @@ pub enum WeaponOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Weapon<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Weapon<'a> { - type Inner = Weapon<'a>; + type Inner = Weapon<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Weapon<'a> { - pub const VT_NAME: ::flatbuffers::VOffsetT = 4; - pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6; + pub const VT_NAME: ::flatbuffers::VOffsetT = 4; + pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Sample.Weapon" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - Weapon { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args WeaponArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = WeaponBuilder::new(_fbb); - if let Some(x) = args.name { builder.add_name(x); } - builder.add_damage(args.damage); - builder.finish() - } - - pub fn unpack(&self) -> WeaponT { - let name = self.name().map(|x| { - alloc::string::ToString::to_string(x) - }); - let damage = self.damage(); - WeaponT { - name, - damage, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Sample.Weapon" } - } - #[inline] - pub fn name(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Weapon { _tab: table } + } - #[inline] - pub fn damage(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Weapon::VT_DAMAGE, Some(0)).unwrap()} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args WeaponArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = WeaponBuilder::new(_fbb); + if let Some(x) = args.name { builder.add_name(x); } + builder.add_damage(args.damage); + builder.finish() + } + + pub fn unpack(&self) -> WeaponT { + let name = self.name().map(|x| { + alloc::string::ToString::to_string(x) + }); + let damage = self.damage(); + WeaponT { + name, + damage, + } + } + + #[inline] + pub fn name(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)} + } + + #[inline] + pub fn damage(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Weapon::VT_DAMAGE, Some(0)).unwrap()} + } } impl ::flatbuffers::Verifiable for Weapon<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)? - .visit_field::("damage", Self::VT_DAMAGE, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)? + .visit_field::("damage", Self::VT_DAMAGE, false)? + .finish(); + Ok(()) + } } pub struct WeaponArgs<'a> { @@ -90,84 +90,84 @@ pub struct WeaponArgs<'a> { } impl<'a> Default for WeaponArgs<'a> { - #[inline] - fn default() -> Self { - WeaponArgs { - name: None, - damage: 0, + #[inline] + fn default() -> Self { + WeaponArgs { + name: None, + damage: 0, + } } - } } pub struct WeaponBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WeaponBuilder<'a, 'b, A> { - #[inline] - pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name); - } - - #[inline] - pub fn add_damage(&mut self, damage: i16) { - self.fbb_.push_slot::(Weapon::VT_DAMAGE, damage, 0); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - WeaponBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_damage(&mut self, damage: i16) { + self.fbb_.push_slot::(Weapon::VT_DAMAGE, damage, 0); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + WeaponBuilder { + 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 ::core::fmt::Debug for Weapon<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Weapon"); - ds.field("name", &self.name()); - ds.field("damage", &self.damage()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Weapon"); + ds.field("name", &self.name()); + ds.field("damage", &self.damage()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct WeaponT { - pub name: Option, - pub damage: i16, + pub name: Option, + pub damage: i16, } impl Default for WeaponT { - fn default() -> Self { - Self { - name: None, - damage: 0, + fn default() -> Self { + Self { + name: None, + damage: 0, + } } - } } impl WeaponT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let name = self.name.as_ref().map(|x|{ - _fbb.create_string(x) - }); - let damage = self.damage; - Weapon::create(_fbb, &WeaponArgs{ - name, - damage, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let name = self.name.as_ref().map(|x|{ + _fbb.create_string(x) + }); + let damage = self.damage; + Weapon::create(_fbb, &WeaponArgs{ + name, + damage, + }) + } } diff --git a/src/idl_gen_rust.cpp b/src/idl_gen_rust.cpp index 398475f80..13a024113 100644 --- a/src/idl_gen_rust.cpp +++ b/src/idl_gen_rust.cpp @@ -330,7 +330,7 @@ static bool GenerateRustModuleRootFile(const Parser& parser, it++) { root_module.Insert(namer, *it); } - CodeWriter code(" "); + CodeWriter code(" "); // TODO(caspern): Move generated warning out of BaseGenerator. code += "// Automatically generated by the Flatbuffers compiler. " @@ -354,7 +354,7 @@ class RustGenerator : public BaseGenerator { namer_(WithFlagOptions(RustDefaultConfig(), parser.opts, path), RustKeywords()) { // TODO: Namer flag overrides should be in flatc or flatc_main. - code_.SetPadding(" "); + code_.SetPadding(" "); } bool generate() { @@ -729,16 +729,16 @@ class RustGenerator : public BaseGenerator { // constants but in camel case. code_ += "#[allow(non_upper_case_globals)]"; code_ += "mod bitflags_{{ENUM_NAMESPACE}} {"; - code_ += " ::flatbuffers::bitflags::bitflags! {"; - GenComment(enum_def.doc_comment, " "); - code_ += " #[derive(Default, Debug, Clone, Copy, PartialEq)]"; - code_ += " {{ACCESS_TYPE}} struct {{ENUM_TY}}: {{BASE_TYPE}} {"; + code_ += " ::flatbuffers::bitflags::bitflags! {"; + GenComment(enum_def.doc_comment, " "); + code_ += " #[derive(Default, Debug, Clone, Copy, PartialEq)]"; + code_ += " {{ACCESS_TYPE}} struct {{ENUM_TY}}: {{BASE_TYPE}} {"; ForAllEnumValues1(enum_def, [&](const EnumVal& ev) { - this->GenComment(ev.doc_comment, " "); - code_ += " const {{VARIANT}} = {{VALUE}};"; + this->GenComment(ev.doc_comment, " "); + code_ += " const {{VARIANT}} = {{VALUE}};"; }); + code_ += " }"; code_ += " }"; - code_ += " }"; code_ += "}"; code_ += ""; @@ -794,36 +794,39 @@ class RustGenerator : public BaseGenerator { }); code_ += ""; // Generate Associated constants - code_ += " pub const ENUM_MIN: {{BASE_TYPE}} = {{ENUM_MIN_BASE_VALUE}};"; - code_ += " pub const ENUM_MAX: {{BASE_TYPE}} = {{ENUM_MAX_BASE_VALUE}};"; - code_ += " pub const ENUM_VALUES: &'static [Self] = &["; - ForAllEnumValues(enum_def, [&]() { code_ += " Self::{{VARIANT}},"; }); - code_ += " ];"; + code_ += + " pub const ENUM_MIN: {{BASE_TYPE}} = {{ENUM_MIN_BASE_VALUE}};"; + code_ += + " pub const ENUM_MAX: {{BASE_TYPE}} = {{ENUM_MAX_BASE_VALUE}};"; + code_ += " pub const ENUM_VALUES: &'static [Self] = &["; + ForAllEnumValues(enum_def, [&]() { code_ += " Self::{{VARIANT}},"; }); + code_ += " ];"; code_ += ""; - code_ += " /// Returns the variant's name or \"\" if unknown."; - code_ += " pub fn variant_name(self) -> Option<&'static str> {"; - code_ += " match self {"; + code_ += " /// Returns the variant's name or \"\" if unknown."; + code_ += " pub fn variant_name(self) -> Option<&'static str> {"; + code_ += " match self {"; ForAllEnumValues(enum_def, [&]() { - code_ += " Self::{{VARIANT}} => Some(\"{{VARIANT}}\"),"; + code_ += " Self::{{VARIANT}} => Some(\"{{VARIANT}}\"),"; }); - code_ += " _ => None,"; + code_ += " _ => None,"; + code_ += " }"; code_ += " }"; - code_ += " }"; code_ += "}"; code_ += ""; // Generate Debug. Unknown variants are printed like "". code_ += "impl ::core::fmt::Debug for {{ENUM_TY}} {"; code_ += - " fn fmt(&self, f: &mut ::core::fmt::Formatter) ->" + " fn fmt(&self, f: &mut ::core::fmt::Formatter) ->" " ::core::fmt::Result {"; - code_ += " if let Some(name) = self.variant_name() {"; - code_ += " f.write_str(name)"; - code_ += " } else {"; - code_ += " f.write_fmt(format_args!(\"\", self.0))"; + code_ += " if let Some(name) = self.variant_name() {"; + code_ += " f.write_str(name)"; + code_ += " } else {"; + code_ += + " f.write_fmt(format_args!(\"\", self.0))"; + code_ += " }"; code_ += " }"; - code_ += " }"; code_ += "}"; code_ += ""; @@ -834,19 +837,20 @@ class RustGenerator : public BaseGenerator { if (parser_.opts.rust_serialize) { code_ += "impl Serialize for {{ENUM_TY}} {"; code_ += - " fn serialize(&self, serializer: S) -> Result"; - code_ += " where"; - code_ += " S: Serializer,"; - code_ += " {"; + " fn serialize(&self, serializer: S) -> Result"; + code_ += " where"; + code_ += " S: Serializer,"; + code_ += " {"; if (IsBitFlagsEnum(enum_def)) { - code_ += " serializer.serialize_u32(self.bits() as u32)"; + code_ += " serializer.serialize_u32(self.bits() as u32)"; } else { code_ += - " serializer.serialize_unit_variant(\"{{ENUM_TY}}\", self.0 " + " serializer.serialize_unit_variant(\"{{ENUM_TY}}\", self.0 " "as " "u32, self.variant_name().unwrap())"; } - code_ += " }"; + code_ += " }"; code_ += "}"; code_ += ""; @@ -859,7 +863,9 @@ class RustGenerator : public BaseGenerator { code_ += " {"; code_ += " let s = String::deserialize(deserializer)?;"; code_ += " for item in {{ENUM_TY}}::ENUM_VALUES {"; - code_ += " if let Some(item_name) = item.variant_name() {"; + code_ += + " if let Some(item_name) = " + "item.variant_name() {"; code_ += " if item_name == s {"; code_ += " return Ok(item.clone());"; code_ += " }"; @@ -876,19 +882,19 @@ class RustGenerator : public BaseGenerator { // Generate Follow and Push so we can serialize and stuff. code_ += "impl<'a> ::flatbuffers::Follow<'a> for {{ENUM_TY}} {"; - code_ += " type Inner = Self;"; + code_ += " type Inner = Self;"; code_ += ""; - code_ += " #[inline]"; - code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; + code_ += " #[inline]"; + code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; code_ += - " let b = unsafe { " + " let b = unsafe { " "::flatbuffers::read_scalar_at::<{{BASE_TYPE}}>(buf, loc) };"; if (IsBitFlagsEnum(enum_def)) { - code_ += " Self::from_bits_retain(b)"; + code_ += " Self::from_bits_retain(b)"; } else { - code_ += " Self(b)"; + code_ += " Self(b)"; } - code_ += " }"; + code_ += " }"; code_ += "}"; code_ += ""; code_ += "impl ::flatbuffers::Push for {{ENUM_TY}} {"; @@ -903,34 +909,34 @@ class RustGenerator : public BaseGenerator { code_ += "}"; code_ += ""; code_ += "impl ::flatbuffers::EndianScalar for {{ENUM_TY}} {"; - code_ += " type Scalar = {{BASE_TYPE}};"; + code_ += " type Scalar = {{BASE_TYPE}};"; code_ += ""; - code_ += " #[inline]"; - code_ += " fn to_little_endian(self) -> {{BASE_TYPE}} {"; - code_ += " {{INTO_BASE}}.to_le()"; - code_ += " }"; + code_ += " #[inline]"; + code_ += " fn to_little_endian(self) -> {{BASE_TYPE}} {"; + code_ += " {{INTO_BASE}}.to_le()"; + code_ += " }"; code_ += ""; - code_ += " #[inline]"; - code_ += " #[allow(clippy::wrong_self_convention)]"; - code_ += " fn from_little_endian(v: {{BASE_TYPE}}) -> Self {"; - code_ += " let b = {{BASE_TYPE}}::from_le(v);"; + code_ += " #[inline]"; + code_ += " #[allow(clippy::wrong_self_convention)]"; + code_ += " fn from_little_endian(v: {{BASE_TYPE}}) -> Self {"; + code_ += " let b = {{BASE_TYPE}}::from_le(v);"; if (IsBitFlagsEnum(enum_def)) { - code_ += " Self::from_bits_retain(b)"; + code_ += " Self::from_bits_retain(b)"; } else { - code_ += " Self(b)"; + code_ += " Self(b)"; } - code_ += " }"; + code_ += " }"; code_ += "}"; code_ += ""; // Generate verifier - deferring to the base type. code_ += "impl<'a> ::flatbuffers::Verifiable for {{ENUM_TY}} {"; - code_ += " #[inline]"; - code_ += " fn run_verifier("; - code_ += " v: &mut ::flatbuffers::Verifier, pos: usize"; - code_ += " ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {"; - code_ += " {{BASE_TYPE}}::run_verifier(v, pos)"; - code_ += " }"; + code_ += " #[inline]"; + code_ += " fn run_verifier("; + code_ += " v: &mut ::flatbuffers::Verifier, pos: usize"; + code_ += " ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {"; + code_ += " {{BASE_TYPE}}::run_verifier(v, pos)"; + code_ += " }"; code_ += "}"; code_ += ""; // Enums are basically integers. @@ -978,7 +984,7 @@ class RustGenerator : public BaseGenerator { code_ += "#[non_exhaustive]"; code_ += "#[derive(Debug, Clone, PartialEq)]"; code_ += "{{ACCESS_TYPE}} enum {{ENUM_OTY}} {"; - code_ += " NONE,"; + code_ += " NONE,"; ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { code_ += "{{NATIVE_VARIANT}}(alloc::boxed::Box<{{U_ELEMENT_TABLE_TYPE}}>),"; @@ -988,9 +994,9 @@ class RustGenerator : public BaseGenerator { // Generate Default (NONE). code_ += "impl Default for {{ENUM_OTY}} {"; - code_ += " fn default() -> Self {"; - code_ += " Self::NONE"; - code_ += " }"; + code_ += " fn default() -> Self {"; + code_ += " Self::NONE"; + code_ += " }"; code_ += "}"; code_ += ""; @@ -999,32 +1005,33 @@ class RustGenerator : public BaseGenerator { // Get flatbuffers union key. // TODO(cneo): add docstrings? - code_ += " pub fn {{ENUM_FN}}_type(&self) -> {{ENUM_TY}} {"; - code_ += " match self {"; - code_ += " Self::NONE => {{ENUM_TY}}::NONE,"; + code_ += " pub fn {{ENUM_FN}}_type(&self) -> {{ENUM_TY}} {"; + code_ += " match self {"; + code_ += " Self::NONE => {{ENUM_TY}}::NONE,"; ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { code_ += - " Self::{{NATIVE_VARIANT}}(_) => {{ENUM_TY}}::" + " Self::{{NATIVE_VARIANT}}(_) => {{ENUM_TY}}::" "{{VARIANT_NAME}},"; }); + code_ += " }"; code_ += " }"; - code_ += " }"; code_ += ""; // Pack flatbuffers union value code_ += - " pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut " + " pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: " + "&mut " "::flatbuffers::FlatBufferBuilder<'b, A>)" " -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>" " {"; - code_ += " match self {"; - code_ += " Self::NONE => None,"; + code_ += " match self {"; + code_ += " Self::NONE => None,"; ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { - code_ += " Self::{{NATIVE_VARIANT}}(v) => \\"; + code_ += " Self::{{NATIVE_VARIANT}}(v) => \\"; code_ += "Some(v.pack(fbb).as_union_value()),"; }); + code_ += " }"; code_ += " }"; - code_ += " }"; // Generate some accessors; ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { @@ -1036,16 +1043,16 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn take_{{U_ELEMENT_NAME}}(&mut self) -> " "Option> {"; - code_ += " if let Self::{{NATIVE_VARIANT}}(_) = self {"; - code_ += " let v = ::core::mem::replace(self, Self::NONE);"; - code_ += " if let Self::{{NATIVE_VARIANT}}(w) = v {"; - code_ += " Some(w)"; + code_ += " if let Self::{{NATIVE_VARIANT}}(_) = self {"; + code_ += " let v = ::core::mem::replace(self, Self::NONE);"; + code_ += " if let Self::{{NATIVE_VARIANT}}(w) = v {"; + code_ += " Some(w)"; + code_ += " } else {"; + code_ += " unreachable!()"; + code_ += " }"; code_ += " } else {"; - code_ += " unreachable!()"; + code_ += " None"; code_ += " }"; - code_ += " } else {"; - code_ += " None"; - code_ += " }"; code_ += "}"; // Immutable reference accessor. @@ -1057,7 +1064,7 @@ class RustGenerator : public BaseGenerator { "pub fn as_{{U_ELEMENT_NAME}}(&self) -> " "Option<&{{U_ELEMENT_TABLE_TYPE}}> {"; code_ += - " if let Self::{{NATIVE_VARIANT}}(v) = self " + " if let Self::{{NATIVE_VARIANT}}(v) = self " "{ Some(v.as_ref()) } else { None }"; code_ += "}"; @@ -1070,7 +1077,7 @@ class RustGenerator : public BaseGenerator { "pub fn as_{{U_ELEMENT_NAME}}_mut(&mut self) -> " "Option<&mut {{U_ELEMENT_TABLE_TYPE}}> {"; code_ += - " if let Self::{{NATIVE_VARIANT}}(v) = self " + " if let Self::{{NATIVE_VARIANT}}(v) = self " "{ Some(v.as_mut()) } else { None }"; code_ += "}"; }); @@ -1649,9 +1656,9 @@ class RustGenerator : public BaseGenerator { const std::string& name) { const std::string fully_qualified_name = struct_def.defined_namespace->GetFullyQualifiedName(name); - code_ += " pub const fn get_fully_qualified_name() -> &'static str {"; - code_ += " \"" + fully_qualified_name + "\""; - code_ += " }"; + code_ += " pub const fn get_fully_qualified_name() -> &'static str {"; + code_ += " \"" + fully_qualified_name + "\""; + code_ += " }"; code_ += ""; } @@ -1721,17 +1728,17 @@ class RustGenerator : public BaseGenerator { code_ += "#[derive(Copy, Clone, PartialEq)]"; code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}<'a> {"; - code_ += " pub _tab: ::flatbuffers::Table<'a>,"; + code_ += " pub _tab: ::flatbuffers::Table<'a>,"; code_ += "}"; code_ += ""; code_ += "impl<'a> ::flatbuffers::Follow<'a> for {{STRUCT_TY}}<'a> {"; - code_ += " type Inner = {{STRUCT_TY}}<'a>;"; + code_ += " type Inner = {{STRUCT_TY}}<'a>;"; code_ += ""; - code_ += " #[inline]"; - code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; + code_ += " #[inline]"; + code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; code_ += - " Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }"; - code_ += " }"; + " Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }"; + code_ += " }"; code_ += "}"; code_ += ""; code_ += "impl<'a> {{STRUCT_TY}}<'a> {"; @@ -1750,12 +1757,12 @@ class RustGenerator : public BaseGenerator { GenFullyQualifiedNameGetter(struct_def, struct_def.name); } - code_ += " #[inline]"; + code_ += " #[inline]"; code_ += - " pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> " + " pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> " "Self {"; - code_ += " {{STRUCT_TY}} { _tab: table }"; - code_ += " }"; + code_ += " {{STRUCT_TY}} { _tab: table }"; + code_ += " }"; code_ += ""; // Generate a convenient create* function that uses the above builder @@ -1763,16 +1770,17 @@ class RustGenerator : public BaseGenerator { code_.SetValue("MAYBE_US", struct_def.fields.vec.size() == 0 ? "_" : ""); code_.SetValue("MAYBE_LT", TableBuilderArgsNeedsLifetime(struct_def) ? "<'args>" : ""); - code_ += " #[allow(unused_mut)]"; + code_ += " #[allow(unused_mut)]"; code_ += - " pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: " + " pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: " "::flatbuffers::Allocator + 'bldr>("; code_ += - " _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,"; - code_ += " {{MAYBE_US}}args: &'args {{STRUCT_TY}}Args{{MAYBE_LT}}"; - code_ += " ) -> ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'bldr>> {"; + " _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, " + "A>,"; + code_ += " {{MAYBE_US}}args: &'args {{STRUCT_TY}}Args{{MAYBE_LT}}"; + code_ += " ) -> ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'bldr>> {"; - code_ += " let mut builder = {{STRUCT_TY}}Builder::new(_fbb);"; + code_ += " let mut builder = {{STRUCT_TY}}Builder::new(_fbb);"; for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; size; size /= 2) { ForAllTableFields( @@ -1783,16 +1791,16 @@ class RustGenerator : public BaseGenerator { return; if (IsOptionalToBuilder(field)) { code_ += - " if let Some(x) = args.{{FIELD}} " + " if let Some(x) = args.{{FIELD}} " "{ builder.add_{{FIELD}}(x); }"; } else { - code_ += " builder.add_{{FIELD}}(args.{{FIELD}});"; + code_ += " builder.add_{{FIELD}}(args.{{FIELD}});"; } }, /*reverse=*/true); } - code_ += " builder.finish()"; - code_ += " }"; + code_ += " builder.finish()"; + code_ += " }"; code_ += ""; // Generate Object API Packer function. @@ -1800,7 +1808,7 @@ class RustGenerator : public BaseGenerator { // TODO(cneo): Replace more for loops with ForAllX stuff. // TODO(cneo): Manage indentation with IncrementIdentLevel? code_.SetValue("STRUCT_OTY", namer_.ObjectType(struct_def)); - code_ += " pub fn unpack(&self) -> {{STRUCT_OTY}} {"; + code_ += " pub fn unpack(&self) -> {{STRUCT_OTY}} {"; ForAllObjectTableFields(struct_def, [&](const FieldDef& field) { const Type& type = field.value.type; switch (GetFullType(type)) { @@ -1808,7 +1816,7 @@ class RustGenerator : public BaseGenerator { case ftBool: case ftFloat: case ftEnumKey: { - code_ += " let {{FIELD}} = self.{{FIELD}}();"; + code_ += " let {{FIELD}} = self.{{FIELD}}();"; return; } case ftUnionKey: @@ -1820,23 +1828,23 @@ class RustGenerator : public BaseGenerator { code_.SetValue("UNION_TYPE_METHOD", namer_.LegacyRustUnionTypeMethod(field)); - code_ += " let {{FIELD}} = match self.{{UNION_TYPE_METHOD}}() {"; - code_ += " {{ENUM_TY}}::NONE => {{NATIVE_ENUM_NAME}}::NONE,"; + code_ += " let {{FIELD}} = match self.{{UNION_TYPE_METHOD}}() {"; + code_ += " {{ENUM_TY}}::NONE => {{NATIVE_ENUM_NAME}}::NONE,"; ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { code_ += - " {{ENUM_TY}}::{{VARIANT_NAME}} => " + " {{ENUM_TY}}::{{VARIANT_NAME}} => " "{{NATIVE_ENUM_NAME}}::{{NATIVE_VARIANT}}(alloc::boxed::Box::" "new("; - code_ += " self.{{FIELD}}_as_{{U_ELEMENT_NAME}}()"; + code_ += " self.{{FIELD}}_as_{{U_ELEMENT_NAME}}()"; code_ += - " .expect(\"Invalid union table, " + " .expect(\"Invalid union table, " "expected `{{ENUM_TY}}::{{VARIANT_NAME}}`.\")"; - code_ += " .unpack()"; - code_ += " )),"; + code_ += " .unpack()"; + code_ += " )),"; }); // Maybe we shouldn't throw away unknown discriminants? - code_ += " _ => {{NATIVE_ENUM_NAME}}::NONE,"; - code_ += " };"; + code_ += " _ => {{NATIVE_ENUM_NAME}}::NONE,"; + code_ += " };"; return; } // The rest of the types need special handling based on if the field @@ -1884,24 +1892,24 @@ class RustGenerator : public BaseGenerator { } } if (field.IsOptional()) { - code_ += " let {{FIELD}} = self.{{FIELD}}().map(|x| {"; - code_ += " {{EXPR}}"; - code_ += " });"; + code_ += " let {{FIELD}} = self.{{FIELD}}().map(|x| {"; + code_ += " {{EXPR}}"; + code_ += " });"; } else { - code_ += " let {{FIELD}} = {"; - code_ += " let x = self.{{FIELD}}();"; - code_ += " {{EXPR}}"; - code_ += " };"; + code_ += " let {{FIELD}} = {"; + code_ += " let x = self.{{FIELD}}();"; + code_ += " {{EXPR}}"; + code_ += " };"; } }); - code_ += " {{STRUCT_OTY}} {"; + code_ += " {{STRUCT_OTY}} {"; ForAllObjectTableFields(struct_def, [&](const FieldDef& field) { if (field.value.type.base_type == BASE_TYPE_UTYPE) return; - code_ += " {{FIELD}},"; + code_ += " {{FIELD}},"; }); + code_ += " }"; code_ += " }"; - code_ += " }"; } // Generate the accessors. Each has one of two forms: @@ -1923,10 +1931,10 @@ class RustGenerator : public BaseGenerator { this->GenComment(field.doc_comment); code_ += "#[inline]"; code_ += "pub fn {{FIELD}}(&self) -> {{RETURN_TYPE}} {"; - code_ += " // Safety:"; - code_ += " // Created from valid Table for this object"; - code_ += " // which contains a valid value in this slot"; - code_ += " " + GenTableAccessorFuncBody(field, "'a"); + code_ += " // Safety:"; + code_ += " // Created from valid Table for this object"; + code_ += " // which contains a valid value in this slot"; + code_ += " " + GenTableAccessorFuncBody(field, "'a"); code_ += "}"; // Generate a comparison function for this field if it is a key. @@ -1951,17 +1959,7 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn {{FIELD}}_nested_flatbuffer(&'a self) -> \\"; if (field.IsRequired()) { code_ += "{{NESTED}}<'a> {"; - code_ += " let data = self.{{FIELD}}();"; - code_ += " use ::flatbuffers::Follow;"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid flatbuffer in this slot"; - code_ += - " unsafe { <::flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>" - "::follow(data.bytes(), 0) }"; - } else { - code_ += "Option<{{NESTED}}<'a>> {"; - code_ += " self.{{FIELD}}().map(|data| {"; + code_ += " let data = self.{{FIELD}}();"; code_ += " use ::flatbuffers::Follow;"; code_ += " // Safety:"; code_ += " // Created from a valid Table for this object"; @@ -1969,7 +1967,18 @@ class RustGenerator : public BaseGenerator { code_ += " unsafe { <::flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>" "::follow(data.bytes(), 0) }"; - code_ += " })"; + } else { + code_ += "Option<{{NESTED}}<'a>> {"; + code_ += " self.{{FIELD}}().map(|data| {"; + code_ += " use ::flatbuffers::Follow;"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid flatbuffer in this slot"; + code_ += + " unsafe { " + "<::flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>" + "::follow(data.bytes(), 0) }"; + code_ += " })"; } code_ += "}"; } @@ -1999,31 +2008,34 @@ class RustGenerator : public BaseGenerator { // // To avoid this problem the type field name is used unescaped here: code_ += - " if self.{{DISCRIMINANT}}() == {{U_ELEMENT_ENUM_TYPE}} {"; + " if self.{{DISCRIMINANT}}() == {{U_ELEMENT_ENUM_TYPE}} {"; // The following logic is not tested in the integration test, // as of April 10, 2020 if (field.IsRequired()) { - code_ += " let u = self.{{FIELD}}();"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid union in this slot"; + code_ += " let u = self.{{FIELD}}();"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid union in this slot"; code_ += " Some(unsafe { " "{{U_ELEMENT_TABLE_TYPE}}::init_from_table(u) })"; } else { - code_ += " self.{{FIELD}}().map(|t| {"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid union in this slot"; + code_ += " self.{{FIELD}}().map(|t| {"; + code_ += " // Safety:"; code_ += - " unsafe { {{U_ELEMENT_TABLE_TYPE}}::init_from_table(t) " + " // Created from a valid Table for this object"; + code_ += + " // Which contains a valid union in this slot"; + code_ += + " unsafe { " + "{{U_ELEMENT_TABLE_TYPE}}::init_from_table(t) " "}"; - code_ += " })"; + code_ += " })"; } - code_ += " } else {"; - code_ += " None"; - code_ += " }"; + code_ += " } else {"; + code_ += " None"; + code_ += " }"; code_ += "}"; }); }); @@ -2032,11 +2044,11 @@ class RustGenerator : public BaseGenerator { // Generate Verifier; code_ += "impl ::flatbuffers::Verifiable for {{STRUCT_TY}}<'_> {"; - code_ += " #[inline]"; - code_ += " fn run_verifier("; - code_ += " v: &mut ::flatbuffers::Verifier, pos: usize"; - code_ += " ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {"; - code_ += " v.visit_table(pos)?\\"; + code_ += " #[inline]"; + code_ += " fn run_verifier("; + code_ += " v: &mut ::flatbuffers::Verifier, pos: usize"; + code_ += " ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {"; + code_ += " v.visit_table(pos)?"; // Escape newline and insert it onthe next line so we can end the builder // with a nice semicolon. ForAllTableFields(struct_def, [&](const FieldDef& field) { @@ -2047,8 +2059,8 @@ class RustGenerator : public BaseGenerator { // All types besides unions. code_.SetValue("TY", FollowType(field.value.type, "'_")); code_ += - "\n .visit_field::<{{TY}}>(\"{{FIELD}}\", " - "Self::{{OFFSET_NAME}}, {{IS_REQ}})?\\"; + " .visit_field::<{{TY}}>(\"{{FIELD}}\", " + "Self::{{OFFSET_NAME}}, {{IS_REQ}})?"; return; } // Unions. @@ -2059,25 +2071,26 @@ class RustGenerator : public BaseGenerator { code_.SetValue("UNION_TYPE_METHOD", namer_.LegacyRustUnionTypeMethod(field)); code_ += - "\n .visit_union::<{{UNION_TYPE}}, _>(" + " .visit_union::<{{UNION_TYPE}}, _>(" "\"{{UNION_TYPE_METHOD}}\", Self::{{UNION_TYPE_OFFSET_NAME}}, " "\"{{FIELD}}\", Self::{{OFFSET_NAME}}, {{IS_REQ}}, " "|key, v, pos| {"; - code_ += " match key {"; + code_ += " match key {"; ForAllUnionVariantsBesidesNone(union_def, [&](const EnumVal& unused) { (void)unused; code_ += - " {{U_ELEMENT_ENUM_TYPE}} => v.verify_union_variant::" + " {{U_ELEMENT_ENUM_TYPE}} => " + "v.verify_union_variant::" "<::flatbuffers::ForwardsUOffset<{{U_ELEMENT_TABLE_TYPE}}>>(" "\"{{U_ELEMENT_ENUM_TYPE}}\", pos),"; }); - code_ += " _ => Ok(()),"; - code_ += " }"; - code_ += " })?\\"; + code_ += " _ => Ok(()),"; + code_ += " }"; + code_ += " })?"; }); - code_ += "\n .finish();"; - code_ += " Ok(())"; - code_ += " }"; + code_ += " .finish();"; + code_ += " Ok(())"; + code_ += " }"; code_ += "}"; code_ += ""; @@ -2087,22 +2100,22 @@ class RustGenerator : public BaseGenerator { code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}Args{{MAYBE_LT}} {"; ForAllTableFields(struct_def, [&](const FieldDef& field) { code_.SetValue("PARAM_TYPE", TableBuilderArgsDefnType(field, "'a")); - code_ += " pub {{FIELD}}: {{PARAM_TYPE}},"; + code_ += "pub {{FIELD}}: {{PARAM_TYPE}},"; }); code_ += "}"; code_ += ""; // Generate an impl of Default for the *Args type: code_ += "impl<'a> Default for {{STRUCT_TY}}Args{{MAYBE_LT}} {"; - code_ += " #[inline]"; - code_ += " fn default() -> Self {"; - code_ += " {{STRUCT_TY}}Args {"; + code_ += " #[inline]"; + code_ += " fn default() -> Self {"; + code_ += " {{STRUCT_TY}}Args {"; ForAllTableFields(struct_def, [&](const FieldDef& field) { - code_ += " {{FIELD}}: {{BLDR_DEF_VAL}},\\"; + code_ += " {{FIELD}}: {{BLDR_DEF_VAL}},\\"; code_ += field.IsRequired() ? " // required field" : ""; }); + code_ += " }"; code_ += " }"; - code_ += " }"; code_ += "}"; code_ += ""; @@ -2112,17 +2125,19 @@ class RustGenerator : public BaseGenerator { code_.SetValue("NUM_FIELDS", NumToString(numFields)); code_ += "impl Serialize for {{STRUCT_TY}}<'_> {"; code_ += - " fn serialize(&self, serializer: S) -> Result"; - code_ += " where"; - code_ += " S: Serializer,"; - code_ += " {"; + " fn serialize(&self, serializer: S) -> Result"; + code_ += " where"; + code_ += " S: Serializer,"; + code_ += " {"; if (numFields == 0) { code_ += - " let s = serializer.serialize_struct(\"{{STRUCT_TY}}\", 0)?;"; + " let s = serializer.serialize_struct(\"{{STRUCT_TY}}\", " + "0)?;"; } else { code_ += - " let mut s = serializer.serialize_struct(\"{{STRUCT_TY}}\", " - "{{NUM_FIELDS}})?;"; + " let mut s = " + "serializer.serialize_struct(\"{{STRUCT_TY}}\", {{NUM_FIELDS}})?;"; } ForAllTableFields(struct_def, [&](const FieldDef& field) { const Type& type = field.value.type; @@ -2135,20 +2150,20 @@ class RustGenerator : public BaseGenerator { namer_.LegacyRustUnionTypeMethod(field)); code_ += " match self.{{UNION_TYPE_METHOD}}() {"; - code_ += " {{ENUM_TY}}::NONE => (),"; + code_ += " {{ENUM_TY}}::NONE => (),"; ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { code_.SetValue("FIELD", namer_.Field(field)); - code_ += " {{ENUM_TY}}::{{VARIANT_NAME}} => {"; + code_ += " {{ENUM_TY}}::{{VARIANT_NAME}} => {"; code_ += - " let f = " + " let f = " "self.{{FIELD}}_as_{{U_ELEMENT_NAME}}()"; code_ += - " .expect(\"Invalid union table, expected " + " .expect(\"Invalid union table, expected " "`{{ENUM_TY}}::{{VARIANT_NAME}}`.\");"; - code_ += " s.serialize_field(\"{{FIELD}}\", &f)?;"; - code_ += " }"; + code_ += " s.serialize_field(\"{{FIELD}}\", &f)?;"; + code_ += " }"; }); - code_ += " _ => unimplemented!(),"; + code_ += " _ => unimplemented!(),"; code_ += " }"; } else { code_ += @@ -2158,9 +2173,9 @@ class RustGenerator : public BaseGenerator { } else { if (field.IsOptional()) { code_ += " if let Some(f) = self.{{FIELD}}() {"; - code_ += " s.serialize_field(\"{{FIELD}}\", &f)?;"; + code_ += " s.serialize_field(\"{{FIELD}}\", &f)?;"; code_ += " } else {"; - code_ += " s.skip_field(\"{{FIELD}}\")?;"; + code_ += " s.skip_field(\"{{FIELD}}\")?;"; code_ += " }"; } else { code_ += @@ -2169,8 +2184,8 @@ class RustGenerator : public BaseGenerator { } } }); - code_ += " s.end()"; - code_ += " }"; + code_ += " s.end()"; + code_ += " }"; code_ += "}"; code_ += ""; } @@ -2179,9 +2194,9 @@ class RustGenerator : public BaseGenerator { code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}Builder<'a: 'b, 'b, A: " "::flatbuffers::Allocator + 'a> {"; - code_ += " fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,"; + code_ += " fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,"; code_ += - " start_: ::flatbuffers::WIPOffset<" + " start_: ::flatbuffers::WIPOffset<" "::flatbuffers::TableUnfinishedWIPOffset>,"; code_ += "}"; code_ += ""; @@ -2214,53 +2229,53 @@ class RustGenerator : public BaseGenerator { "{{FIELD_TYPE}}) {"; if (is_scalar && !field.IsOptional()) { code_ += - " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD}}, " + " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD}}, " "{{BLDR_DEF_VAL}});"; } else { - code_ += " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD}});"; + code_ += " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD}});"; } code_ += "}"; code_ += ""; }); // Struct initializer (all fields required); - code_ += " #[inline]"; + code_ += " #[inline]"; code_ += - " pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) " + " pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) " "-> " "{{STRUCT_TY}}Builder<'a, 'b, A> {"; code_.SetValue("NUM_FIELDS", NumToString(struct_def.fields.vec.size())); - code_ += " let start = _fbb.start_table();"; - code_ += " {{STRUCT_TY}}Builder {"; - code_ += " fbb_: _fbb,"; - code_ += " start_: start,"; + code_ += " let start = _fbb.start_table();"; + code_ += " {{STRUCT_TY}}Builder {"; + code_ += " fbb_: _fbb,"; + code_ += " start_: start,"; + code_ += " }"; code_ += " }"; - code_ += " }"; code_ += ""; // finish() function. - code_ += " #[inline]"; + code_ += " #[inline]"; code_ += - " pub fn finish(self) -> " + " pub fn finish(self) -> " "::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>> {"; - code_ += " let o = self.fbb_.end_table(self.start_);"; + code_ += " let o = self.fbb_.end_table(self.start_);"; ForAllTableFields(struct_def, [&](const FieldDef& field) { if (!field.IsRequired()) return; code_ += - " self.fbb_.required(o, {{STRUCT_TY}}::{{OFFSET_NAME}}," + " self.fbb_.required(o, {{STRUCT_TY}}::{{OFFSET_NAME}}," "\"{{FIELD}}\");"; }); - code_ += " ::flatbuffers::WIPOffset::new(o.value())"; - code_ += " }"; + code_ += " ::flatbuffers::WIPOffset::new(o.value())"; + code_ += " }"; code_ += "}"; code_ += ""; code_ += "impl ::core::fmt::Debug for {{STRUCT_TY}}<'_> {"; code_ += - " fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>" + " fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>" ") -> ::core::fmt::Result {"; - code_ += " let mut ds = f.debug_struct(\"{{STRUCT_TY}}\");"; + code_ += " let mut ds = f.debug_struct(\"{{STRUCT_TY}}\");"; ForAllTableFields(struct_def, [&](const FieldDef& field) { if (GetFullType(field.value.type) == ftUnionValue) { // Generate a match statement to handle unions properly. @@ -2273,29 +2288,29 @@ class RustGenerator : public BaseGenerator { ForAllUnionVariantsBesidesNone( *field.value.type.enum_def, [&](const EnumVal& unused) { (void)unused; - code_ += " {{U_ELEMENT_ENUM_TYPE}} => {"; + code_ += " {{U_ELEMENT_ENUM_TYPE}} => {"; code_ += - " if let Some(x) = " + " if let Some(x) = " "self.{{FIELD}}_as_" "{{U_ELEMENT_NAME}}() {"; - code_ += " ds.field(\"{{FIELD}}\", &x)"; - code_ += " } else {"; - code_ += " ds.field(\"{{FIELD}}\", {{UNION_ERR}})"; - code_ += " }"; - code_ += " },"; + code_ += " ds.field(\"{{FIELD}}\", &x)"; + code_ += " } else {"; + code_ += " ds.field(\"{{FIELD}}\", {{UNION_ERR}})"; + code_ += " }"; + code_ += " },"; }); - code_ += " _ => {"; - code_ += " let x: Option<()> = None;"; - code_ += " ds.field(\"{{FIELD}}\", &x)"; - code_ += " },"; + code_ += " _ => {"; + code_ += " let x: Option<()> = None;"; + code_ += " ds.field(\"{{FIELD}}\", &x)"; + code_ += " },"; code_ += " };"; } else { // Most fields. code_ += " ds.field(\"{{FIELD}}\", &self.{{FIELD}}());"; } }); - code_ += " ds.finish()"; - code_ += " }"; + code_ += " ds.finish()"; + code_ += " }"; code_ += "}"; } @@ -2319,15 +2334,15 @@ class RustGenerator : public BaseGenerator { code_ += ""; code_ += "impl Default for {{STRUCT_OTY}} {"; - code_ += " fn default() -> Self {"; - code_ += " Self {"; + code_ += " fn default() -> Self {"; + code_ += " Self {"; ForAllObjectTableFields(table, [&](const FieldDef& field) { if (field.value.type.base_type == BASE_TYPE_UTYPE) return; std::string default_value = GetDefaultValue(field, kObject); - code_ += " {{FIELD}}: " + default_value + ","; + code_ += " {{FIELD}}: " + default_value + ","; }); + code_ += " }"; code_ += " }"; - code_ += " }"; code_ += "}"; code_ += ""; @@ -2336,10 +2351,10 @@ class RustGenerator : public BaseGenerator { // Generate pack function. code_ += "impl {{STRUCT_OTY}} {"; - code_ += " pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>("; - code_ += " &self,"; - code_ += " _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>"; - code_ += " ) -> ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'b>> {"; + code_ += " pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>("; + code_ += " &self,"; + code_ += " _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>"; + code_ += " ) -> ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'b>> {"; // First we generate variables for each field and then later assemble them // using "StructArgs" to more easily manage ownership of the builder. ForAllObjectTableFields(table, [&](const FieldDef& field) { @@ -2349,7 +2364,7 @@ class RustGenerator : public BaseGenerator { case ftBool: case ftFloat: case ftEnumKey: { - code_ += " let {{FIELD}} = self.{{FIELD}};"; + code_ += " let {{FIELD}} = self.{{FIELD}};"; return; } case ftUnionKey: @@ -2360,9 +2375,9 @@ class RustGenerator : public BaseGenerator { code_.SetValue("DISCRIMINANT", namer_.LegacyRustUnionTypeMethod(field)); code_ += - " let {{DISCRIMINANT}} = " + " let {{DISCRIMINANT}} = " "self.{{FIELD}}.{{ENUM_METHOD}}_type();"; - code_ += " let {{FIELD}} = self.{{FIELD}}.pack(_fbb);"; + code_ += " let {{FIELD}} = self.{{FIELD}}.pack(_fbb);"; return; } // The rest of the types require special casing around optionalness @@ -2374,13 +2389,13 @@ class RustGenerator : public BaseGenerator { case ftStruct: { // Hold the struct in a variable so we can reference it. if (field.IsRequired()) { - code_ += " let {{FIELD}}_tmp = Some(self.{{FIELD}}.pack());"; + code_ += " let {{FIELD}}_tmp = Some(self.{{FIELD}}.pack());"; } else { code_ += - " let {{FIELD}}_tmp = self.{{FIELD}}" + " let {{FIELD}}_tmp = self.{{FIELD}}" ".as_ref().map(|x| x.pack());"; } - code_ += " let {{FIELD}} = {{FIELD}}_tmp.as_ref();"; + code_ += " let {{FIELD}} = {{FIELD}}_tmp.as_ref();"; return; } @@ -2431,13 +2446,13 @@ class RustGenerator : public BaseGenerator { } } }); - code_ += " {{STRUCT_TY}}::create(_fbb, &{{STRUCT_TY}}Args{"; + code_ += " {{STRUCT_TY}}::create(_fbb, &{{STRUCT_TY}}Args{"; ForAllObjectTableFields(table, [&](const FieldDef& field) { (void)field; // Unused. - code_ += " {{FIELD}},"; + code_ += " {{FIELD}},"; }); - code_ += " })"; - code_ += " }"; + code_ += " })"; + code_ += " }"; code_ += "}"; } void ForAllObjectTableFields(const StructDef& table, @@ -2455,16 +2470,16 @@ class RustGenerator : public BaseGenerator { } void MapNativeTableField(const FieldDef& field, const std::string& expr) { if (field.IsOptional()) { - code_ += " let {{FIELD}} = self.{{FIELD}}.as_ref().map(|x|{"; - code_ += " " + expr; - code_ += " });"; + code_ += " let {{FIELD}} = self.{{FIELD}}.as_ref().map(|x|{"; + code_ += " " + expr; + code_ += " });"; } else { // For some reason Args has optional types for required fields. // TODO(cneo): Fix this... but its a breaking change? - code_ += " let {{FIELD}} = Some({"; - code_ += " let x = &self.{{FIELD}};"; - code_ += " " + expr; - code_ += " });"; + code_ += " let {{FIELD}} = Some({"; + code_ += " let x = &self.{{FIELD}};"; + code_ += " " + expr; + code_ += " });"; } } @@ -2482,7 +2497,7 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn key_compare_less_than(&self, o: &{{STRUCT_TY}}) -> " "bool {"; - code_ += " self.{{FIELD}}() < o.{{FIELD}}()"; + code_ += " self.{{FIELD}}() < o.{{FIELD}}()"; code_ += "}"; code_ += ""; @@ -2490,8 +2505,8 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn key_compare_with_value(&self, val: {{KEY_TYPE}}) -> " "::core::cmp::Ordering {"; - code_ += " let key = self.{{FIELD}}();"; - code_ += " key.cmp({{REF}}val)"; + code_ += " let key = self.{{FIELD}}();"; + code_ += " key.cmp({{REF}}val)"; code_ += "}"; } @@ -2516,7 +2531,7 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn root_as_{{STRUCT_FN}}(buf: &[u8]) " "-> Result<{{STRUCT_TY}}<'_>, ::flatbuffers::InvalidFlatbuffer> {"; - code_ += " ::flatbuffers::root::<{{STRUCT_TY}}>(buf)"; + code_ += " ::flatbuffers::root::<{{STRUCT_TY}}>(buf)"; code_ += "}"; code_ += ""; @@ -2531,7 +2546,7 @@ class RustGenerator : public BaseGenerator { "pub fn size_prefixed_root_as_{{STRUCT_FN}}" "(buf: &[u8]) -> Result<{{STRUCT_TY}}<'_>, " "::flatbuffers::InvalidFlatbuffer> {"; - code_ += " ::flatbuffers::size_prefixed_root::<{{STRUCT_TY}}>(buf)"; + code_ += " ::flatbuffers::size_prefixed_root::<{{STRUCT_TY}}>(buf)"; code_ += "}"; code_ += ""; @@ -2544,12 +2559,13 @@ class RustGenerator : public BaseGenerator { code_ += "/// `root_as_{{STRUCT_FN}}_unchecked`."; code_ += "#[inline]"; code_ += "pub fn root_as_{{STRUCT_FN}}_with_opts<'b, 'o>("; - code_ += " opts: &'o ::flatbuffers::VerifierOptions,"; - code_ += " buf: &'b [u8],"; + code_ += " opts: &'o ::flatbuffers::VerifierOptions,"; + code_ += " buf: &'b [u8],"; code_ += ") -> Result<{{STRUCT_TY}}<'b>, ::flatbuffers::InvalidFlatbuffer>" " {"; - code_ += " ::flatbuffers::root_with_opts::<{{STRUCT_TY}}<'b>>(opts, buf)"; + code_ += + " ::flatbuffers::root_with_opts::<{{STRUCT_TY}}<'b>>(opts, buf)"; code_ += "}"; code_ += ""; @@ -2563,13 +2579,13 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn size_prefixed_root_as_{{STRUCT_FN}}_with_opts" "<'b, 'o>("; - code_ += " opts: &'o ::flatbuffers::VerifierOptions,"; - code_ += " buf: &'b [u8],"; + code_ += " opts: &'o ::flatbuffers::VerifierOptions,"; + code_ += " buf: &'b [u8],"; code_ += ") -> Result<{{STRUCT_TY}}<'b>, ::flatbuffers::InvalidFlatbuffer>" " {"; code_ += - " ::flatbuffers::size_prefixed_root_with_opts::<{{STRUCT_TY}}" + " ::flatbuffers::size_prefixed_root_with_opts::<{{STRUCT_TY}}" "<'b>>(opts, buf)"; code_ += "}"; code_ += ""; @@ -2586,7 +2602,8 @@ class RustGenerator : public BaseGenerator { code_ += "pub unsafe fn root_as_{{STRUCT_FN}}_unchecked" "(buf: &[u8]) -> {{STRUCT_TY}}<'_> {"; - code_ += " unsafe { ::flatbuffers::root_unchecked::<{{STRUCT_TY}}>(buf) }"; + code_ += + " unsafe { ::flatbuffers::root_unchecked::<{{STRUCT_TY}}>(buf) }"; code_ += "}"; code_ += ""; @@ -2602,7 +2619,7 @@ class RustGenerator : public BaseGenerator { "pub unsafe fn size_prefixed_root_as_{{STRUCT_FN}}" "_unchecked(buf: &[u8]) -> {{STRUCT_TY}}<'_> {"; code_ += - " unsafe { " + " unsafe { " "::flatbuffers::size_prefixed_root_unchecked::<{{STRUCT_TY}}>" "(buf) }"; code_ += "}"; @@ -2619,14 +2636,14 @@ class RustGenerator : public BaseGenerator { code_ += "#[inline]"; code_ += "pub fn {{STRUCT_FN}}_buffer_has_identifier\\"; code_ += "(buf: &[u8]) -> bool {"; - code_ += " ::flatbuffers::buffer_has_identifier(buf, \\"; + code_ += " ::flatbuffers::buffer_has_identifier(buf, \\"; code_ += "{{STRUCT_CONST}}_IDENTIFIER, false)"; code_ += "}"; code_ += ""; code_ += "#[inline]"; code_ += "pub fn {{STRUCT_FN}}_size_prefixed\\"; code_ += "_buffer_has_identifier(buf: &[u8]) -> bool {"; - code_ += " ::flatbuffers::buffer_has_identifier(buf, \\"; + code_ += " ::flatbuffers::buffer_has_identifier(buf, \\"; code_ += "{{STRUCT_CONST}}_IDENTIFIER, true)"; code_ += "}"; code_ += ""; @@ -2645,26 +2662,28 @@ class RustGenerator : public BaseGenerator { "pub fn finish_{{STRUCT_FN}}_buffer<'a, 'b, A: " "::flatbuffers::Allocator + 'a>("; code_ += " fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,"; - code_ += " root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {"; + code_ += " root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>"; + code_ += ") {"; if (parser_.file_identifier_.length()) { - code_ += " fbb.finish(root, Some({{STRUCT_CONST}}_IDENTIFIER));"; + code_ += " fbb.finish(root, Some({{STRUCT_CONST}}_IDENTIFIER));"; } else { - code_ += " fbb.finish(root, None);"; + code_ += " fbb.finish(root, None);"; } code_ += "}"; code_ += ""; code_ += "#[inline]"; code_ += "pub fn finish_size_prefixed_{{STRUCT_FN}}_buffer" - "<'a, 'b, A: ::flatbuffers::Allocator + 'a>(" - "fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, " - "root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {"; + "<'a, 'b, A: ::flatbuffers::Allocator + 'a>("; + code_ += " fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,"; + code_ += " root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>"; + code_ += ") {"; if (parser_.file_identifier_.length()) { code_ += - " fbb.finish_size_prefixed(root, " + " fbb.finish_size_prefixed(root, " "Some({{STRUCT_CONST}}_IDENTIFIER));"; } else { - code_ += " fbb.finish_size_prefixed(root, None);"; + code_ += " fbb.finish_size_prefixed(root, None);"; } code_ += "}"; } @@ -2740,25 +2759,25 @@ class RustGenerator : public BaseGenerator { code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}(pub [u8; {{STRUCT_SIZE}}]);"; code_ += ""; - code_ += "impl Default for {{STRUCT_TY}} { "; - code_ += " fn default() -> Self { "; - code_ += " Self([0; {{STRUCT_SIZE}}])"; - code_ += " }"; + code_ += "impl Default for {{STRUCT_TY}} {"; + code_ += " fn default() -> Self {"; + code_ += " Self([0; {{STRUCT_SIZE}}])"; + code_ += " }"; code_ += "}"; code_ += ""; // Debug for structs. code_ += "impl ::core::fmt::Debug for {{STRUCT_TY}} {"; code_ += - " fn fmt(&self, f: &mut ::core::fmt::Formatter" + " fn fmt(&self, f: &mut ::core::fmt::Formatter" ") -> ::core::fmt::Result {"; - code_ += " f.debug_struct(\"{{STRUCT_TY}}\")"; + code_ += " f.debug_struct(\"{{STRUCT_TY}}\")"; ForAllStructFields(struct_def, [&](const FieldDef& unused) { (void)unused; - code_ += " .field(\"{{FIELD}}\", &self.{{FIELD}}())"; + code_ += " .field(\"{{FIELD}}\", &self.{{FIELD}}())"; }); - code_ += " .finish()"; - code_ += " }"; + code_ += " .finish()"; + code_ += " }"; code_ += "}"; code_ += ""; @@ -2769,24 +2788,24 @@ class RustGenerator : public BaseGenerator { code_ += ""; code_ += "impl<'a> ::flatbuffers::Follow<'a> for {{STRUCT_TY}} {"; - code_ += " type Inner = &'a {{STRUCT_TY}};"; + code_ += " type Inner = &'a {{STRUCT_TY}};"; code_ += ""; - code_ += " #[inline]"; - code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; - code_ += " unsafe { <&'a {{STRUCT_TY}}>::follow(buf, loc) }"; - code_ += " }"; + code_ += " #[inline]"; + code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; + code_ += " unsafe { <&'a {{STRUCT_TY}}>::follow(buf, loc) }"; + code_ += " }"; code_ += "}"; code_ += ""; code_ += "impl<'a> ::flatbuffers::Follow<'a> for &'a {{STRUCT_TY}} {"; - code_ += " type Inner = &'a {{STRUCT_TY}};"; + code_ += " type Inner = &'a {{STRUCT_TY}};"; code_ += ""; - code_ += " #[inline]"; - code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; + code_ += " #[inline]"; + code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; code_ += - " unsafe { ::flatbuffers::follow_cast_ref::<{{STRUCT_TY}}>(buf, " + " unsafe { ::flatbuffers::follow_cast_ref::<{{STRUCT_TY}}>(buf, " "loc) }"; - code_ += " }"; + code_ += " }"; code_ += "}"; code_ += ""; @@ -2813,12 +2832,12 @@ class RustGenerator : public BaseGenerator { // Generate verifier: Structs are simple so presence and alignment are // all that need to be checked. code_ += "impl<'a> ::flatbuffers::Verifiable for {{STRUCT_TY}} {"; - code_ += " #[inline]"; - code_ += " fn run_verifier("; - code_ += " v: &mut ::flatbuffers::Verifier, pos: usize"; - code_ += " ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {"; - code_ += " v.in_buffer::(pos)"; - code_ += " }"; + code_ += " #[inline]"; + code_ += " fn run_verifier("; + code_ += " v: &mut ::flatbuffers::Verifier, pos: usize"; + code_ += " ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {"; + code_ += " v.in_buffer::(pos)"; + code_ += " }"; code_ += "}"; code_ += ""; @@ -2828,10 +2847,11 @@ class RustGenerator : public BaseGenerator { code_.SetValue("NUM_FIELDS", NumToString(numFields)); code_ += "impl Serialize for {{STRUCT_TY}} {"; code_ += - " fn serialize(&self, serializer: S) -> Result"; - code_ += " where"; - code_ += " S: Serializer,"; - code_ += " {"; + " fn serialize(&self, serializer: S) -> Result"; + code_ += " where"; + code_ += " S: Serializer,"; + code_ += " {"; if (numFields == 0) { code_ += " let s = serializer.serialize_struct(\"{{STRUCT_TY}}\", 0)?;"; @@ -2846,28 +2866,28 @@ class RustGenerator : public BaseGenerator { " s.serialize_field(\"{{FIELD}}\", " "&self.{{FIELD}}())?;"; }); - code_ += " s.end()"; - code_ += " }"; + code_ += " s.end()"; + code_ += " }"; code_ += "}"; code_ += ""; } // Generate a constructor that takes all fields as arguments. code_ += "impl<'a> {{STRUCT_TY}} {"; - code_ += " #[allow(clippy::too_many_arguments)]"; - code_ += " pub fn new("; + code_ += " #[allow(clippy::too_many_arguments)]"; + code_ += " pub fn new("; ForAllStructFields(struct_def, [&](const FieldDef& unused) { (void)unused; - code_ += " {{FIELD}}: {{REF}}{{FIELD_TYPE}},"; + code_ += " {{FIELD}}: {{REF}}{{FIELD_TYPE}},"; }); - code_ += " ) -> Self {"; - code_ += " let mut s = Self([0; {{STRUCT_SIZE}}]);"; + code_ += " ) -> Self {"; + code_ += " let mut s = Self([0; {{STRUCT_SIZE}}]);"; ForAllStructFields(struct_def, [&](const FieldDef& unused) { (void)unused; - code_ += " s.set_{{FIELD}}({{FIELD}});"; + code_ += " s.set_{{FIELD}}({{FIELD}});"; }); - code_ += " s"; - code_ += " }"; + code_ += " s"; + code_ += " }"; code_ += ""; if (parser_.opts.generate_name_strings) { @@ -2880,11 +2900,11 @@ class RustGenerator : public BaseGenerator { // Getter. if (IsStruct(field.value.type)) { code_ += "pub fn {{FIELD}}(&self) -> &{{FIELD_TYPE}} {"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid struct in this slot"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid struct in this slot"; code_ += - " unsafe {" + " unsafe {" " &*(self.0[{{FIELD_OFFSET}}..].as_ptr() as *const" " {{FIELD_TYPE}}) }"; } else if (IsArray(field.value.type)) { @@ -2894,33 +2914,33 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn {{FIELD}}(&'a self) -> " "::flatbuffers::Array<'a, {{ARRAY_ITEM}}, {{ARRAY_SIZE}}> {"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid array in this slot"; - code_ += " use ::flatbuffers::Follow;"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid array in this slot"; + code_ += " use ::flatbuffers::Follow;"; code_ += - " unsafe { ::flatbuffers::Array::follow(&self.0, " + " unsafe { ::flatbuffers::Array::follow(&self.0, " "{{FIELD_OFFSET}}) " "}"; } else { code_ += "pub fn {{FIELD}}(&self) -> {{FIELD_TYPE}} {"; code_ += - " let mut mem = ::core::mem::MaybeUninit::" + " let mut mem = ::core::mem::MaybeUninit::" "<<{{FIELD_TYPE}} as " "::flatbuffers::EndianScalar>::Scalar>::uninit();"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid value in this slot"; - code_ += " ::flatbuffers::EndianScalar::from_little_endian(unsafe {"; - code_ += " ::core::ptr::copy_nonoverlapping("; - code_ += " self.0[{{FIELD_OFFSET}}..].as_ptr(),"; - code_ += " mem.as_mut_ptr() as *mut u8,"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid value in this slot"; + code_ += " ::flatbuffers::EndianScalar::from_little_endian(unsafe {"; + code_ += " ::core::ptr::copy_nonoverlapping("; + code_ += " self.0[{{FIELD_OFFSET}}..].as_ptr(),"; + code_ += " mem.as_mut_ptr() as *mut u8,"; code_ += - " ::core::mem::size_of::<<{{FIELD_TYPE}} as " + " ::core::mem::size_of::<<{{FIELD_TYPE}} as " "::flatbuffers::EndianScalar>::Scalar>(),"; - code_ += " );"; - code_ += " mem.assume_init()"; - code_ += " })"; + code_ += " );"; + code_ += " mem.assume_init()"; + code_ += " })"; } code_ += "}\n"; // Setter. @@ -2929,7 +2949,7 @@ class RustGenerator : public BaseGenerator { code_ += "#[allow(clippy::identity_op)]"; // If FIELD_OFFSET=0. code_ += "pub fn set_{{FIELD}}(&mut self, x: &{{FIELD_TYPE}}) {"; code_ += - " self.0[{{FIELD_OFFSET}}..{{FIELD_OFFSET}} + {{FIELD_SIZE}}]" + " self.0[{{FIELD_OFFSET}}..{{FIELD_OFFSET}} + {{FIELD_SIZE}}]" ".copy_from_slice(&x.0)"; } else if (IsArray(field.value.type)) { if (GetFullType(field.value.type) == ftArrayOfBuiltin) { @@ -2941,43 +2961,43 @@ class RustGenerator : public BaseGenerator { code_ += "pub fn set_{{FIELD}}(&mut self, items: &{{FIELD_TYPE}}) " "{"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid array in this slot"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid array in this slot"; code_ += - " unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, " + " unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, " "{{FIELD_OFFSET}}, items) };"; } else { code_.SetValue("FIELD_SIZE", NumToString(InlineSize(field.value.type))); code_ += "pub fn set_{{FIELD}}(&mut self, x: &{{FIELD_TYPE}}) {"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid array in this slot"; - code_ += " unsafe {"; - code_ += " ::core::ptr::copy("; - code_ += " x.as_ptr() as *const u8,"; - code_ += " self.0.as_mut_ptr().add({{FIELD_OFFSET}}),"; - code_ += " {{FIELD_SIZE}},"; - code_ += " );"; - code_ += " }"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid array in this slot"; + code_ += " unsafe {"; + code_ += " ::core::ptr::copy("; + code_ += " x.as_ptr() as *const u8,"; + code_ += " self.0.as_mut_ptr().add({{FIELD_OFFSET}}),"; + code_ += " {{FIELD_SIZE}},"; + code_ += " );"; + code_ += " }"; } } else { code_ += "pub fn set_{{FIELD}}(&mut self, x: {{FIELD_TYPE}}) {"; code_ += - " let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);"; - code_ += " // Safety:"; - code_ += " // Created from a valid Table for this object"; - code_ += " // Which contains a valid value in this slot"; - code_ += " unsafe {"; - code_ += " ::core::ptr::copy_nonoverlapping("; - code_ += " &x_le as *const _ as *const u8,"; - code_ += " self.0[{{FIELD_OFFSET}}..].as_mut_ptr(),"; + " let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);"; + code_ += " // Safety:"; + code_ += " // Created from a valid Table for this object"; + code_ += " // Which contains a valid value in this slot"; + code_ += " unsafe {"; + code_ += " ::core::ptr::copy_nonoverlapping("; + code_ += " &x_le as *const _ as *const u8,"; + code_ += " self.0[{{FIELD_OFFSET}}..].as_mut_ptr(),"; code_ += - " ::core::mem::size_of::<<{{FIELD_TYPE}} as " + " ::core::mem::size_of::<<{{FIELD_TYPE}} as " "::flatbuffers::EndianScalar>::Scalar>(),"; - code_ += " );"; - code_ += " }"; + code_ += " );"; + code_ += " }"; } code_ += "}\n"; @@ -2990,8 +3010,8 @@ class RustGenerator : public BaseGenerator { // Generate Object API unpack method. if (parser_.opts.generate_object_based_api) { code_.SetValue("STRUCT_OTY", namer_.ObjectType(struct_def)); - code_ += " pub fn unpack(&self) -> {{STRUCT_OTY}} {"; - code_ += " {{STRUCT_OTY}} {"; + code_ += " pub fn unpack(&self) -> {{STRUCT_OTY}} {"; + code_ += " {{STRUCT_OTY}} {"; ForAllStructFields(struct_def, [&](const FieldDef& field) { if (IsArray(field.value.type)) { if (GetFullType(field.value.type) == ftArrayOfStruct) { @@ -3000,15 +3020,15 @@ class RustGenerator : public BaseGenerator { "self.{{FIELD}}(); ::flatbuffers::array_init(|i| " "{{FIELD}}.get(i).unpack()) },"; } else { - code_ += " {{FIELD}}: self.{{FIELD}}().into(),"; + code_ += " {{FIELD}}: self.{{FIELD}}().into(),"; } } else { std::string unpack = IsStruct(field.value.type) ? ".unpack()" : ""; - code_ += " {{FIELD}}: self.{{FIELD}}()" + unpack + ","; + code_ += " {{FIELD}}: self.{{FIELD}}()" + unpack + ","; } }); + code_ += " }"; code_ += " }"; - code_ += " }"; } code_ += "}"; // End impl Struct methods. @@ -3029,25 +3049,25 @@ class RustGenerator : public BaseGenerator { // The `pack` method that turns the native struct into its Flatbuffers // counterpart. code_ += "impl {{STRUCT_OTY}} {"; - code_ += " pub fn pack(&self) -> {{STRUCT_TY}} {"; - code_ += " {{STRUCT_TY}}::new("; + code_ += " pub fn pack(&self) -> {{STRUCT_TY}} {"; + code_ += " {{STRUCT_TY}}::new("; ForAllStructFields(struct_def, [&](const FieldDef& field) { if (IsStruct(field.value.type)) { - code_ += " &self.{{FIELD}}.pack(),"; + code_ += " &self.{{FIELD}}.pack(),"; } else if (IsArray(field.value.type)) { if (GetFullType(field.value.type) == ftArrayOfStruct) { code_ += - " &::flatbuffers::array_init(|i| " + " &::flatbuffers::array_init(|i| " "self.{{FIELD}}[i].pack()),"; } else { - code_ += " &self.{{FIELD}},"; + code_ += " &self.{{FIELD}},"; } } else { - code_ += " self.{{FIELD}},"; + code_ += " self.{{FIELD}},"; } }); - code_ += " )"; - code_ += " }"; + code_ += " )"; + code_ += " }"; code_ += "}"; } } diff --git a/tests/arrays_test/mod.rs b/tests/arrays_test/mod.rs index 5a649d5e8..129b39519 100644 --- a/tests/arrays_test/mod.rs +++ b/tests/arrays_test/mod.rs @@ -1,16 +1,16 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod my_game { - use super::*; - pub mod example { use super::*; - mod test_enum_generated; - pub use self::test_enum_generated::*; - mod nested_struct_generated; - pub use self::nested_struct_generated::*; - mod array_struct_generated; - pub use self::array_struct_generated::*; - mod array_table_generated; - pub use self::array_table_generated::*; - } // example + pub mod example { + use super::*; + mod test_enum_generated; + pub use self::test_enum_generated::*; + mod nested_struct_generated; + pub use self::nested_struct_generated::*; + mod array_struct_generated; + pub use self::array_struct_generated::*; + mod array_table_generated; + pub use self::array_table_generated::*; + } // example } // my_game diff --git a/tests/arrays_test/my_game/example/array_struct_generated.rs b/tests/arrays_test/my_game/example/array_struct_generated.rs index 2f446d4eb..031d8724f 100644 --- a/tests/arrays_test/my_game/example/array_struct_generated.rs +++ b/tests/arrays_test/my_game/example/array_struct_generated.rs @@ -8,43 +8,43 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct ArrayStruct(pub [u8; 160]); -impl Default for ArrayStruct { - fn default() -> Self { - Self([0; 160]) - } +impl Default for ArrayStruct { + fn default() -> Self { + Self([0; 160]) + } } impl ::core::fmt::Debug for ArrayStruct { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("ArrayStruct") - .field("a", &self.a()) - .field("b", &self.b()) - .field("c", &self.c()) - .field("d", &self.d()) - .field("e", &self.e()) - .field("f", &self.f()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("ArrayStruct") + .field("a", &self.a()) + .field("b", &self.b()) + .field("c", &self.c()) + .field("d", &self.d()) + .field("e", &self.e()) + .field("f", &self.f()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for ArrayStruct {} impl<'a> ::flatbuffers::Follow<'a> for ArrayStruct { - type Inner = &'a ArrayStruct; + type Inner = &'a ArrayStruct; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a ArrayStruct>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a ArrayStruct>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a ArrayStruct { - type Inner = &'a ArrayStruct; + type Inner = &'a ArrayStruct; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for ArrayStruct { @@ -63,207 +63,207 @@ impl<'b> ::flatbuffers::Push for ArrayStruct { } impl<'a> ::flatbuffers::Verifiable for ArrayStruct { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> ArrayStruct { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: f32, - b: &[i32; 15], - c: i8, - d: &[NestedStruct; 2], - e: i32, - f: &[i64; 2], - ) -> Self { - let mut s = Self([0; 160]); - s.set_a(a); - s.set_b(b); - s.set_c(c); - s.set_d(d); - s.set_e(e); - s.set_f(f); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.ArrayStruct" - } - - pub fn a(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + a: f32, + b: &[i32; 15], + c: i8, + d: &[NestedStruct; 2], + e: i32, + f: &[i64; 2], + ) -> Self { + let mut s = Self([0; 160]); + s.set_a(a); + s.set_b(b); + s.set_c(c); + s.set_d(d); + s.set_e(e); + s.set_f(f); + s } - } - pub fn b(&'a self) -> ::flatbuffers::Array<'a, i32, 15> { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - use ::flatbuffers::Follow; - unsafe { ::flatbuffers::Array::follow(&self.0, 4) } - } - - pub fn set_b(&mut self, items: &[i32; 15]) { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 4, items) }; - } - - pub fn c(&self) -> i8 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[64..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_c(&mut self, x: i8) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[64..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.ArrayStruct" } - } - pub fn d(&'a self) -> ::flatbuffers::Array<'a, NestedStruct, 2> { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - use ::flatbuffers::Follow; - unsafe { ::flatbuffers::Array::follow(&self.0, 72) } - } - - pub fn set_d(&mut self, x: &[NestedStruct; 2]) { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - unsafe { - ::core::ptr::copy( - x.as_ptr() as *const u8, - self.0.as_mut_ptr().add(72), - 64, - ); + pub fn a(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) } - } - pub fn e(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[136..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_e(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[136..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn set_a(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } } - } - pub fn f(&'a self) -> ::flatbuffers::Array<'a, i64, 2> { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - use ::flatbuffers::Follow; - unsafe { ::flatbuffers::Array::follow(&self.0, 144) } - } - - pub fn set_f(&mut self, items: &[i64; 2]) { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 144, items) }; - } - - pub fn unpack(&self) -> ArrayStructT { - ArrayStructT { - a: self.a(), - b: self.b().into(), - c: self.c(), - d: { let d = self.d(); ::flatbuffers::array_init(|i| d.get(i).unpack()) }, - e: self.e(), - f: self.f().into(), + pub fn b(&'a self) -> ::flatbuffers::Array<'a, i32, 15> { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + use ::flatbuffers::Follow; + unsafe { ::flatbuffers::Array::follow(&self.0, 4) } + } + + pub fn set_b(&mut self, items: &[i32; 15]) { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 4, items) }; + } + + pub fn c(&self) -> i8 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[64..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_c(&mut self, x: i8) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[64..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn d(&'a self) -> ::flatbuffers::Array<'a, NestedStruct, 2> { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + use ::flatbuffers::Follow; + unsafe { ::flatbuffers::Array::follow(&self.0, 72) } + } + + pub fn set_d(&mut self, x: &[NestedStruct; 2]) { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + unsafe { + ::core::ptr::copy( + x.as_ptr() as *const u8, + self.0.as_mut_ptr().add(72), + 64, + ); + } + } + + pub fn e(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[136..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_e(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[136..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn f(&'a self) -> ::flatbuffers::Array<'a, i64, 2> { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + use ::flatbuffers::Follow; + unsafe { ::flatbuffers::Array::follow(&self.0, 144) } + } + + pub fn set_f(&mut self, items: &[i64; 2]) { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 144, items) }; + } + + pub fn unpack(&self) -> ArrayStructT { + ArrayStructT { + a: self.a(), + b: self.b().into(), + c: self.c(), + d: { let d = self.d(); ::flatbuffers::array_init(|i| d.get(i).unpack()) }, + e: self.e(), + f: self.f().into(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct ArrayStructT { - pub a: f32, - pub b: [i32; 15], - pub c: i8, - pub d: [NestedStructT; 2], - pub e: i32, - pub f: [i64; 2], + pub a: f32, + pub b: [i32; 15], + pub c: i8, + pub d: [NestedStructT; 2], + pub e: i32, + pub f: [i64; 2], } impl ArrayStructT { - pub fn pack(&self) -> ArrayStruct { - ArrayStruct::new( - self.a, - &self.b, - self.c, - &::flatbuffers::array_init(|i| self.d[i].pack()), - self.e, - &self.f, - ) - } + pub fn pack(&self) -> ArrayStruct { + ArrayStruct::new( + self.a, + &self.b, + self.c, + &::flatbuffers::array_init(|i| self.d[i].pack()), + self.e, + &self.f, + ) + } } diff --git a/tests/arrays_test/my_game/example/array_table_generated.rs b/tests/arrays_test/my_game/example/array_table_generated.rs index 449f187c2..525a755da 100644 --- a/tests/arrays_test/my_game/example/array_table_generated.rs +++ b/tests/arrays_test/my_game/example/array_table_generated.rs @@ -7,68 +7,68 @@ pub enum ArrayTableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct ArrayTable<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for ArrayTable<'a> { - type Inner = ArrayTable<'a>; + type Inner = ArrayTable<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> ArrayTable<'a> { - pub const VT_A: ::flatbuffers::VOffsetT = 4; + pub const VT_A: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.ArrayTable" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - ArrayTable { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args ArrayTableArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = ArrayTableBuilder::new(_fbb); - if let Some(x) = args.a { builder.add_a(x); } - builder.finish() - } - - pub fn unpack(&self) -> ArrayTableT { - let a = self.a().map(|x| { - x.unpack() - }); - ArrayTableT { - a, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.ArrayTable" } - } - #[inline] - pub fn a(&self) -> Option<&'a ArrayStruct> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ArrayTable::VT_A, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + ArrayTable { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args ArrayTableArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = ArrayTableBuilder::new(_fbb); + if let Some(x) = args.a { builder.add_a(x); } + builder.finish() + } + + pub fn unpack(&self) -> ArrayTableT { + let a = self.a().map(|x| { + x.unpack() + }); + ArrayTableT { + a, + } + } + + #[inline] + pub fn a(&self) -> Option<&'a ArrayStruct> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ArrayTable::VT_A, None)} + } } impl ::flatbuffers::Verifiable for ArrayTable<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("a", Self::VT_A, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("a", Self::VT_A, false)? + .finish(); + Ok(()) + } } pub struct ArrayTableArgs<'a> { @@ -76,74 +76,74 @@ pub struct ArrayTableArgs<'a> { } impl<'a> Default for ArrayTableArgs<'a> { - #[inline] - fn default() -> Self { - ArrayTableArgs { - a: None, + #[inline] + fn default() -> Self { + ArrayTableArgs { + a: None, + } } - } } pub struct ArrayTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ArrayTableBuilder<'a, 'b, A> { - #[inline] - pub fn add_a(&mut self, a: &ArrayStruct) { - self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayTableBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - ArrayTableBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_a(&mut self, a: &ArrayStruct) { + self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayTableBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + ArrayTableBuilder { + 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 ::core::fmt::Debug for ArrayTable<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("ArrayTable"); - ds.field("a", &self.a()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("ArrayTable"); + ds.field("a", &self.a()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct ArrayTableT { - pub a: Option, + pub a: Option, } impl Default for ArrayTableT { - fn default() -> Self { - Self { - a: None, + fn default() -> Self { + Self { + a: None, + } } - } } impl ArrayTableT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let a_tmp = self.a.as_ref().map(|x| x.pack()); - let a = a_tmp.as_ref(); - ArrayTable::create(_fbb, &ArrayTableArgs{ - a, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let a_tmp = self.a.as_ref().map(|x| x.pack()); + let a = a_tmp.as_ref(); + ArrayTable::create(_fbb, &ArrayTableArgs{ + a, + }) + } } /// Verifies that a buffer of bytes contains a `ArrayTable` @@ -154,7 +154,7 @@ impl ArrayTableT { /// `root_as_array_table_unchecked`. #[inline] pub fn root_as_array_table(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) + ::flatbuffers::root::(buf) } /// Verifies that a buffer of bytes contains a size prefixed @@ -165,7 +165,7 @@ pub fn root_as_array_table(buf: &[u8]) -> Result, ::flatbuffers:: /// `size_prefixed_root_as_array_table_unchecked`. #[inline] pub fn size_prefixed_root_as_array_table(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) + ::flatbuffers::size_prefixed_root::(buf) } /// Verifies, with the given options, that a buffer of bytes @@ -176,10 +176,10 @@ pub fn size_prefixed_root_as_array_table(buf: &[u8]) -> Result, : /// `root_as_array_table_unchecked`. #[inline] pub fn root_as_array_table_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) + ::flatbuffers::root_with_opts::>(opts, buf) } /// Verifies, with the given verifier options, that a buffer of @@ -190,10 +190,10 @@ pub fn root_as_array_table_with_opts<'b, 'o>( /// `root_as_array_table_unchecked`. #[inline] pub fn size_prefixed_root_as_array_table_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } /// Assumes, without verification, that a buffer of bytes contains a ArrayTable and returns it. @@ -201,7 +201,7 @@ pub fn size_prefixed_root_as_array_table_with_opts<'b, 'o>( /// Callers must trust the given bytes do indeed contain a valid `ArrayTable`. #[inline] pub unsafe fn root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } + unsafe { ::flatbuffers::root_unchecked::(buf) } } /// Assumes, without verification, that a buffer of bytes contains a size prefixed ArrayTable and returns it. @@ -209,19 +209,19 @@ pub unsafe fn root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> { /// Callers must trust the given bytes do indeed contain a valid size prefixed `ArrayTable`. #[inline] pub unsafe fn size_prefixed_root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } } pub const ARRAY_TABLE_IDENTIFIER: &str = "ARRT"; #[inline] pub fn array_table_buffer_has_identifier(buf: &[u8]) -> bool { - ::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, false) + ::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, false) } #[inline] pub fn array_table_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool { - ::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, true) + ::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, true) } pub const ARRAY_TABLE_EXTENSION: &str = "mon"; @@ -229,11 +229,15 @@ pub const ARRAY_TABLE_EXTENSION: &str = "mon"; #[inline] pub fn finish_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>) { - fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER)); + root: ::flatbuffers::WIPOffset> +) { + fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER)); } #[inline] -pub fn finish_size_prefixed_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset>) { - fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER)); +pub fn finish_size_prefixed_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset> +) { + fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER)); } diff --git a/tests/arrays_test/my_game/example/nested_struct_generated.rs b/tests/arrays_test/my_game/example/nested_struct_generated.rs index 40134ea51..65159143e 100644 --- a/tests/arrays_test/my_game/example/nested_struct_generated.rs +++ b/tests/arrays_test/my_game/example/nested_struct_generated.rs @@ -8,41 +8,41 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct NestedStruct(pub [u8; 32]); -impl Default for NestedStruct { - fn default() -> Self { - Self([0; 32]) - } +impl Default for NestedStruct { + fn default() -> Self { + Self([0; 32]) + } } impl ::core::fmt::Debug for NestedStruct { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("NestedStruct") - .field("a", &self.a()) - .field("b", &self.b()) - .field("c", &self.c()) - .field("d", &self.d()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("NestedStruct") + .field("a", &self.a()) + .field("b", &self.b()) + .field("c", &self.c()) + .field("d", &self.d()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for NestedStruct {} impl<'a> ::flatbuffers::Follow<'a> for NestedStruct { - type Inner = &'a NestedStruct; + type Inner = &'a NestedStruct; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a NestedStruct>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a NestedStruct>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a NestedStruct { - type Inner = &'a NestedStruct; + type Inner = &'a NestedStruct; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for NestedStruct { @@ -61,139 +61,139 @@ impl<'b> ::flatbuffers::Push for NestedStruct { } impl<'a> ::flatbuffers::Verifiable for NestedStruct { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> NestedStruct { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: &[i32; 2], - b: TestEnum, - c: &[TestEnum; 2], - d: &[i64; 2], - ) -> Self { - let mut s = Self([0; 32]); - s.set_a(a); - s.set_b(b); - s.set_c(c); - s.set_d(d); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.NestedStruct" - } - - pub fn a(&'a self) -> ::flatbuffers::Array<'a, i32, 2> { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - use ::flatbuffers::Follow; - unsafe { ::flatbuffers::Array::follow(&self.0, 0) } - } - - pub fn set_a(&mut self, items: &[i32; 2]) { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) }; - } - - pub fn b(&self) -> TestEnum { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[8..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_b(&mut self, x: TestEnum) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[8..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + a: &[i32; 2], + b: TestEnum, + c: &[TestEnum; 2], + d: &[i64; 2], + ) -> Self { + let mut s = Self([0; 32]); + s.set_a(a); + s.set_b(b); + s.set_c(c); + s.set_d(d); + s } - } - pub fn c(&'a self) -> ::flatbuffers::Array<'a, TestEnum, 2> { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - use ::flatbuffers::Follow; - unsafe { ::flatbuffers::Array::follow(&self.0, 9) } - } - - pub fn set_c(&mut self, x: &[TestEnum; 2]) { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - unsafe { - ::core::ptr::copy( - x.as_ptr() as *const u8, - self.0.as_mut_ptr().add(9), - 2, - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.NestedStruct" } - } - pub fn d(&'a self) -> ::flatbuffers::Array<'a, i64, 2> { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - use ::flatbuffers::Follow; - unsafe { ::flatbuffers::Array::follow(&self.0, 16) } - } - - pub fn set_d(&mut self, items: &[i64; 2]) { - // Safety: - // Created from a valid Table for this object - // Which contains a valid array in this slot - unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 16, items) }; - } - - pub fn unpack(&self) -> NestedStructT { - NestedStructT { - a: self.a().into(), - b: self.b(), - c: self.c().into(), - d: self.d().into(), + pub fn a(&'a self) -> ::flatbuffers::Array<'a, i32, 2> { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + use ::flatbuffers::Follow; + unsafe { ::flatbuffers::Array::follow(&self.0, 0) } + } + + pub fn set_a(&mut self, items: &[i32; 2]) { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) }; + } + + pub fn b(&self) -> TestEnum { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[8..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_b(&mut self, x: TestEnum) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[8..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn c(&'a self) -> ::flatbuffers::Array<'a, TestEnum, 2> { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + use ::flatbuffers::Follow; + unsafe { ::flatbuffers::Array::follow(&self.0, 9) } + } + + pub fn set_c(&mut self, x: &[TestEnum; 2]) { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + unsafe { + ::core::ptr::copy( + x.as_ptr() as *const u8, + self.0.as_mut_ptr().add(9), + 2, + ); + } + } + + pub fn d(&'a self) -> ::flatbuffers::Array<'a, i64, 2> { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + use ::flatbuffers::Follow; + unsafe { ::flatbuffers::Array::follow(&self.0, 16) } + } + + pub fn set_d(&mut self, items: &[i64; 2]) { + // Safety: + // Created from a valid Table for this object + // Which contains a valid array in this slot + unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 16, items) }; + } + + pub fn unpack(&self) -> NestedStructT { + NestedStructT { + a: self.a().into(), + b: self.b(), + c: self.c().into(), + d: self.d().into(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct NestedStructT { - pub a: [i32; 2], - pub b: TestEnum, - pub c: [TestEnum; 2], - pub d: [i64; 2], + pub a: [i32; 2], + pub b: TestEnum, + pub c: [TestEnum; 2], + pub d: [i64; 2], } impl NestedStructT { - pub fn pack(&self) -> NestedStruct { - NestedStruct::new( - &self.a, - self.b, - &self.c, - &self.d, - ) - } + pub fn pack(&self) -> NestedStruct { + NestedStruct::new( + &self.a, + self.b, + &self.c, + &self.d, + ) + } } diff --git a/tests/arrays_test/my_game/example/test_enum_generated.rs b/tests/arrays_test/my_game/example/test_enum_generated.rs index de750a19a..ff0f42683 100644 --- a/tests/arrays_test/my_game/example/test_enum_generated.rs +++ b/tests/arrays_test/my_game/example/test_enum_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_TEST_ENUM: 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_TEST_ENUM: [TestEnum; 3] = [ - TestEnum::A, - TestEnum::B, - TestEnum::C, + TestEnum::A, + TestEnum::B, + TestEnum::C, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub struct TestEnum(pub i8); #[allow(non_upper_case_globals)] impl TestEnum { - pub const A: Self = Self(0); - pub const B: Self = Self(1); - pub const C: Self = Self(2); + pub const A: Self = Self(0); + pub const B: Self = Self(1); + pub const C: Self = Self(2); - pub const ENUM_MIN: i8 = 0; - pub const ENUM_MAX: i8 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::A, - Self::B, - Self::C, - ]; + pub const ENUM_MIN: i8 = 0; + pub const ENUM_MAX: i8 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::A, + Self::B, + Self::C, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::A => Some("A"), - Self::B => Some("B"), - Self::C => Some("C"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::A => Some("A"), + Self::B => Some("B"), + Self::C => Some("C"), + _ => None, + } } - } } impl ::core::fmt::Debug for TestEnum { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 TestEnum { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for TestEnum { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for TestEnum { } impl ::flatbuffers::EndianScalar for TestEnum { - type Scalar = i8; + type Scalar = i8; - #[inline] - fn to_little_endian(self) -> i8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i8) -> Self { - let b = i8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i8) -> Self { + let b = i8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for TestEnum { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for TestEnum {} diff --git a/tests/include_test1/mod.rs b/tests/include_test1/mod.rs index ca4894dc3..a69094e07 100644 --- a/tests/include_test1/mod.rs +++ b/tests/include_test1/mod.rs @@ -1,16 +1,16 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod my_game { - use super::*; - pub mod other_name_space { use super::*; - mod from_include_generated; - pub use self::from_include_generated::*; - mod unused_generated; - pub use self::unused_generated::*; - mod table_b_generated; - pub use self::table_b_generated::*; - } // other_name_space + pub mod other_name_space { + use super::*; + mod from_include_generated; + pub use self::from_include_generated::*; + mod unused_generated; + pub use self::unused_generated::*; + mod table_b_generated; + pub use self::table_b_generated::*; + } // other_name_space } // my_game mod table_a_generated; pub use self::table_a_generated::*; diff --git a/tests/include_test1/my_game/other_name_space/from_include_generated.rs b/tests/include_test1/my_game/other_name_space/from_include_generated.rs index 4e03e2dec..ada294725 100644 --- a/tests/include_test1/my_game/other_name_space/from_include_generated.rs +++ b/tests/include_test1/my_game/other_name_space/from_include_generated.rs @@ -12,7 +12,7 @@ pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; #[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_FROM_INCLUDE: [FromInclude; 1] = [ - FromInclude::IncludeVal, + FromInclude::IncludeVal, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -21,41 +21,41 @@ pub struct FromInclude(pub i64); #[allow(non_upper_case_globals)] impl FromInclude { - pub const IncludeVal: Self = Self(0); + pub const IncludeVal: Self = Self(0); - pub const ENUM_MIN: i64 = 0; - pub const ENUM_MAX: i64 = 0; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::IncludeVal, - ]; + pub const ENUM_MIN: i64 = 0; + pub const ENUM_MAX: i64 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::IncludeVal, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::IncludeVal => Some("IncludeVal"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::IncludeVal => Some("IncludeVal"), + _ => None, + } } - } } impl ::core::fmt::Debug for FromInclude { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 FromInclude { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for FromInclude { @@ -68,28 +68,28 @@ impl ::flatbuffers::Push for FromInclude { } impl ::flatbuffers::EndianScalar for FromInclude { - type Scalar = i64; + type Scalar = i64; - #[inline] - fn to_little_endian(self) -> i64 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i64 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i64) -> Self { - let b = i64::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i64) -> Self { + let b = i64::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for FromInclude { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i64::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i64::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} diff --git a/tests/include_test1/my_game/other_name_space/table_b_generated.rs b/tests/include_test1/my_game/other_name_space/table_b_generated.rs index 5e969c2dc..5434e448a 100644 --- a/tests/include_test1/my_game/other_name_space/table_b_generated.rs +++ b/tests/include_test1/my_game/other_name_space/table_b_generated.rs @@ -7,68 +7,68 @@ pub enum TableBOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableB<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { - type Inner = TableB<'a>; + type Inner = TableB<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableB<'a> { - pub const VT_A: ::flatbuffers::VOffsetT = 4; + pub const VT_A: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.TableB" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableB { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableBArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableBBuilder::new(_fbb); - if let Some(x) = args.a { builder.add_a(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableBT { - let a = self.a().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableBT { - a, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.TableB" } - } - #[inline] - pub fn a(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableB { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableBArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableBBuilder::new(_fbb); + if let Some(x) = args.a { builder.add_a(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableBT { + let a = self.a().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableBT { + a, + } + } + + #[inline] + pub fn a(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} + } } impl ::flatbuffers::Verifiable for TableB<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? + .finish(); + Ok(()) + } } pub struct TableBArgs<'a> { @@ -76,73 +76,73 @@ pub struct TableBArgs<'a> { } impl<'a> Default for TableBArgs<'a> { - #[inline] - fn default() -> Self { - TableBArgs { - a: None, + #[inline] + fn default() -> Self { + TableBArgs { + a: None, + } } - } } pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { - #[inline] - pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableBBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableBBuilder { + 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 ::core::fmt::Debug for TableB<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableB"); - ds.field("a", &self.a()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableB"); + ds.field("a", &self.a()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableBT { - pub a: Option>, + pub a: Option>, } impl Default for TableBT { - fn default() -> Self { - Self { - a: None, + fn default() -> Self { + Self { + a: None, + } } - } } impl TableBT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let a = self.a.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableB::create(_fbb, &TableBArgs{ - a, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let a = self.a.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableB::create(_fbb, &TableBArgs{ + a, + }) + } } diff --git a/tests/include_test1/my_game/other_name_space/unused_generated.rs b/tests/include_test1/my_game/other_name_space/unused_generated.rs index e8639acf2..12f7fa768 100644 --- a/tests/include_test1/my_game/other_name_space/unused_generated.rs +++ b/tests/include_test1/my_game/other_name_space/unused_generated.rs @@ -8,38 +8,38 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Unused(pub [u8; 4]); -impl Default for Unused { - fn default() -> Self { - Self([0; 4]) - } +impl Default for Unused { + fn default() -> Self { + Self([0; 4]) + } } impl ::core::fmt::Debug for Unused { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Unused") - .field("a", &self.a()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Unused") + .field("a", &self.a()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} impl<'a> ::flatbuffers::Follow<'a> for Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Unused>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Unused>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Unused { @@ -58,73 +58,73 @@ impl<'b> ::flatbuffers::Push for Unused { } impl<'a> ::flatbuffers::Verifiable for Unused { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> Unused { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: i32, - ) -> Self { - let mut s = Self([0; 4]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.Unused" - } - - pub fn a(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + a: i32, + ) -> Self { + let mut s = Self([0; 4]); + s.set_a(a); + s } - } - pub fn unpack(&self) -> UnusedT { - UnusedT { - a: self.a(), + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.Unused" + } + + pub fn a(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> UnusedT { + UnusedT { + a: self.a(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct UnusedT { - pub a: i32, + pub a: i32, } impl UnusedT { - pub fn pack(&self) -> Unused { - Unused::new( - self.a, - ) - } + pub fn pack(&self) -> Unused { + Unused::new( + self.a, + ) + } } diff --git a/tests/include_test1/table_a_generated.rs b/tests/include_test1/table_a_generated.rs index 2558b8406..467c514a1 100644 --- a/tests/include_test1/table_a_generated.rs +++ b/tests/include_test1/table_a_generated.rs @@ -7,68 +7,68 @@ pub enum TableAOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableA<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> { - type Inner = TableA<'a>; + type Inner = TableA<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableA<'a> { - pub const VT_B: ::flatbuffers::VOffsetT = 4; + pub const VT_B: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "TableA" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableA { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableAArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableABuilder::new(_fbb); - if let Some(x) = args.b { builder.add_b(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableAT { - let b = self.b().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableAT { - b, + pub const fn get_fully_qualified_name() -> &'static str { + "TableA" } - } - #[inline] - pub fn b(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableA { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableAArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableABuilder::new(_fbb); + if let Some(x) = args.b { builder.add_b(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableAT { + let b = self.b().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableAT { + b, + } + } + + #[inline] + pub fn b(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} + } } impl ::flatbuffers::Verifiable for TableA<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? + .finish(); + Ok(()) + } } pub struct TableAArgs<'a> { @@ -76,73 +76,73 @@ pub struct TableAArgs<'a> { } impl<'a> Default for TableAArgs<'a> { - #[inline] - fn default() -> Self { - TableAArgs { - b: None, + #[inline] + fn default() -> Self { + TableAArgs { + b: None, + } } - } } pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> { - #[inline] - pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableABuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableABuilder { + 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 ::core::fmt::Debug for TableA<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableA"); - ds.field("b", &self.b()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableA"); + ds.field("b", &self.b()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableAT { - pub b: Option>, + pub b: Option>, } impl Default for TableAT { - fn default() -> Self { - Self { - b: None, + fn default() -> Self { + Self { + b: None, + } } - } } impl TableAT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let b = self.b.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableA::create(_fbb, &TableAArgs{ - b, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let b = self.b.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableA::create(_fbb, &TableAArgs{ + b, + }) + } } diff --git a/tests/include_test1_generated.rs b/tests/include_test1_generated.rs index bb00aa8fc..708e8627b 100644 --- a/tests/include_test1_generated.rs +++ b/tests/include_test1_generated.rs @@ -6,68 +6,68 @@ pub enum TableAOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableA<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> { - type Inner = TableA<'a>; + type Inner = TableA<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableA<'a> { - pub const VT_B: ::flatbuffers::VOffsetT = 4; + pub const VT_B: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "TableA" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableA { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableAArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableABuilder::new(_fbb); - if let Some(x) = args.b { builder.add_b(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableAT { - let b = self.b().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableAT { - b, + pub const fn get_fully_qualified_name() -> &'static str { + "TableA" } - } - #[inline] - pub fn b(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableA { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableAArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableABuilder::new(_fbb); + if let Some(x) = args.b { builder.add_b(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableAT { + let b = self.b().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableAT { + b, + } + } + + #[inline] + pub fn b(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} + } } impl ::flatbuffers::Verifiable for TableA<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? + .finish(); + Ok(()) + } } pub struct TableAArgs<'a> { @@ -75,444 +75,444 @@ pub struct TableAArgs<'a> { } impl<'a> Default for TableAArgs<'a> { - #[inline] - fn default() -> Self { - TableAArgs { - b: None, + #[inline] + fn default() -> Self { + TableAArgs { + b: None, + } } - } } pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> { - #[inline] - pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableABuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableABuilder { + 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 ::core::fmt::Debug for TableA<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableA"); - ds.field("b", &self.b()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableA"); + ds.field("b", &self.b()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableAT { - pub b: Option>, + pub b: Option>, } impl Default for TableAT { - fn default() -> Self { - Self { - b: None, + fn default() -> Self { + Self { + b: None, + } } - } } impl TableAT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let b = self.b.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableA::create(_fbb, &TableAArgs{ - b, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let b = self.b.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableA::create(_fbb, &TableAArgs{ + b, + }) + } } #[allow(unused_imports, dead_code)] pub mod my_game { - extern crate alloc; - - #[allow(unused_imports, dead_code)] - pub mod other_name_space { extern crate alloc; - #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] - pub const ENUM_MIN_FROM_INCLUDE: i64 = 0; + #[allow(unused_imports, dead_code)] + pub mod other_name_space { + extern crate alloc; - #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] - pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; + #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] + pub const ENUM_MIN_FROM_INCLUDE: i64 = 0; - #[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_FROM_INCLUDE: [FromInclude; 1] = [ - FromInclude::IncludeVal, - ]; + #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] + pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] - #[repr(transparent)] - pub struct FromInclude(pub i64); + #[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_FROM_INCLUDE: [FromInclude; 1] = [ + FromInclude::IncludeVal, + ]; - #[allow(non_upper_case_globals)] - impl FromInclude { - pub const IncludeVal: Self = Self(0); + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] + #[repr(transparent)] + pub struct FromInclude(pub i64); - pub const ENUM_MIN: i64 = 0; - pub const ENUM_MAX: i64 = 0; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::IncludeVal, - ]; + #[allow(non_upper_case_globals)] + impl FromInclude { + pub const IncludeVal: Self = Self(0); - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::IncludeVal => Some("IncludeVal"), - _ => None, - } - } - } + pub const ENUM_MIN: i64 = 0; + pub const ENUM_MAX: i64 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::IncludeVal, + ]; - impl ::core::fmt::Debug for FromInclude { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 FromInclude { - type Inner = Self; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } - } - - impl ::flatbuffers::Push for FromInclude { - type Output = FromInclude; - - #[inline] - unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; - } - } - - impl ::flatbuffers::EndianScalar for FromInclude { - type Scalar = i64; - - #[inline] - fn to_little_endian(self) -> i64 { - self.0.to_le() - } - - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i64) -> Self { - let b = i64::from_le(v); - Self(b) - } - } - - impl<'a> ::flatbuffers::Verifiable for FromInclude { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i64::run_verifier(v, pos) - } - } - - impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} - - // struct Unused, aligned to 4 - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq)] - pub struct Unused(pub [u8; 4]); - - impl Default for Unused { - fn default() -> Self { - Self([0; 4]) - } - } - - impl ::core::fmt::Debug for Unused { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Unused") - .field("a", &self.a()) - .finish() - } - } - - impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} - - impl<'a> ::flatbuffers::Follow<'a> for Unused { - type Inner = &'a Unused; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Unused>::follow(buf, loc) } - } - } - - impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { - type Inner = &'a Unused; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } - } - - impl<'b> ::flatbuffers::Push for Unused { - type Output = Unused; - - #[inline] - unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, ::size()) }; - dst.copy_from_slice(src); + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::IncludeVal => Some("IncludeVal"), + _ => None, + } + } } - #[inline] - fn alignment() -> ::flatbuffers::PushAlignment { - ::flatbuffers::PushAlignment::new(4) + impl ::core::fmt::Debug for FromInclude { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } + } } - } - impl<'a> ::flatbuffers::Verifiable for Unused { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } - } + impl<'a> ::flatbuffers::Follow<'a> for FromInclude { + type Inner = Self; - impl<'a> Unused { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: i32, - ) -> Self { - let mut s = Self([0; 4]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.Unused" - } - - pub fn a(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } - } - pub fn unpack(&self) -> UnusedT { - UnusedT { - a: self.a(), + impl ::flatbuffers::Push for FromInclude { + type Output = FromInclude; + + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + } } - } - } - #[derive(Debug, Clone, PartialEq, Default)] - pub struct UnusedT { - pub a: i32, - } + impl ::flatbuffers::EndianScalar for FromInclude { + type Scalar = i64; - impl UnusedT { - pub fn pack(&self) -> Unused { - Unused::new( - self.a, - ) - } - } + #[inline] + fn to_little_endian(self) -> i64 { + self.0.to_le() + } - pub enum TableBOffset {} - - #[derive(Copy, Clone, PartialEq)] - pub struct TableB<'a> { - pub _tab: ::flatbuffers::Table<'a>, - } - - impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { - type Inner = TableB<'a>; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } - } - - impl<'a> TableB<'a> { - pub const VT_A: ::flatbuffers::VOffsetT = 4; - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.TableB" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableB { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableBArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableBBuilder::new(_fbb); - if let Some(x) = args.a { builder.add_a(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableBT { - let a = self.a().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableBT { - a, + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i64) -> Self { + let b = i64::from_le(v); + Self(b) + } } - } - #[inline] - pub fn a(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} - } - } - - impl ::flatbuffers::Verifiable for TableB<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? - .finish(); - Ok(()) - } - } - - pub struct TableBArgs<'a> { - pub a: Option<::flatbuffers::WIPOffset>>, - } - - impl<'a> Default for TableBArgs<'a> { - #[inline] - fn default() -> Self { - TableBArgs { - a: None, + impl<'a> ::flatbuffers::Verifiable for FromInclude { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i64::run_verifier(v, pos) + } } - } - } - pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, - } + impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { - #[inline] - pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); - } + // struct Unused, aligned to 4 + #[repr(transparent)] + #[derive(Clone, Copy, PartialEq)] + pub struct Unused(pub [u8; 4]); - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableBBuilder { - fbb_: _fbb, - start_: start, + impl Default for Unused { + fn default() -> Self { + Self([0; 4]) + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } - } - - impl ::core::fmt::Debug for TableB<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableB"); - ds.field("a", &self.a()); - ds.finish() - } - } - - #[non_exhaustive] - #[derive(Debug, Clone, PartialEq)] - pub struct TableBT { - pub a: Option>, - } - - impl Default for TableBT { - fn default() -> Self { - Self { - a: None, + impl ::core::fmt::Debug for Unused { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Unused") + .field("a", &self.a()) + .finish() + } } - } - } - impl TableBT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let a = self.a.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableB::create(_fbb, &TableBArgs{ - a, - }) - } - } - } // pub mod OtherNameSpace + impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} + + impl<'a> ::flatbuffers::Follow<'a> for Unused { + type Inner = &'a Unused; + + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Unused>::follow(buf, loc) } + } + } + + impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { + type Inner = &'a Unused; + + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } + } + + impl<'b> ::flatbuffers::Push for Unused { + type Output = Unused; + + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, ::size()) }; + dst.copy_from_slice(src); + } + + #[inline] + fn alignment() -> ::flatbuffers::PushAlignment { + ::flatbuffers::PushAlignment::new(4) + } + } + + impl<'a> ::flatbuffers::Verifiable for Unused { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } + } + + impl<'a> Unused { + #[allow(clippy::too_many_arguments)] + pub fn new( + a: i32, + ) -> Self { + let mut s = Self([0; 4]); + s.set_a(a); + s + } + + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.Unused" + } + + pub fn a(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> UnusedT { + UnusedT { + a: self.a(), + } + } + } + + #[derive(Debug, Clone, PartialEq, Default)] + pub struct UnusedT { + pub a: i32, + } + + impl UnusedT { + pub fn pack(&self) -> Unused { + Unused::new( + self.a, + ) + } + } + + pub enum TableBOffset {} + + #[derive(Copy, Clone, PartialEq)] + pub struct TableB<'a> { + pub _tab: ::flatbuffers::Table<'a>, + } + + impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { + type Inner = TableB<'a>; + + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } + } + + impl<'a> TableB<'a> { + pub const VT_A: ::flatbuffers::VOffsetT = 4; + + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.TableB" + } + + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableB { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableBArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableBBuilder::new(_fbb); + if let Some(x) = args.a { builder.add_a(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableBT { + let a = self.a().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableBT { + a, + } + } + + #[inline] + pub fn a(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} + } + } + + impl ::flatbuffers::Verifiable for TableB<'_> { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? + .finish(); + Ok(()) + } + } + + pub struct TableBArgs<'a> { + pub a: Option<::flatbuffers::WIPOffset>>, + } + + impl<'a> Default for TableBArgs<'a> { + #[inline] + fn default() -> Self { + TableBArgs { + a: None, + } + } + } + + pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + } + + impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { + #[inline] + pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableBBuilder { + 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 ::core::fmt::Debug for TableB<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableB"); + ds.field("a", &self.a()); + ds.finish() + } + } + + #[non_exhaustive] + #[derive(Debug, Clone, PartialEq)] + pub struct TableBT { + pub a: Option>, + } + + impl Default for TableBT { + fn default() -> Self { + Self { + a: None, + } + } + } + + impl TableBT { + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let a = self.a.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableB::create(_fbb, &TableBArgs{ + a, + }) + } + } + } // pub mod OtherNameSpace } // pub mod MyGame diff --git a/tests/include_test2/mod.rs b/tests/include_test2/mod.rs index ca4894dc3..a69094e07 100644 --- a/tests/include_test2/mod.rs +++ b/tests/include_test2/mod.rs @@ -1,16 +1,16 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod my_game { - use super::*; - pub mod other_name_space { use super::*; - mod from_include_generated; - pub use self::from_include_generated::*; - mod unused_generated; - pub use self::unused_generated::*; - mod table_b_generated; - pub use self::table_b_generated::*; - } // other_name_space + pub mod other_name_space { + use super::*; + mod from_include_generated; + pub use self::from_include_generated::*; + mod unused_generated; + pub use self::unused_generated::*; + mod table_b_generated; + pub use self::table_b_generated::*; + } // other_name_space } // my_game mod table_a_generated; pub use self::table_a_generated::*; diff --git a/tests/include_test2/my_game/other_name_space/from_include_generated.rs b/tests/include_test2/my_game/other_name_space/from_include_generated.rs index 4e03e2dec..ada294725 100644 --- a/tests/include_test2/my_game/other_name_space/from_include_generated.rs +++ b/tests/include_test2/my_game/other_name_space/from_include_generated.rs @@ -12,7 +12,7 @@ pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; #[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_FROM_INCLUDE: [FromInclude; 1] = [ - FromInclude::IncludeVal, + FromInclude::IncludeVal, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -21,41 +21,41 @@ pub struct FromInclude(pub i64); #[allow(non_upper_case_globals)] impl FromInclude { - pub const IncludeVal: Self = Self(0); + pub const IncludeVal: Self = Self(0); - pub const ENUM_MIN: i64 = 0; - pub const ENUM_MAX: i64 = 0; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::IncludeVal, - ]; + pub const ENUM_MIN: i64 = 0; + pub const ENUM_MAX: i64 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::IncludeVal, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::IncludeVal => Some("IncludeVal"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::IncludeVal => Some("IncludeVal"), + _ => None, + } } - } } impl ::core::fmt::Debug for FromInclude { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 FromInclude { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for FromInclude { @@ -68,28 +68,28 @@ impl ::flatbuffers::Push for FromInclude { } impl ::flatbuffers::EndianScalar for FromInclude { - type Scalar = i64; + type Scalar = i64; - #[inline] - fn to_little_endian(self) -> i64 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i64 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i64) -> Self { - let b = i64::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i64) -> Self { + let b = i64::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for FromInclude { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i64::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i64::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} diff --git a/tests/include_test2/my_game/other_name_space/table_b_generated.rs b/tests/include_test2/my_game/other_name_space/table_b_generated.rs index 5e969c2dc..5434e448a 100644 --- a/tests/include_test2/my_game/other_name_space/table_b_generated.rs +++ b/tests/include_test2/my_game/other_name_space/table_b_generated.rs @@ -7,68 +7,68 @@ pub enum TableBOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableB<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { - type Inner = TableB<'a>; + type Inner = TableB<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableB<'a> { - pub const VT_A: ::flatbuffers::VOffsetT = 4; + pub const VT_A: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.TableB" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableB { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableBArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableBBuilder::new(_fbb); - if let Some(x) = args.a { builder.add_a(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableBT { - let a = self.a().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableBT { - a, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.TableB" } - } - #[inline] - pub fn a(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableB { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableBArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableBBuilder::new(_fbb); + if let Some(x) = args.a { builder.add_a(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableBT { + let a = self.a().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableBT { + a, + } + } + + #[inline] + pub fn a(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} + } } impl ::flatbuffers::Verifiable for TableB<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? + .finish(); + Ok(()) + } } pub struct TableBArgs<'a> { @@ -76,73 +76,73 @@ pub struct TableBArgs<'a> { } impl<'a> Default for TableBArgs<'a> { - #[inline] - fn default() -> Self { - TableBArgs { - a: None, + #[inline] + fn default() -> Self { + TableBArgs { + a: None, + } } - } } pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { - #[inline] - pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableBBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableBBuilder { + 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 ::core::fmt::Debug for TableB<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableB"); - ds.field("a", &self.a()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableB"); + ds.field("a", &self.a()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableBT { - pub a: Option>, + pub a: Option>, } impl Default for TableBT { - fn default() -> Self { - Self { - a: None, + fn default() -> Self { + Self { + a: None, + } } - } } impl TableBT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let a = self.a.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableB::create(_fbb, &TableBArgs{ - a, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let a = self.a.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableB::create(_fbb, &TableBArgs{ + a, + }) + } } diff --git a/tests/include_test2/my_game/other_name_space/unused_generated.rs b/tests/include_test2/my_game/other_name_space/unused_generated.rs index e8639acf2..12f7fa768 100644 --- a/tests/include_test2/my_game/other_name_space/unused_generated.rs +++ b/tests/include_test2/my_game/other_name_space/unused_generated.rs @@ -8,38 +8,38 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Unused(pub [u8; 4]); -impl Default for Unused { - fn default() -> Self { - Self([0; 4]) - } +impl Default for Unused { + fn default() -> Self { + Self([0; 4]) + } } impl ::core::fmt::Debug for Unused { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Unused") - .field("a", &self.a()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Unused") + .field("a", &self.a()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} impl<'a> ::flatbuffers::Follow<'a> for Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Unused>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Unused>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Unused { @@ -58,73 +58,73 @@ impl<'b> ::flatbuffers::Push for Unused { } impl<'a> ::flatbuffers::Verifiable for Unused { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> Unused { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: i32, - ) -> Self { - let mut s = Self([0; 4]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.Unused" - } - - pub fn a(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + a: i32, + ) -> Self { + let mut s = Self([0; 4]); + s.set_a(a); + s } - } - pub fn unpack(&self) -> UnusedT { - UnusedT { - a: self.a(), + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.Unused" + } + + pub fn a(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> UnusedT { + UnusedT { + a: self.a(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct UnusedT { - pub a: i32, + pub a: i32, } impl UnusedT { - pub fn pack(&self) -> Unused { - Unused::new( - self.a, - ) - } + pub fn pack(&self) -> Unused { + Unused::new( + self.a, + ) + } } diff --git a/tests/include_test2/table_a_generated.rs b/tests/include_test2/table_a_generated.rs index 2558b8406..467c514a1 100644 --- a/tests/include_test2/table_a_generated.rs +++ b/tests/include_test2/table_a_generated.rs @@ -7,68 +7,68 @@ pub enum TableAOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableA<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> { - type Inner = TableA<'a>; + type Inner = TableA<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableA<'a> { - pub const VT_B: ::flatbuffers::VOffsetT = 4; + pub const VT_B: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "TableA" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableA { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableAArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableABuilder::new(_fbb); - if let Some(x) = args.b { builder.add_b(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableAT { - let b = self.b().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableAT { - b, + pub const fn get_fully_qualified_name() -> &'static str { + "TableA" } - } - #[inline] - pub fn b(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableA { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableAArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableABuilder::new(_fbb); + if let Some(x) = args.b { builder.add_b(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableAT { + let b = self.b().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableAT { + b, + } + } + + #[inline] + pub fn b(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} + } } impl ::flatbuffers::Verifiable for TableA<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? + .finish(); + Ok(()) + } } pub struct TableAArgs<'a> { @@ -76,73 +76,73 @@ pub struct TableAArgs<'a> { } impl<'a> Default for TableAArgs<'a> { - #[inline] - fn default() -> Self { - TableAArgs { - b: None, + #[inline] + fn default() -> Self { + TableAArgs { + b: None, + } } - } } pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> { - #[inline] - pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableABuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableABuilder { + 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 ::core::fmt::Debug for TableA<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableA"); - ds.field("b", &self.b()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableA"); + ds.field("b", &self.b()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableAT { - pub b: Option>, + pub b: Option>, } impl Default for TableAT { - fn default() -> Self { - Self { - b: None, + fn default() -> Self { + Self { + b: None, + } } - } } impl TableAT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let b = self.b.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableA::create(_fbb, &TableAArgs{ - b, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let b = self.b.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableA::create(_fbb, &TableAArgs{ + b, + }) + } } diff --git a/tests/include_test2_generated.rs b/tests/include_test2_generated.rs index bb00aa8fc..708e8627b 100644 --- a/tests/include_test2_generated.rs +++ b/tests/include_test2_generated.rs @@ -6,68 +6,68 @@ pub enum TableAOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableA<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> { - type Inner = TableA<'a>; + type Inner = TableA<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableA<'a> { - pub const VT_B: ::flatbuffers::VOffsetT = 4; + pub const VT_B: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "TableA" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableA { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableAArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableABuilder::new(_fbb); - if let Some(x) = args.b { builder.add_b(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableAT { - let b = self.b().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableAT { - b, + pub const fn get_fully_qualified_name() -> &'static str { + "TableA" } - } - #[inline] - pub fn b(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableA { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableAArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableABuilder::new(_fbb); + if let Some(x) = args.b { builder.add_b(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableAT { + let b = self.b().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableAT { + b, + } + } + + #[inline] + pub fn b(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} + } } impl ::flatbuffers::Verifiable for TableA<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? + .finish(); + Ok(()) + } } pub struct TableAArgs<'a> { @@ -75,444 +75,444 @@ pub struct TableAArgs<'a> { } impl<'a> Default for TableAArgs<'a> { - #[inline] - fn default() -> Self { - TableAArgs { - b: None, + #[inline] + fn default() -> Self { + TableAArgs { + b: None, + } } - } } pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> { - #[inline] - pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableABuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableABuilder { + 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 ::core::fmt::Debug for TableA<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableA"); - ds.field("b", &self.b()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableA"); + ds.field("b", &self.b()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableAT { - pub b: Option>, + pub b: Option>, } impl Default for TableAT { - fn default() -> Self { - Self { - b: None, + fn default() -> Self { + Self { + b: None, + } } - } } impl TableAT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let b = self.b.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableA::create(_fbb, &TableAArgs{ - b, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let b = self.b.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableA::create(_fbb, &TableAArgs{ + b, + }) + } } #[allow(unused_imports, dead_code)] pub mod my_game { - extern crate alloc; - - #[allow(unused_imports, dead_code)] - pub mod other_name_space { extern crate alloc; - #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] - pub const ENUM_MIN_FROM_INCLUDE: i64 = 0; + #[allow(unused_imports, dead_code)] + pub mod other_name_space { + extern crate alloc; - #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] - pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; + #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] + pub const ENUM_MIN_FROM_INCLUDE: i64 = 0; - #[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_FROM_INCLUDE: [FromInclude; 1] = [ - FromInclude::IncludeVal, - ]; + #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] + pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] - #[repr(transparent)] - pub struct FromInclude(pub i64); + #[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_FROM_INCLUDE: [FromInclude; 1] = [ + FromInclude::IncludeVal, + ]; - #[allow(non_upper_case_globals)] - impl FromInclude { - pub const IncludeVal: Self = Self(0); + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] + #[repr(transparent)] + pub struct FromInclude(pub i64); - pub const ENUM_MIN: i64 = 0; - pub const ENUM_MAX: i64 = 0; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::IncludeVal, - ]; + #[allow(non_upper_case_globals)] + impl FromInclude { + pub const IncludeVal: Self = Self(0); - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::IncludeVal => Some("IncludeVal"), - _ => None, - } - } - } + pub const ENUM_MIN: i64 = 0; + pub const ENUM_MAX: i64 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::IncludeVal, + ]; - impl ::core::fmt::Debug for FromInclude { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 FromInclude { - type Inner = Self; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } - } - - impl ::flatbuffers::Push for FromInclude { - type Output = FromInclude; - - #[inline] - unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; - } - } - - impl ::flatbuffers::EndianScalar for FromInclude { - type Scalar = i64; - - #[inline] - fn to_little_endian(self) -> i64 { - self.0.to_le() - } - - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i64) -> Self { - let b = i64::from_le(v); - Self(b) - } - } - - impl<'a> ::flatbuffers::Verifiable for FromInclude { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i64::run_verifier(v, pos) - } - } - - impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} - - // struct Unused, aligned to 4 - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq)] - pub struct Unused(pub [u8; 4]); - - impl Default for Unused { - fn default() -> Self { - Self([0; 4]) - } - } - - impl ::core::fmt::Debug for Unused { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Unused") - .field("a", &self.a()) - .finish() - } - } - - impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} - - impl<'a> ::flatbuffers::Follow<'a> for Unused { - type Inner = &'a Unused; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Unused>::follow(buf, loc) } - } - } - - impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { - type Inner = &'a Unused; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } - } - - impl<'b> ::flatbuffers::Push for Unused { - type Output = Unused; - - #[inline] - unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, ::size()) }; - dst.copy_from_slice(src); + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::IncludeVal => Some("IncludeVal"), + _ => None, + } + } } - #[inline] - fn alignment() -> ::flatbuffers::PushAlignment { - ::flatbuffers::PushAlignment::new(4) + impl ::core::fmt::Debug for FromInclude { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } + } } - } - impl<'a> ::flatbuffers::Verifiable for Unused { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } - } + impl<'a> ::flatbuffers::Follow<'a> for FromInclude { + type Inner = Self; - impl<'a> Unused { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: i32, - ) -> Self { - let mut s = Self([0; 4]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.Unused" - } - - pub fn a(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } - } - pub fn unpack(&self) -> UnusedT { - UnusedT { - a: self.a(), + impl ::flatbuffers::Push for FromInclude { + type Output = FromInclude; + + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + } } - } - } - #[derive(Debug, Clone, PartialEq, Default)] - pub struct UnusedT { - pub a: i32, - } + impl ::flatbuffers::EndianScalar for FromInclude { + type Scalar = i64; - impl UnusedT { - pub fn pack(&self) -> Unused { - Unused::new( - self.a, - ) - } - } + #[inline] + fn to_little_endian(self) -> i64 { + self.0.to_le() + } - pub enum TableBOffset {} - - #[derive(Copy, Clone, PartialEq)] - pub struct TableB<'a> { - pub _tab: ::flatbuffers::Table<'a>, - } - - impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { - type Inner = TableB<'a>; - - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } - } - - impl<'a> TableB<'a> { - pub const VT_A: ::flatbuffers::VOffsetT = 4; - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.TableB" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableB { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableBArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableBBuilder::new(_fbb); - if let Some(x) = args.a { builder.add_a(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableBT { - let a = self.a().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableBT { - a, + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i64) -> Self { + let b = i64::from_le(v); + Self(b) + } } - } - #[inline] - pub fn a(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} - } - } - - impl ::flatbuffers::Verifiable for TableB<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? - .finish(); - Ok(()) - } - } - - pub struct TableBArgs<'a> { - pub a: Option<::flatbuffers::WIPOffset>>, - } - - impl<'a> Default for TableBArgs<'a> { - #[inline] - fn default() -> Self { - TableBArgs { - a: None, + impl<'a> ::flatbuffers::Verifiable for FromInclude { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i64::run_verifier(v, pos) + } } - } - } - pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, - } + impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { - #[inline] - pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); - } + // struct Unused, aligned to 4 + #[repr(transparent)] + #[derive(Clone, Copy, PartialEq)] + pub struct Unused(pub [u8; 4]); - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableBBuilder { - fbb_: _fbb, - start_: start, + impl Default for Unused { + fn default() -> Self { + Self([0; 4]) + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } - } - - impl ::core::fmt::Debug for TableB<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableB"); - ds.field("a", &self.a()); - ds.finish() - } - } - - #[non_exhaustive] - #[derive(Debug, Clone, PartialEq)] - pub struct TableBT { - pub a: Option>, - } - - impl Default for TableBT { - fn default() -> Self { - Self { - a: None, + impl ::core::fmt::Debug for Unused { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Unused") + .field("a", &self.a()) + .finish() + } } - } - } - impl TableBT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let a = self.a.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableB::create(_fbb, &TableBArgs{ - a, - }) - } - } - } // pub mod OtherNameSpace + impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} + + impl<'a> ::flatbuffers::Follow<'a> for Unused { + type Inner = &'a Unused; + + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Unused>::follow(buf, loc) } + } + } + + impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { + type Inner = &'a Unused; + + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } + } + + impl<'b> ::flatbuffers::Push for Unused { + type Output = Unused; + + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, ::size()) }; + dst.copy_from_slice(src); + } + + #[inline] + fn alignment() -> ::flatbuffers::PushAlignment { + ::flatbuffers::PushAlignment::new(4) + } + } + + impl<'a> ::flatbuffers::Verifiable for Unused { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } + } + + impl<'a> Unused { + #[allow(clippy::too_many_arguments)] + pub fn new( + a: i32, + ) -> Self { + let mut s = Self([0; 4]); + s.set_a(a); + s + } + + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.Unused" + } + + pub fn a(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> UnusedT { + UnusedT { + a: self.a(), + } + } + } + + #[derive(Debug, Clone, PartialEq, Default)] + pub struct UnusedT { + pub a: i32, + } + + impl UnusedT { + pub fn pack(&self) -> Unused { + Unused::new( + self.a, + ) + } + } + + pub enum TableBOffset {} + + #[derive(Copy, Clone, PartialEq)] + pub struct TableB<'a> { + pub _tab: ::flatbuffers::Table<'a>, + } + + impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { + type Inner = TableB<'a>; + + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } + } + + impl<'a> TableB<'a> { + pub const VT_A: ::flatbuffers::VOffsetT = 4; + + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.TableB" + } + + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableB { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableBArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableBBuilder::new(_fbb); + if let Some(x) = args.a { builder.add_a(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableBT { + let a = self.a().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableBT { + a, + } + } + + #[inline] + pub fn a(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} + } + } + + impl ::flatbuffers::Verifiable for TableB<'_> { + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? + .finish(); + Ok(()) + } + } + + pub struct TableBArgs<'a> { + pub a: Option<::flatbuffers::WIPOffset>>, + } + + impl<'a> Default for TableBArgs<'a> { + #[inline] + fn default() -> Self { + TableBArgs { + a: None, + } + } + } + + pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + } + + impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { + #[inline] + pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableBBuilder { + 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 ::core::fmt::Debug for TableB<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableB"); + ds.field("a", &self.a()); + ds.finish() + } + } + + #[non_exhaustive] + #[derive(Debug, Clone, PartialEq)] + pub struct TableBT { + pub a: Option>, + } + + impl Default for TableBT { + fn default() -> Self { + Self { + a: None, + } + } + } + + impl TableBT { + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let a = self.a.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableB::create(_fbb, &TableBArgs{ + a, + }) + } + } + } // pub mod OtherNameSpace } // pub mod MyGame diff --git a/tests/keyword_test/keyword_test/abc_generated.rs b/tests/keyword_test/keyword_test/abc_generated.rs index a8da0581e..cac583257 100644 --- a/tests/keyword_test/keyword_test/abc_generated.rs +++ b/tests/keyword_test/keyword_test/abc_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_ABC: i32 = 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_ABC: [ABC; 3] = [ - ABC::void, - ABC::where_, - ABC::stackalloc, + ABC::void, + ABC::where_, + ABC::stackalloc, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub struct ABC(pub i32); #[allow(non_upper_case_globals)] impl ABC { - pub const void: Self = Self(0); - pub const where_: Self = Self(1); - pub const stackalloc: Self = Self(2); + pub const void: Self = Self(0); + pub const where_: Self = Self(1); + pub const stackalloc: Self = Self(2); - pub const ENUM_MIN: i32 = 0; - pub const ENUM_MAX: i32 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::void, - Self::where_, - Self::stackalloc, - ]; + pub const ENUM_MIN: i32 = 0; + pub const ENUM_MAX: i32 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::void, + Self::where_, + Self::stackalloc, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::void => Some("void"), - Self::where_ => Some("where_"), - Self::stackalloc => Some("stackalloc"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::void => Some("void"), + Self::where_ => Some("where_"), + Self::stackalloc => Some("stackalloc"), + _ => None, + } } - } } impl ::core::fmt::Debug for ABC { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 ABC { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for ABC { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for ABC { } impl ::flatbuffers::EndianScalar for ABC { - type Scalar = i32; + type Scalar = i32; - #[inline] - fn to_little_endian(self) -> i32 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i32 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i32) -> Self { - let b = i32::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i32) -> Self { + let b = i32::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for ABC { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i32::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i32::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for ABC {} diff --git a/tests/keyword_test/keyword_test/keywords_in_table_generated.rs b/tests/keyword_test/keyword_test/keywords_in_table_generated.rs index f8c050576..c8dc45612 100644 --- a/tests/keyword_test/keyword_test/keywords_in_table_generated.rs +++ b/tests/keyword_test/keyword_test/keywords_in_table_generated.rs @@ -7,105 +7,105 @@ pub enum KeywordsInTableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct KeywordsInTable<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for KeywordsInTable<'a> { - type Inner = KeywordsInTable<'a>; + type Inner = KeywordsInTable<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> KeywordsInTable<'a> { - pub const VT_IS: ::flatbuffers::VOffsetT = 4; - pub const VT_PRIVATE: ::flatbuffers::VOffsetT = 6; - pub const VT_TYPE_: ::flatbuffers::VOffsetT = 8; - pub const VT_DEFAULT: ::flatbuffers::VOffsetT = 10; + pub const VT_IS: ::flatbuffers::VOffsetT = 4; + pub const VT_PRIVATE: ::flatbuffers::VOffsetT = 6; + pub const VT_TYPE_: ::flatbuffers::VOffsetT = 8; + pub const VT_DEFAULT: ::flatbuffers::VOffsetT = 10; - pub const fn get_fully_qualified_name() -> &'static str { - "KeywordTest.KeywordsInTable" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - KeywordsInTable { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args KeywordsInTableArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = KeywordsInTableBuilder::new(_fbb); - builder.add_type_(args.type_); - builder.add_private(args.private); - builder.add_is(args.is); - builder.add_default(args.default); - builder.finish() - } - - pub fn unpack(&self) -> KeywordsInTableT { - let is = self.is(); - let private = self.private(); - let type_ = self.type_(); - let default = self.default(); - KeywordsInTableT { - is, - private, - type_, - default, + pub const fn get_fully_qualified_name() -> &'static str { + "KeywordTest.KeywordsInTable" } - } - #[inline] - pub fn is(&self) -> ABC { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(KeywordsInTable::VT_IS, Some(ABC::void)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + KeywordsInTable { _tab: table } + } - #[inline] - pub fn private(&self) -> public { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(KeywordsInTable::VT_PRIVATE, Some(public::NONE)).unwrap()} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args KeywordsInTableArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = KeywordsInTableBuilder::new(_fbb); + builder.add_type_(args.type_); + builder.add_private(args.private); + builder.add_is(args.is); + builder.add_default(args.default); + builder.finish() + } - #[inline] - pub fn type_(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(KeywordsInTable::VT_TYPE_, Some(0)).unwrap()} - } + pub fn unpack(&self) -> KeywordsInTableT { + let is = self.is(); + let private = self.private(); + let type_ = self.type_(); + let default = self.default(); + KeywordsInTableT { + is, + private, + type_, + default, + } + } - #[inline] - pub fn default(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(KeywordsInTable::VT_DEFAULT, Some(false)).unwrap()} - } + #[inline] + pub fn is(&self) -> ABC { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(KeywordsInTable::VT_IS, Some(ABC::void)).unwrap()} + } + + #[inline] + pub fn private(&self) -> public { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(KeywordsInTable::VT_PRIVATE, Some(public::NONE)).unwrap()} + } + + #[inline] + pub fn type_(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(KeywordsInTable::VT_TYPE_, Some(0)).unwrap()} + } + + #[inline] + pub fn default(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(KeywordsInTable::VT_DEFAULT, Some(false)).unwrap()} + } } impl ::flatbuffers::Verifiable for KeywordsInTable<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("is", Self::VT_IS, false)? - .visit_field::("private", Self::VT_PRIVATE, false)? - .visit_field::("type_", Self::VT_TYPE_, false)? - .visit_field::("default", Self::VT_DEFAULT, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("is", Self::VT_IS, false)? + .visit_field::("private", Self::VT_PRIVATE, false)? + .visit_field::("type_", Self::VT_TYPE_, false)? + .visit_field::("default", Self::VT_DEFAULT, false)? + .finish(); + Ok(()) + } } pub struct KeywordsInTableArgs { @@ -116,104 +116,104 @@ pub struct KeywordsInTableArgs { } impl<'a> Default for KeywordsInTableArgs { - #[inline] - fn default() -> Self { - KeywordsInTableArgs { - is: ABC::void, - private: public::NONE, - type_: 0, - default: false, + #[inline] + fn default() -> Self { + KeywordsInTableArgs { + is: ABC::void, + private: public::NONE, + type_: 0, + default: false, + } } - } } pub struct KeywordsInTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> KeywordsInTableBuilder<'a, 'b, A> { - #[inline] - pub fn add_is(&mut self, is: ABC) { - self.fbb_.push_slot::(KeywordsInTable::VT_IS, is, ABC::void); - } - - #[inline] - pub fn add_private(&mut self, private: public) { - self.fbb_.push_slot::(KeywordsInTable::VT_PRIVATE, private, public::NONE); - } - - #[inline] - pub fn add_type_(&mut self, type_: i32) { - self.fbb_.push_slot::(KeywordsInTable::VT_TYPE_, type_, 0); - } - - #[inline] - pub fn add_default(&mut self, default: bool) { - self.fbb_.push_slot::(KeywordsInTable::VT_DEFAULT, default, false); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> KeywordsInTableBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - KeywordsInTableBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_is(&mut self, is: ABC) { + self.fbb_.push_slot::(KeywordsInTable::VT_IS, is, ABC::void); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_private(&mut self, private: public) { + self.fbb_.push_slot::(KeywordsInTable::VT_PRIVATE, private, public::NONE); + } + + #[inline] + pub fn add_type_(&mut self, type_: i32) { + self.fbb_.push_slot::(KeywordsInTable::VT_TYPE_, type_, 0); + } + + #[inline] + pub fn add_default(&mut self, default: bool) { + self.fbb_.push_slot::(KeywordsInTable::VT_DEFAULT, default, false); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> KeywordsInTableBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + KeywordsInTableBuilder { + 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 ::core::fmt::Debug for KeywordsInTable<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("KeywordsInTable"); - ds.field("is", &self.is()); - ds.field("private", &self.private()); - ds.field("type_", &self.type_()); - ds.field("default", &self.default()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("KeywordsInTable"); + ds.field("is", &self.is()); + ds.field("private", &self.private()); + ds.field("type_", &self.type_()); + ds.field("default", &self.default()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct KeywordsInTableT { - pub is: ABC, - pub private: public, - pub type_: i32, - pub default: bool, + pub is: ABC, + pub private: public, + pub type_: i32, + pub default: bool, } impl Default for KeywordsInTableT { - fn default() -> Self { - Self { - is: ABC::void, - private: public::NONE, - type_: 0, - default: false, + fn default() -> Self { + Self { + is: ABC::void, + private: public::NONE, + type_: 0, + default: false, + } } - } } impl KeywordsInTableT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let is = self.is; - let private = self.private; - let type_ = self.type_; - let default = self.default; - KeywordsInTable::create(_fbb, &KeywordsInTableArgs{ - is, - private, - type_, - default, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let is = self.is; + let private = self.private; + let type_ = self.type_; + let default = self.default; + KeywordsInTable::create(_fbb, &KeywordsInTableArgs{ + is, + private, + type_, + default, + }) + } } diff --git a/tests/keyword_test/keyword_test/keywords_in_union_generated.rs b/tests/keyword_test/keyword_test/keywords_in_union_generated.rs index fe3114172..5ac7f3ecd 100644 --- a/tests/keyword_test/keyword_test/keywords_in_union_generated.rs +++ b/tests/keyword_test/keyword_test/keywords_in_union_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_KEYWORDS_IN_UNION: u8 = 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_KEYWORDS_IN_UNION: [KeywordsInUnion; 3] = [ - KeywordsInUnion::NONE, - KeywordsInUnion::static_, - KeywordsInUnion::internal, + KeywordsInUnion::NONE, + KeywordsInUnion::static_, + KeywordsInUnion::internal, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub struct KeywordsInUnion(pub u8); #[allow(non_upper_case_globals)] impl KeywordsInUnion { - pub const NONE: Self = Self(0); - pub const static_: Self = Self(1); - pub const internal: Self = Self(2); + pub const NONE: Self = Self(0); + pub const static_: Self = Self(1); + pub const internal: Self = Self(2); - pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::static_, - Self::internal, - ]; + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + Self::static_, + Self::internal, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - Self::static_ => Some("static_"), - Self::internal => Some("internal"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + Self::static_ => Some("static_"), + Self::internal => Some("internal"), + _ => None, + } } - } } impl ::core::fmt::Debug for KeywordsInUnion { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 KeywordsInUnion { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for KeywordsInUnion { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for KeywordsInUnion { } impl ::flatbuffers::EndianScalar for KeywordsInUnion { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for KeywordsInUnion { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for KeywordsInUnion {} @@ -108,80 +108,80 @@ pub struct KeywordsInUnionUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum KeywordsInUnionT { - NONE, - Static_(alloc::boxed::Box), - Internal(alloc::boxed::Box), + NONE, + Static_(alloc::boxed::Box), + Internal(alloc::boxed::Box), } impl Default for KeywordsInUnionT { - fn default() -> Self { - Self::NONE - } + fn default() -> Self { + Self::NONE + } } impl KeywordsInUnionT { - pub fn keywords_in_union_type(&self) -> KeywordsInUnion { - match self { - Self::NONE => KeywordsInUnion::NONE, - Self::Static_(_) => KeywordsInUnion::static_, - Self::Internal(_) => KeywordsInUnion::internal, + pub fn keywords_in_union_type(&self) -> KeywordsInUnion { + match self { + Self::NONE => KeywordsInUnion::NONE, + Self::Static_(_) => KeywordsInUnion::static_, + Self::Internal(_) => KeywordsInUnion::internal, + } } - } - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - match self { - Self::NONE => None, - Self::Static_(v) => Some(v.pack(fbb).as_union_value()), - Self::Internal(v) => Some(v.pack(fbb).as_union_value()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + match self { + Self::NONE => None, + Self::Static_(v) => Some(v.pack(fbb).as_union_value()), + Self::Internal(v) => Some(v.pack(fbb).as_union_value()), + } } - } - /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE. - pub fn take_static_(&mut self) -> Option> { - if let Self::Static_(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::Static_(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE. + pub fn take_static_(&mut self) -> Option> { + if let Self::Static_(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::Static_(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } } - } - /// If the union variant matches, return a reference to the KeywordsInTableT. - pub fn as_static_(&self) -> Option<&KeywordsInTableT> { - if let Self::Static_(v) = self { Some(v.as_ref()) } else { None } - } - - /// If the union variant matches, return a mutable reference to the KeywordsInTableT. - pub fn as_static__mut(&mut self) -> Option<&mut KeywordsInTableT> { - if let Self::Static_(v) = self { Some(v.as_mut()) } else { None } - } - - /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE. - pub fn take_internal(&mut self) -> Option> { - if let Self::Internal(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::Internal(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return a reference to the KeywordsInTableT. + pub fn as_static_(&self) -> Option<&KeywordsInTableT> { + if let Self::Static_(v) = self { Some(v.as_ref()) } else { None } } - } - /// If the union variant matches, return a reference to the KeywordsInTableT. - pub fn as_internal(&self) -> Option<&KeywordsInTableT> { - if let Self::Internal(v) = self { Some(v.as_ref()) } else { None } - } + /// If the union variant matches, return a mutable reference to the KeywordsInTableT. + pub fn as_static__mut(&mut self) -> Option<&mut KeywordsInTableT> { + if let Self::Static_(v) = self { Some(v.as_mut()) } else { None } + } - /// If the union variant matches, return a mutable reference to the KeywordsInTableT. - pub fn as_internal_mut(&mut self) -> Option<&mut KeywordsInTableT> { - if let Self::Internal(v) = self { Some(v.as_mut()) } else { None } - } + /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE. + pub fn take_internal(&mut self) -> Option> { + if let Self::Internal(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::Internal(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } + } + + /// If the union variant matches, return a reference to the KeywordsInTableT. + pub fn as_internal(&self) -> Option<&KeywordsInTableT> { + if let Self::Internal(v) = self { Some(v.as_ref()) } else { None } + } + + /// If the union variant matches, return a mutable reference to the KeywordsInTableT. + pub fn as_internal_mut(&mut self) -> Option<&mut KeywordsInTableT> { + if let Self::Internal(v) = self { Some(v.as_mut()) } else { None } + } } diff --git a/tests/keyword_test/keyword_test/public_generated.rs b/tests/keyword_test/keyword_test/public_generated.rs index a4a449e95..0799d68b2 100644 --- a/tests/keyword_test/keyword_test/public_generated.rs +++ b/tests/keyword_test/keyword_test/public_generated.rs @@ -12,7 +12,7 @@ pub const ENUM_MAX_PUBLIC: i32 = 0; #[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_PUBLIC: [public; 1] = [ - public::NONE, + public::NONE, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -21,41 +21,41 @@ pub struct public(pub i32); #[allow(non_upper_case_globals)] impl public { - pub const NONE: Self = Self(0); + pub const NONE: Self = Self(0); - pub const ENUM_MIN: i32 = 0; - pub const ENUM_MAX: i32 = 0; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - ]; + pub const ENUM_MIN: i32 = 0; + pub const ENUM_MAX: i32 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + _ => None, + } } - } } impl ::core::fmt::Debug for public { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 public { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for public { @@ -68,28 +68,28 @@ impl ::flatbuffers::Push for public { } impl ::flatbuffers::EndianScalar for public { - type Scalar = i32; + type Scalar = i32; - #[inline] - fn to_little_endian(self) -> i32 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i32 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i32) -> Self { - let b = i32::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i32) -> Self { + let b = i32::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for public { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i32::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i32::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for public {} diff --git a/tests/keyword_test/keyword_test/table_2_generated.rs b/tests/keyword_test/keyword_test/table_2_generated.rs index 4436a0f07..219ba405e 100644 --- a/tests/keyword_test/keyword_test/table_2_generated.rs +++ b/tests/keyword_test/keyword_test/table_2_generated.rs @@ -7,125 +7,125 @@ pub enum Table2Offset {} #[derive(Copy, Clone, PartialEq)] pub struct Table2<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Table2<'a> { - type Inner = Table2<'a>; + type Inner = Table2<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Table2<'a> { - pub const VT_TYPE_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_TYPE_: ::flatbuffers::VOffsetT = 6; + pub const VT_TYPE_TYPE: ::flatbuffers::VOffsetT = 4; + pub const VT_TYPE_: ::flatbuffers::VOffsetT = 6; - pub const fn get_fully_qualified_name() -> &'static str { - "KeywordTest.Table2" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - Table2 { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args Table2Args - ) -> ::flatbuffers::WIPOffset> { - let mut builder = Table2Builder::new(_fbb); - if let Some(x) = args.type_ { builder.add_type_(x); } - builder.add_type_type(args.type_type); - builder.finish() - } - - pub fn unpack(&self) -> Table2T { - let type_ = match self.type_type() { - KeywordsInUnion::NONE => KeywordsInUnionT::NONE, - KeywordsInUnion::static_ => KeywordsInUnionT::Static_(alloc::boxed::Box::new( - self.type__as_static_() - .expect("Invalid union table, expected `KeywordsInUnion::static_`.") - .unpack() - )), - KeywordsInUnion::internal => KeywordsInUnionT::Internal(alloc::boxed::Box::new( - self.type__as_internal() - .expect("Invalid union table, expected `KeywordsInUnion::internal`.") - .unpack() - )), - _ => KeywordsInUnionT::NONE, - }; - Table2T { - type_, + pub const fn get_fully_qualified_name() -> &'static str { + "KeywordTest.Table2" } - } - #[inline] - pub fn type_type(&self) -> KeywordsInUnion { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Table2::VT_TYPE_TYPE, Some(KeywordsInUnion::NONE)).unwrap()} - } - - #[inline] - pub fn type_(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Table2::VT_TYPE_, None)} - } - - #[inline] - #[allow(non_snake_case)] - pub fn type__as_static_(&self) -> Option> { - if self.type_type() == KeywordsInUnion::static_ { - self.type_().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { KeywordsInTable::init_from_table(t) } - }) - } else { - None + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Table2 { _tab: table } } - } - #[inline] - #[allow(non_snake_case)] - pub fn type__as_internal(&self) -> Option> { - if self.type_type() == KeywordsInUnion::internal { - self.type_().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { KeywordsInTable::init_from_table(t) } - }) - } else { - None + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args Table2Args + ) -> ::flatbuffers::WIPOffset> { + let mut builder = Table2Builder::new(_fbb); + if let Some(x) = args.type_ { builder.add_type_(x); } + builder.add_type_type(args.type_type); + builder.finish() + } + + pub fn unpack(&self) -> Table2T { + let type_ = match self.type_type() { + KeywordsInUnion::NONE => KeywordsInUnionT::NONE, + KeywordsInUnion::static_ => KeywordsInUnionT::Static_(alloc::boxed::Box::new( + self.type__as_static_() + .expect("Invalid union table, expected `KeywordsInUnion::static_`.") + .unpack() + )), + KeywordsInUnion::internal => KeywordsInUnionT::Internal(alloc::boxed::Box::new( + self.type__as_internal() + .expect("Invalid union table, expected `KeywordsInUnion::internal`.") + .unpack() + )), + _ => KeywordsInUnionT::NONE, + }; + Table2T { + type_, + } + } + + #[inline] + pub fn type_type(&self) -> KeywordsInUnion { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Table2::VT_TYPE_TYPE, Some(KeywordsInUnion::NONE)).unwrap()} + } + + #[inline] + pub fn type_(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Table2::VT_TYPE_, None)} + } + + #[inline] + #[allow(non_snake_case)] + pub fn type__as_static_(&self) -> Option> { + if self.type_type() == KeywordsInUnion::static_ { + self.type_().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { KeywordsInTable::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn type__as_internal(&self) -> Option> { + if self.type_type() == KeywordsInUnion::internal { + self.type_().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { KeywordsInTable::init_from_table(t) } + }) + } else { + None + } } - } } impl ::flatbuffers::Verifiable for Table2<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_union::("type_type", Self::VT_TYPE_TYPE, "type_", Self::VT_TYPE_, false, |key, v, pos| { - match key { - KeywordsInUnion::static_ => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("KeywordsInUnion::static_", pos), - KeywordsInUnion::internal => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("KeywordsInUnion::internal", pos), - _ => Ok(()), - } - })? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_union::("type_type", Self::VT_TYPE_TYPE, "type_", Self::VT_TYPE_, false, |key, v, pos| { + match key { + KeywordsInUnion::static_ => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("KeywordsInUnion::static_", pos), + KeywordsInUnion::internal => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("KeywordsInUnion::internal", pos), + _ => Ok(()), + } + })? + .finish(); + Ok(()) + } } pub struct Table2Args { @@ -134,99 +134,99 @@ pub struct Table2Args { } impl<'a> Default for Table2Args { - #[inline] - fn default() -> Self { - Table2Args { - type_type: KeywordsInUnion::NONE, - type_: None, + #[inline] + fn default() -> Self { + Table2Args { + type_type: KeywordsInUnion::NONE, + type_: None, + } } - } } pub struct Table2Builder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> Table2Builder<'a, 'b, A> { - #[inline] - pub fn add_type_type(&mut self, type_type: KeywordsInUnion) { - self.fbb_.push_slot::(Table2::VT_TYPE_TYPE, type_type, KeywordsInUnion::NONE); - } - - #[inline] - pub fn add_type_(&mut self, type_: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Table2::VT_TYPE_, type_); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> Table2Builder<'a, 'b, A> { - let start = _fbb.start_table(); - Table2Builder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_type_type(&mut self, type_type: KeywordsInUnion) { + self.fbb_.push_slot::(Table2::VT_TYPE_TYPE, type_type, KeywordsInUnion::NONE); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_type_(&mut self, type_: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Table2::VT_TYPE_, type_); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> Table2Builder<'a, 'b, A> { + let start = _fbb.start_table(); + Table2Builder { + 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 ::core::fmt::Debug for Table2<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Table2"); - ds.field("type_type", &self.type_type()); - match self.type_type() { - KeywordsInUnion::static_ => { - if let Some(x) = self.type__as_static_() { - ds.field("type_", &x) - } else { - ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - KeywordsInUnion::internal => { - if let Some(x) = self.type__as_internal() { - ds.field("type_", &x) - } else { - ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("type_", &x) - }, - }; - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Table2"); + ds.field("type_type", &self.type_type()); + match self.type_type() { + KeywordsInUnion::static_ => { + if let Some(x) = self.type__as_static_() { + ds.field("type_", &x) + } else { + ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + KeywordsInUnion::internal => { + if let Some(x) = self.type__as_internal() { + ds.field("type_", &x) + } else { + ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + _ => { + let x: Option<()> = None; + ds.field("type_", &x) + }, + }; + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct Table2T { - pub type_: KeywordsInUnionT, + pub type_: KeywordsInUnionT, } impl Default for Table2T { - fn default() -> Self { - Self { - type_: KeywordsInUnionT::NONE, + fn default() -> Self { + Self { + type_: KeywordsInUnionT::NONE, + } } - } } impl Table2T { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let type_type = self.type_.keywords_in_union_type(); - let type_ = self.type_.pack(_fbb); - Table2::create(_fbb, &Table2Args{ - type_type, - type_, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let type_type = self.type_.keywords_in_union_type(); + let type_ = self.type_.pack(_fbb); + Table2::create(_fbb, &Table2Args{ + type_type, + type_, + }) + } } diff --git a/tests/keyword_test/mod.rs b/tests/keyword_test/mod.rs index 56f68c40d..b0b522ecd 100644 --- a/tests/keyword_test/mod.rs +++ b/tests/keyword_test/mod.rs @@ -1,15 +1,15 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod keyword_test { - use super::*; - mod abc_generated; - pub use self::abc_generated::*; - mod public_generated; - pub use self::public_generated::*; - mod keywords_in_union_generated; - pub use self::keywords_in_union_generated::*; - mod keywords_in_table_generated; - pub use self::keywords_in_table_generated::*; - mod table_2_generated; - pub use self::table_2_generated::*; + use super::*; + mod abc_generated; + pub use self::abc_generated::*; + mod public_generated; + pub use self::public_generated::*; + mod keywords_in_union_generated; + pub use self::keywords_in_union_generated::*; + mod keywords_in_table_generated; + pub use self::keywords_in_table_generated::*; + mod table_2_generated; + pub use self::table_2_generated::*; } // keyword_test diff --git a/tests/monster_test/mod.rs b/tests/monster_test/mod.rs index 7f1fab136..27af0f287 100644 --- a/tests/monster_test/mod.rs +++ b/tests/monster_test/mod.rs @@ -1,58 +1,58 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod my_game { - use super::*; - pub mod example { use super::*; - mod color_generated; - pub use self::color_generated::*; - mod race_generated; - pub use self::race_generated::*; - mod long_enum_generated; - pub use self::long_enum_generated::*; - mod any_generated; - pub use self::any_generated::*; - mod any_unique_aliases_generated; - pub use self::any_unique_aliases_generated::*; - mod any_ambiguous_aliases_generated; - pub use self::any_ambiguous_aliases_generated::*; - mod test_generated; - pub use self::test_generated::*; - mod test_simple_table_with_enum_generated; - pub use self::test_simple_table_with_enum_generated::*; - mod vec_3_generated; - pub use self::vec_3_generated::*; - mod ability_generated; - pub use self::ability_generated::*; - mod struct_of_structs_generated; - pub use self::struct_of_structs_generated::*; - mod struct_of_structs_of_structs_generated; - pub use self::struct_of_structs_of_structs_generated::*; - mod stat_generated; - pub use self::stat_generated::*; - mod referrable_generated; - pub use self::referrable_generated::*; - mod monster_generated; - pub use self::monster_generated::*; - mod type_aliases_generated; - pub use self::type_aliases_generated::*; - } // example - pub mod example_2 { - use super::*; - mod monster_generated; - pub use self::monster_generated::*; - } // example_2 - pub mod other_name_space { - use super::*; - mod from_include_generated; - pub use self::from_include_generated::*; - mod unused_generated; - pub use self::unused_generated::*; - mod table_b_generated; - pub use self::table_b_generated::*; - } // other_name_space - mod in_parent_namespace_generated; - pub use self::in_parent_namespace_generated::*; + pub mod example { + use super::*; + mod color_generated; + pub use self::color_generated::*; + mod race_generated; + pub use self::race_generated::*; + mod long_enum_generated; + pub use self::long_enum_generated::*; + mod any_generated; + pub use self::any_generated::*; + mod any_unique_aliases_generated; + pub use self::any_unique_aliases_generated::*; + mod any_ambiguous_aliases_generated; + pub use self::any_ambiguous_aliases_generated::*; + mod test_generated; + pub use self::test_generated::*; + mod test_simple_table_with_enum_generated; + pub use self::test_simple_table_with_enum_generated::*; + mod vec_3_generated; + pub use self::vec_3_generated::*; + mod ability_generated; + pub use self::ability_generated::*; + mod struct_of_structs_generated; + pub use self::struct_of_structs_generated::*; + mod struct_of_structs_of_structs_generated; + pub use self::struct_of_structs_of_structs_generated::*; + mod stat_generated; + pub use self::stat_generated::*; + mod referrable_generated; + pub use self::referrable_generated::*; + mod monster_generated; + pub use self::monster_generated::*; + mod type_aliases_generated; + pub use self::type_aliases_generated::*; + } // example + pub mod example_2 { + use super::*; + mod monster_generated; + pub use self::monster_generated::*; + } // example_2 + pub mod other_name_space { + use super::*; + mod from_include_generated; + pub use self::from_include_generated::*; + mod unused_generated; + pub use self::unused_generated::*; + mod table_b_generated; + pub use self::table_b_generated::*; + } // other_name_space + mod in_parent_namespace_generated; + pub use self::in_parent_namespace_generated::*; } // my_game mod table_a_generated; pub use self::table_a_generated::*; diff --git a/tests/monster_test/my_game/example/ability_generated.rs b/tests/monster_test/my_game/example/ability_generated.rs index 6cd6f901f..7dd38491a 100644 --- a/tests/monster_test/my_game/example/ability_generated.rs +++ b/tests/monster_test/my_game/example/ability_generated.rs @@ -8,39 +8,39 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Ability(pub [u8; 8]); -impl Default for Ability { - fn default() -> Self { - Self([0; 8]) - } +impl Default for Ability { + fn default() -> Self { + Self([0; 8]) + } } impl ::core::fmt::Debug for Ability { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Ability") - .field("id", &self.id()) - .field("distance", &self.distance()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Ability") + .field("id", &self.id()) + .field("distance", &self.distance()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Ability {} impl<'a> ::flatbuffers::Follow<'a> for Ability { - type Inner = &'a Ability; + type Inner = &'a Ability; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Ability>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Ability>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Ability { - type Inner = &'a Ability; + type Inner = &'a Ability; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Ability { @@ -59,118 +59,118 @@ impl<'b> ::flatbuffers::Push for Ability { } impl<'a> ::flatbuffers::Verifiable for Ability { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_id(&mut self, x: u32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[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 } - } - - #[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) -> ::core::cmp::Ordering { - let key = self.id(); - key.cmp(&val) - } - pub fn distance(&self) -> u32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[4..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_distance(&mut self, x: u32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[4..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Ability" } - } - pub fn unpack(&self) -> AbilityT { - AbilityT { - id: self.id(), - distance: self.distance(), + pub fn id(&self) -> u32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_id(&mut self, x: u32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + + #[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) -> ::core::cmp::Ordering { + let key = self.id(); + key.cmp(&val) + } + pub fn distance(&self) -> u32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[4..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_distance(&mut self, x: u32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[4..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + 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, + pub id: u32, + pub distance: u32, } impl AbilityT { - pub fn pack(&self) -> Ability { - Ability::new( - self.id, - self.distance, - ) - } + pub fn pack(&self) -> Ability { + Ability::new( + self.id, + self.distance, + ) + } } diff --git a/tests/monster_test/my_game/example/any_ambiguous_aliases_generated.rs b/tests/monster_test/my_game/example/any_ambiguous_aliases_generated.rs index 1363d0e37..0501ade17 100644 --- a/tests/monster_test/my_game/example/any_ambiguous_aliases_generated.rs +++ b/tests/monster_test/my_game/example/any_ambiguous_aliases_generated.rs @@ -12,10 +12,10 @@ 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, + AnyAmbiguousAliases::NONE, + AnyAmbiguousAliases::M1, + AnyAmbiguousAliases::M2, + AnyAmbiguousAliases::M3, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -24,50 +24,50 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for AnyAmbiguousAliases { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -80,28 +80,28 @@ impl ::flatbuffers::Push for AnyAmbiguousAliases { } impl ::flatbuffers::EndianScalar for AnyAmbiguousAliases { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for AnyAmbiguousAliases { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for AnyAmbiguousAliases {} @@ -112,107 +112,107 @@ pub struct AnyAmbiguousAliasesUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyAmbiguousAliasesT { - NONE, - M1(alloc::boxed::Box), - M2(alloc::boxed::Box), - M3(alloc::boxed::Box), + NONE, + M1(alloc::boxed::Box), + M2(alloc::boxed::Box), + M3(alloc::boxed::Box), } impl Default for AnyAmbiguousAliasesT { - fn default() -> Self { - Self::NONE - } + 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 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<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - 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()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M1(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// 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 = ::core::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 = ::core::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_m1(&self) -> Option<&MonsterT> { + if let Self::M1(v) = self { Some(v.as_ref()) } 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M3(w) = v { - Some(w) - } else { - unreachable!() - } - } 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 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 the owned MonsterT, setting the union to NONE. + pub fn take_m2(&mut self) -> Option> { + if let Self::M2(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::M2(w) = v { + Some(w) + } else { + unreachable!() + } + } 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 } - } + /// 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 = ::core::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 } + } } diff --git a/tests/monster_test/my_game/example/any_generated.rs b/tests/monster_test/my_game/example/any_generated.rs index 268d316f6..106b029aa 100644 --- a/tests/monster_test/my_game/example/any_generated.rs +++ b/tests/monster_test/my_game/example/any_generated.rs @@ -12,10 +12,10 @@ 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, + Any::NONE, + Any::Monster, + Any::TestSimpleTableWithEnum, + Any::MyGame_Example2_Monster, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -24,50 +24,50 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for Any { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -80,28 +80,28 @@ impl ::flatbuffers::Push for Any { } impl ::flatbuffers::EndianScalar for Any { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for Any { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Any {} @@ -112,107 +112,107 @@ pub struct AnyUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyT { - NONE, - Monster(alloc::boxed::Box), - TestSimpleTableWithEnum(alloc::boxed::Box), - MyGameExample2Monster(alloc::boxed::Box), + NONE, + Monster(alloc::boxed::Box), + TestSimpleTableWithEnum(alloc::boxed::Box), + MyGameExample2Monster(alloc::boxed::Box), } impl Default for AnyT { - fn default() -> Self { - Self::NONE - } + 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 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<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - 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()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + 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 = ::core::mem::replace(self, Self::NONE); - if let Self::Monster(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// 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 = ::core::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 = ::core::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 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 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 = ::core::mem::replace(self, Self::NONE); - if let Self::MyGameExample2Monster(w) = v { - Some(w) - } else { - unreachable!() - } - } 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 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 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 = ::core::mem::replace(self, Self::NONE); + if let Self::TestSimpleTableWithEnum(w) = v { + Some(w) + } else { + unreachable!() + } + } 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 } - } + /// 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 = ::core::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 } + } } diff --git a/tests/monster_test/my_game/example/any_unique_aliases_generated.rs b/tests/monster_test/my_game/example/any_unique_aliases_generated.rs index f4d8592ba..8abf5c64b 100644 --- a/tests/monster_test/my_game/example/any_unique_aliases_generated.rs +++ b/tests/monster_test/my_game/example/any_unique_aliases_generated.rs @@ -12,10 +12,10 @@ 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, + AnyUniqueAliases::NONE, + AnyUniqueAliases::M, + AnyUniqueAliases::TS, + AnyUniqueAliases::M2, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -24,50 +24,50 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for AnyUniqueAliases { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -80,28 +80,28 @@ impl ::flatbuffers::Push for AnyUniqueAliases { } impl ::flatbuffers::EndianScalar for AnyUniqueAliases { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for AnyUniqueAliases { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for AnyUniqueAliases {} @@ -112,107 +112,107 @@ pub struct AnyUniqueAliasesUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyUniqueAliasesT { - NONE, - M(alloc::boxed::Box), - TS(alloc::boxed::Box), - M2(alloc::boxed::Box), + NONE, + M(alloc::boxed::Box), + TS(alloc::boxed::Box), + M2(alloc::boxed::Box), } impl Default for AnyUniqueAliasesT { - fn default() -> Self { - Self::NONE - } + 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 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<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - 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()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// 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 = ::core::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 = ::core::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 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 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M2(w) = v { - Some(w) - } else { - unreachable!() - } - } 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 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 the owned TestSimpleTableWithEnumT, setting the union to NONE. + pub fn take_ts(&mut self) -> Option> { + if let Self::TS(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::TS(w) = v { + Some(w) + } else { + unreachable!() + } + } 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 } - } + /// 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 = ::core::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 } + } } diff --git a/tests/monster_test/my_game/example/color_generated.rs b/tests/monster_test/my_game/example/color_generated.rs index c4b584210..ca3886bba 100644 --- a/tests/monster_test/my_game/example/color_generated.rs +++ b/tests/monster_test/my_game/example/color_generated.rs @@ -5,30 +5,30 @@ use super::*; #[allow(non_upper_case_globals)] mod bitflags_color { - ::flatbuffers::bitflags::bitflags! { - /// Composite components of Monster color. - #[derive(Default, Debug, Clone, Copy, PartialEq)] - 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; + ::flatbuffers::bitflags::bitflags! { + /// Composite components of Monster color. + #[derive(Default, Debug, Clone, Copy, PartialEq)] + 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; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self::from_bits_retain(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self::from_bits_retain(b) + } } impl ::flatbuffers::Push for Color { @@ -41,28 +41,28 @@ impl ::flatbuffers::Push for Color { } impl ::flatbuffers::EndianScalar for Color { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.bits().to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.bits().to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self::from_bits_retain(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self::from_bits_retain(b) + } } impl<'a> ::flatbuffers::Verifiable for Color { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Color {} diff --git a/tests/monster_test/my_game/example/long_enum_generated.rs b/tests/monster_test/my_game/example/long_enum_generated.rs index b690f44c8..7cac7700f 100644 --- a/tests/monster_test/my_game/example/long_enum_generated.rs +++ b/tests/monster_test/my_game/example/long_enum_generated.rs @@ -5,26 +5,26 @@ use super::*; #[allow(non_upper_case_globals)] mod bitflags_long_enum { - ::flatbuffers::bitflags::bitflags! { - #[derive(Default, Debug, Clone, Copy, PartialEq)] - pub struct LongEnum: u64 { - const LongOne = 2; - const LongTwo = 4; - const LongBig = 1099511627776; + ::flatbuffers::bitflags::bitflags! { + #[derive(Default, Debug, Clone, Copy, PartialEq)] + pub struct LongEnum: u64 { + const LongOne = 2; + const LongTwo = 4; + const LongBig = 1099511627776; + } } - } } pub use self::bitflags_long_enum::LongEnum; impl<'a> ::flatbuffers::Follow<'a> for LongEnum { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self::from_bits_retain(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self::from_bits_retain(b) + } } impl ::flatbuffers::Push for LongEnum { @@ -37,28 +37,28 @@ impl ::flatbuffers::Push for LongEnum { } impl ::flatbuffers::EndianScalar for LongEnum { - type Scalar = u64; + type Scalar = u64; - #[inline] - fn to_little_endian(self) -> u64 { - self.bits().to_le() - } + #[inline] + fn to_little_endian(self) -> u64 { + self.bits().to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u64) -> Self { - let b = u64::from_le(v); - Self::from_bits_retain(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u64) -> Self { + let b = u64::from_le(v); + Self::from_bits_retain(b) + } } impl<'a> ::flatbuffers::Verifiable for LongEnum { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u64::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u64::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for LongEnum {} diff --git a/tests/monster_test/my_game/example/monster_generated.rs b/tests/monster_test/my_game/example/monster_generated.rs index 34aaac631..d860e0613 100644 --- a/tests/monster_test/my_game/example/monster_generated.rs +++ b/tests/monster_test/my_game/example/monster_generated.rs @@ -8,1133 +8,1133 @@ pub enum MonsterOffset {} /// an example documentation comment: "monster object" #[derive(Copy, Clone, PartialEq)] pub struct Monster<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> { - type Inner = Monster<'a>; + type Inner = Monster<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Monster<'a> { - 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; - pub const VT_NATIVE_INLINE: ::flatbuffers::VOffsetT = 106; - pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: ::flatbuffers::VOffsetT = 108; - pub const VT_LONG_ENUM_NORMAL_DEFAULT: ::flatbuffers::VOffsetT = 110; - pub const VT_NAN_DEFAULT: ::flatbuffers::VOffsetT = 112; - pub const VT_INF_DEFAULT: ::flatbuffers::VOffsetT = 114; - pub const VT_POSITIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 116; - pub const VT_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 118; - pub const VT_POSITIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 120; - pub const VT_NEGATIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 122; - pub const VT_NEGATIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 124; - pub const VT_DOUBLE_INF_DEFAULT: ::flatbuffers::VOffsetT = 126; + 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; + pub const VT_NATIVE_INLINE: ::flatbuffers::VOffsetT = 106; + pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: ::flatbuffers::VOffsetT = 108; + pub const VT_LONG_ENUM_NORMAL_DEFAULT: ::flatbuffers::VOffsetT = 110; + pub const VT_NAN_DEFAULT: ::flatbuffers::VOffsetT = 112; + pub const VT_INF_DEFAULT: ::flatbuffers::VOffsetT = 114; + pub const VT_POSITIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 116; + pub const VT_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 118; + pub const VT_POSITIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 120; + pub const VT_NEGATIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 122; + pub const VT_NEGATIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 124; + pub const VT_DOUBLE_INF_DEFAULT: ::flatbuffers::VOffsetT = 126; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.Monster" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args MonsterArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = MonsterBuilder::new(_fbb); - builder.add_double_inf_default(args.double_inf_default); - builder.add_long_enum_normal_default(args.long_enum_normal_default); - builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default); - 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); - builder.add_negative_infinity_default(args.negative_infinity_default); - builder.add_negative_inf_default(args.negative_inf_default); - builder.add_positive_infinity_default(args.positive_infinity_default); - builder.add_infinity_default(args.infinity_default); - builder.add_positive_inf_default(args.positive_inf_default); - builder.add_inf_default(args.inf_default); - builder.add_nan_default(args.nan_default); - if let Some(x) = args.native_inline { builder.add_native_inline(x); } - 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(); - alloc::string::ToString::to_string(x) - }; - let inventory = self.inventory().map(|x| { - x.into_iter().collect() - }); - let color = self.color(); - let test = match self.test_type() { - Any::NONE => AnyT::NONE, - Any::Monster => AnyT::Monster(alloc::boxed::Box::new( - self.test_as_monster() - .expect("Invalid union table, expected `Any::Monster`.") - .unpack() - )), - Any::TestSimpleTableWithEnum => AnyT::TestSimpleTableWithEnum(alloc::boxed::Box::new( - self.test_as_test_simple_table_with_enum() - .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`.") - .unpack() - )), - Any::MyGame_Example2_Monster => AnyT::MyGameExample2Monster(alloc::boxed::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| alloc::string::ToString::to_string(s)).collect() - }); - let testarrayoftables = self.testarrayoftables().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - let enemy = self.enemy().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - let testnestedflatbuffer = self.testnestedflatbuffer().map(|x| { - x.into_iter().collect() - }); - let testempty = self.testempty().map(|x| { - alloc::boxed::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.into_iter().collect() - }); - let testf = self.testf(); - let testf2 = self.testf2(); - let testf3 = self.testf3(); - let testarrayofstring2 = self.testarrayofstring2().map(|x| { - x.iter().map(|s| alloc::string::ToString::to_string(s)).collect() - }); - let testarrayofsortedstruct = self.testarrayofsortedstruct().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - let flex = self.flex().map(|x| { - x.into_iter().collect() - }); - 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| { - alloc::boxed::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(alloc::boxed::Box::new( - self.any_unique_as_m() - .expect("Invalid union table, expected `AnyUniqueAliases::M`.") - .unpack() - )), - AnyUniqueAliases::TS => AnyUniqueAliasesT::TS(alloc::boxed::Box::new( - self.any_unique_as_ts() - .expect("Invalid union table, expected `AnyUniqueAliases::TS`.") - .unpack() - )), - AnyUniqueAliases::M2 => AnyUniqueAliasesT::M2(alloc::boxed::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(alloc::boxed::Box::new( - self.any_ambiguous_as_m1() - .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`.") - .unpack() - )), - AnyAmbiguousAliases::M2 => AnyAmbiguousAliasesT::M2(alloc::boxed::Box::new( - self.any_ambiguous_as_m2() - .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`.") - .unpack() - )), - AnyAmbiguousAliases::M3 => AnyAmbiguousAliasesT::M3(alloc::boxed::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.into_iter().collect() - }); - let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - let native_inline = self.native_inline().map(|x| { - x.unpack() - }); - let long_enum_non_enum_default = self.long_enum_non_enum_default(); - let long_enum_normal_default = self.long_enum_normal_default(); - let nan_default = self.nan_default(); - let inf_default = self.inf_default(); - let positive_inf_default = self.positive_inf_default(); - let infinity_default = self.infinity_default(); - let positive_infinity_default = self.positive_infinity_default(); - let negative_inf_default = self.negative_inf_default(); - let negative_infinity_default = self.negative_infinity_default(); - let double_inf_default = self.double_inf_default(); - 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, - native_inline, - long_enum_non_enum_default, - long_enum_normal_default, - nan_default, - inf_default, - positive_inf_default, - infinity_default, - positive_infinity_default, - negative_inf_default, - negative_infinity_default, - double_inf_default, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Monster" } - } - #[inline] - pub fn pos(&self) -> Option<&'a Vec3> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_POS, None)} - } - - #[inline] - pub fn mana(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_MANA, Some(150)).unwrap()} - } - - #[inline] - pub fn hp(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_HP, Some(100)).unwrap()} - } - - #[inline] - pub fn name(&self) -> &'a str { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(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) -> ::core::cmp::Ordering { - let key = self.name(); - key.cmp(val) - } - - #[inline] - pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)} - } - - #[inline] - pub fn color(&self) -> Color { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_COLOR, Some(Color::Blue)).unwrap()} - } - - #[inline] - pub fn test_type(&self) -> Any { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TEST_TYPE, Some(Any::NONE)).unwrap()} - } - - #[inline] - pub fn test(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_TEST, None)} - } - - #[inline] - pub fn test4(&self) -> Option<::flatbuffers::Vector<'a, Test>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST4, None)} - } - - #[inline] - pub fn testarrayofstring(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING, None)} - } - - /// an example documentation comment: this will end up in the generated code - /// multiline too - #[inline] - pub fn testarrayoftables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_TESTARRAYOFTABLES, None)} - } - - #[inline] - pub fn enemy(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_ENEMY, None)} - } - - #[inline] - pub fn testnestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTNESTEDFLATBUFFER, None)} - } - - pub fn testnestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { - self.testnestedflatbuffer().map(|data| { - use ::flatbuffers::Follow; - // Safety: - // Created from a valid Table for this object - // Which contains a valid flatbuffer in this slot - unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } - }) - } - - #[inline] - pub fn testempty(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_TESTEMPTY, None)} - } - - #[inline] - pub fn testbool(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTBOOL, Some(false)).unwrap()} - } - - #[inline] - pub fn testhashs32_fnv1(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu32_fnv1(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashs64_fnv1(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu64_fnv1(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashs32_fnv1a(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu32_fnv1a(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashs64_fnv1a(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu64_fnv1a(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testarrayofbools(&self) -> Option<::flatbuffers::Vector<'a, bool>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, bool>>>(Monster::VT_TESTARRAYOFBOOLS, None)} - } - - #[inline] - pub fn testf(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTF, Some(3.14159)).unwrap()} - } - - #[inline] - pub fn testf2(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTF2, Some(3.0)).unwrap()} - } - - #[inline] - pub fn testf3(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTF3, Some(0.0)).unwrap()} - } - - #[inline] - pub fn testarrayofstring2(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING2, None)} - } - - #[inline] - pub fn testarrayofsortedstruct(&self) -> Option<::flatbuffers::Vector<'a, Ability>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Ability>>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, None)} - } - - #[inline] - pub fn flex(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_FLEX, None)} - } - - #[inline] - pub fn test5(&self) -> Option<::flatbuffers::Vector<'a, Test>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST5, None)} - } - - #[inline] - pub fn vector_of_longs(&self) -> Option<::flatbuffers::Vector<'a, i64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i64>>>(Monster::VT_VECTOR_OF_LONGS, None)} - } - - #[inline] - pub fn vector_of_doubles(&self) -> Option<::flatbuffers::Vector<'a, f64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(Monster::VT_VECTOR_OF_DOUBLES, None)} - } - - #[inline] - pub fn parent_namespace_test(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_PARENT_NAMESPACE_TEST, None)} - } - - #[inline] - pub fn vector_of_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_REFERRABLES, None)} - } - - #[inline] - pub fn single_weak_reference(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_SINGLE_WEAK_REFERENCE, Some(0)).unwrap()} - } - - #[inline] - pub fn vector_of_weak_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, None)} - } - - #[inline] - pub fn vector_of_strong_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, None)} - } - - #[inline] - pub fn co_owning_reference(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_CO_OWNING_REFERENCE, Some(0)).unwrap()} - } - - #[inline] - pub fn vector_of_co_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, None)} - } - - #[inline] - pub fn non_owning_reference(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NON_OWNING_REFERENCE, Some(0)).unwrap()} - } - - #[inline] - pub fn vector_of_non_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, None)} - } - - #[inline] - pub fn any_unique_type(&self) -> AnyUniqueAliases { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_ANY_UNIQUE_TYPE, Some(AnyUniqueAliases::NONE)).unwrap()} - } - - #[inline] - pub fn any_unique(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_UNIQUE, None)} - } - - #[inline] - pub fn any_ambiguous_type(&self) -> AnyAmbiguousAliases { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_ANY_AMBIGUOUS_TYPE, Some(AnyAmbiguousAliases::NONE)).unwrap()} - } - - #[inline] - pub fn any_ambiguous(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_AMBIGUOUS, None)} - } - - #[inline] - pub fn vector_of_enums(&self) -> Option<::flatbuffers::Vector<'a, Color>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Color>>>(Monster::VT_VECTOR_OF_ENUMS, None)} - } - - #[inline] - pub fn signed_enum(&self) -> Race { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()} - } - - #[inline] - pub fn testrequirednestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None)} - } - - pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { - self.testrequirednestedflatbuffer().map(|data| { - use ::flatbuffers::Follow; - // Safety: - // Created from a valid Table for this object - // Which contains a valid flatbuffer in this slot - unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } - }) - } - - #[inline] - pub fn scalar_key_sorted_tables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)} - } - - #[inline] - pub fn native_inline(&self) -> Option<&'a Test> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NATIVE_INLINE, None)} - } - - #[inline] - pub fn long_enum_non_enum_default(&self) -> LongEnum { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, Some(Default::default())).unwrap()} - } - - #[inline] - pub fn long_enum_normal_default(&self) -> LongEnum { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()} - } - - #[inline] - pub fn nan_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()} - } - - #[inline] - pub fn inf_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn positive_inf_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn infinity_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn positive_infinity_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn negative_inf_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} - } - - #[inline] - pub fn negative_infinity_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} - } - - #[inline] - pub fn double_inf_default(&self) -> f64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()} - } - - #[inline] - #[allow(non_snake_case)] - pub fn test_as_monster(&self) -> Option> { - if self.test_type() == Any::Monster { - self.test().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Monster { _tab: table } } - } - #[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(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TestSimpleTableWithEnum::init_from_table(t) } - }) - } else { - None + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args MonsterArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = MonsterBuilder::new(_fbb); + builder.add_double_inf_default(args.double_inf_default); + builder.add_long_enum_normal_default(args.long_enum_normal_default); + builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default); + 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); + builder.add_negative_infinity_default(args.negative_infinity_default); + builder.add_negative_inf_default(args.negative_inf_default); + builder.add_positive_infinity_default(args.positive_infinity_default); + builder.add_infinity_default(args.infinity_default); + builder.add_positive_inf_default(args.positive_inf_default); + builder.add_inf_default(args.inf_default); + builder.add_nan_default(args.nan_default); + if let Some(x) = args.native_inline { builder.add_native_inline(x); } + 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() } - } - #[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(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { super::example_2::Monster::init_from_table(t) } - }) - } else { - None + 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(); + alloc::string::ToString::to_string(x) + }; + let inventory = self.inventory().map(|x| { + x.into_iter().collect() + }); + let color = self.color(); + let test = match self.test_type() { + Any::NONE => AnyT::NONE, + Any::Monster => AnyT::Monster(alloc::boxed::Box::new( + self.test_as_monster() + .expect("Invalid union table, expected `Any::Monster`.") + .unpack() + )), + Any::TestSimpleTableWithEnum => AnyT::TestSimpleTableWithEnum(alloc::boxed::Box::new( + self.test_as_test_simple_table_with_enum() + .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`.") + .unpack() + )), + Any::MyGame_Example2_Monster => AnyT::MyGameExample2Monster(alloc::boxed::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| alloc::string::ToString::to_string(s)).collect() + }); + let testarrayoftables = self.testarrayoftables().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + let enemy = self.enemy().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + let testnestedflatbuffer = self.testnestedflatbuffer().map(|x| { + x.into_iter().collect() + }); + let testempty = self.testempty().map(|x| { + alloc::boxed::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.into_iter().collect() + }); + let testf = self.testf(); + let testf2 = self.testf2(); + let testf3 = self.testf3(); + let testarrayofstring2 = self.testarrayofstring2().map(|x| { + x.iter().map(|s| alloc::string::ToString::to_string(s)).collect() + }); + let testarrayofsortedstruct = self.testarrayofsortedstruct().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + let flex = self.flex().map(|x| { + x.into_iter().collect() + }); + 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| { + alloc::boxed::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(alloc::boxed::Box::new( + self.any_unique_as_m() + .expect("Invalid union table, expected `AnyUniqueAliases::M`.") + .unpack() + )), + AnyUniqueAliases::TS => AnyUniqueAliasesT::TS(alloc::boxed::Box::new( + self.any_unique_as_ts() + .expect("Invalid union table, expected `AnyUniqueAliases::TS`.") + .unpack() + )), + AnyUniqueAliases::M2 => AnyUniqueAliasesT::M2(alloc::boxed::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(alloc::boxed::Box::new( + self.any_ambiguous_as_m1() + .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`.") + .unpack() + )), + AnyAmbiguousAliases::M2 => AnyAmbiguousAliasesT::M2(alloc::boxed::Box::new( + self.any_ambiguous_as_m2() + .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`.") + .unpack() + )), + AnyAmbiguousAliases::M3 => AnyAmbiguousAliasesT::M3(alloc::boxed::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.into_iter().collect() + }); + let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + let native_inline = self.native_inline().map(|x| { + x.unpack() + }); + let long_enum_non_enum_default = self.long_enum_non_enum_default(); + let long_enum_normal_default = self.long_enum_normal_default(); + let nan_default = self.nan_default(); + let inf_default = self.inf_default(); + let positive_inf_default = self.positive_inf_default(); + let infinity_default = self.infinity_default(); + let positive_infinity_default = self.positive_infinity_default(); + let negative_inf_default = self.negative_inf_default(); + let negative_infinity_default = self.negative_infinity_default(); + let double_inf_default = self.double_inf_default(); + 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, + native_inline, + long_enum_non_enum_default, + long_enum_normal_default, + nan_default, + inf_default, + positive_inf_default, + infinity_default, + positive_infinity_default, + negative_inf_default, + negative_infinity_default, + double_inf_default, + } } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_unique_as_m(&self) -> Option> { - if self.any_unique_type() == AnyUniqueAliases::M { - self.any_unique().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn pos(&self) -> Option<&'a Vec3> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_POS, 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(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TestSimpleTableWithEnum::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn mana(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_MANA, Some(150)).unwrap()} } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_unique_as_m2(&self) -> Option> { - if self.any_unique_type() == AnyUniqueAliases::M2 { - self.any_unique().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { super::example_2::Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn hp(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_HP, Some(100)).unwrap()} } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_ambiguous_as_m1(&self) -> Option> { - if self.any_ambiguous_type() == AnyAmbiguousAliases::M1 { - self.any_ambiguous().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn name(&self) -> &'a str { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None).unwrap()} } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_ambiguous_as_m2(&self) -> Option> { - if self.any_ambiguous_type() == AnyAmbiguousAliases::M2 { - self.any_ambiguous().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn key_compare_less_than(&self, o: &Monster) -> bool { + self.name() < o.name() } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_ambiguous_as_m3(&self) -> Option> { - if self.any_ambiguous_type() == AnyAmbiguousAliases::M3 { - self.any_ambiguous().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn key_compare_with_value(&self, val: & str) -> ::core::cmp::Ordering { + let key = self.name(); + key.cmp(val) + } + + #[inline] + pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)} + } + + #[inline] + pub fn color(&self) -> Color { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_COLOR, Some(Color::Blue)).unwrap()} + } + + #[inline] + pub fn test_type(&self) -> Any { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TEST_TYPE, Some(Any::NONE)).unwrap()} + } + + #[inline] + pub fn test(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_TEST, None)} + } + + #[inline] + pub fn test4(&self) -> Option<::flatbuffers::Vector<'a, Test>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST4, None)} + } + + #[inline] + pub fn testarrayofstring(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING, None)} + } + + /// an example documentation comment: this will end up in the generated code + /// multiline too + #[inline] + pub fn testarrayoftables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_TESTARRAYOFTABLES, None)} + } + + #[inline] + pub fn enemy(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_ENEMY, None)} + } + + #[inline] + pub fn testnestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTNESTEDFLATBUFFER, None)} + } + + pub fn testnestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { + self.testnestedflatbuffer().map(|data| { + use ::flatbuffers::Follow; + // Safety: + // Created from a valid Table for this object + // Which contains a valid flatbuffer in this slot + unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } + }) + } + + #[inline] + pub fn testempty(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_TESTEMPTY, None)} + } + + #[inline] + pub fn testbool(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTBOOL, Some(false)).unwrap()} + } + + #[inline] + pub fn testhashs32_fnv1(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu32_fnv1(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashs64_fnv1(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu64_fnv1(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashs32_fnv1a(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu32_fnv1a(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashs64_fnv1a(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu64_fnv1a(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testarrayofbools(&self) -> Option<::flatbuffers::Vector<'a, bool>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, bool>>>(Monster::VT_TESTARRAYOFBOOLS, None)} + } + + #[inline] + pub fn testf(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTF, Some(3.14159)).unwrap()} + } + + #[inline] + pub fn testf2(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTF2, Some(3.0)).unwrap()} + } + + #[inline] + pub fn testf3(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTF3, Some(0.0)).unwrap()} + } + + #[inline] + pub fn testarrayofstring2(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING2, None)} + } + + #[inline] + pub fn testarrayofsortedstruct(&self) -> Option<::flatbuffers::Vector<'a, Ability>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Ability>>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, None)} + } + + #[inline] + pub fn flex(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_FLEX, None)} + } + + #[inline] + pub fn test5(&self) -> Option<::flatbuffers::Vector<'a, Test>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST5, None)} + } + + #[inline] + pub fn vector_of_longs(&self) -> Option<::flatbuffers::Vector<'a, i64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i64>>>(Monster::VT_VECTOR_OF_LONGS, None)} + } + + #[inline] + pub fn vector_of_doubles(&self) -> Option<::flatbuffers::Vector<'a, f64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(Monster::VT_VECTOR_OF_DOUBLES, None)} + } + + #[inline] + pub fn parent_namespace_test(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_PARENT_NAMESPACE_TEST, None)} + } + + #[inline] + pub fn vector_of_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_REFERRABLES, None)} + } + + #[inline] + pub fn single_weak_reference(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_SINGLE_WEAK_REFERENCE, Some(0)).unwrap()} + } + + #[inline] + pub fn vector_of_weak_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, None)} + } + + #[inline] + pub fn vector_of_strong_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, None)} + } + + #[inline] + pub fn co_owning_reference(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_CO_OWNING_REFERENCE, Some(0)).unwrap()} + } + + #[inline] + pub fn vector_of_co_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, None)} + } + + #[inline] + pub fn non_owning_reference(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NON_OWNING_REFERENCE, Some(0)).unwrap()} + } + + #[inline] + pub fn vector_of_non_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, None)} + } + + #[inline] + pub fn any_unique_type(&self) -> AnyUniqueAliases { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_ANY_UNIQUE_TYPE, Some(AnyUniqueAliases::NONE)).unwrap()} + } + + #[inline] + pub fn any_unique(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_UNIQUE, None)} + } + + #[inline] + pub fn any_ambiguous_type(&self) -> AnyAmbiguousAliases { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_ANY_AMBIGUOUS_TYPE, Some(AnyAmbiguousAliases::NONE)).unwrap()} + } + + #[inline] + pub fn any_ambiguous(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_AMBIGUOUS, None)} + } + + #[inline] + pub fn vector_of_enums(&self) -> Option<::flatbuffers::Vector<'a, Color>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Color>>>(Monster::VT_VECTOR_OF_ENUMS, None)} + } + + #[inline] + pub fn signed_enum(&self) -> Race { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()} + } + + #[inline] + pub fn testrequirednestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None)} + } + + pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { + self.testrequirednestedflatbuffer().map(|data| { + use ::flatbuffers::Follow; + // Safety: + // Created from a valid Table for this object + // Which contains a valid flatbuffer in this slot + unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } + }) + } + + #[inline] + pub fn scalar_key_sorted_tables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)} + } + + #[inline] + pub fn native_inline(&self) -> Option<&'a Test> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NATIVE_INLINE, None)} + } + + #[inline] + pub fn long_enum_non_enum_default(&self) -> LongEnum { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, Some(Default::default())).unwrap()} + } + + #[inline] + pub fn long_enum_normal_default(&self) -> LongEnum { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()} + } + + #[inline] + pub fn nan_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()} + } + + #[inline] + pub fn inf_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn positive_inf_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn infinity_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn positive_infinity_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn negative_inf_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} + } + + #[inline] + pub fn negative_infinity_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} + } + + #[inline] + pub fn double_inf_default(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()} + } + + #[inline] + #[allow(non_snake_case)] + pub fn test_as_monster(&self) -> Option> { + if self.test_type() == Any::Monster { + self.test().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TestSimpleTableWithEnum::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { super::example_2::Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TestSimpleTableWithEnum::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { super::example_2::Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } else { + None + } } - } } impl ::flatbuffers::Verifiable for Monster<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - 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::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("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::<::flatbuffers::ForwardsUOffset>("Any::Monster", pos), - Any::TestSimpleTableWithEnum => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::TestSimpleTableWithEnum", pos), - Any::MyGame_Example2_Monster => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::MyGame_Example2_Monster", pos), - _ => Ok(()), - } - })? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test4", Self::VT_TEST4, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring", Self::VT_TESTARRAYOFSTRING, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("testarrayoftables", Self::VT_TESTARRAYOFTABLES, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>("enemy", Self::VT_ENEMY, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testnestedflatbuffer", Self::VT_TESTNESTEDFLATBUFFER, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, bool>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring2", Self::VT_TESTARRAYOFSTRING2, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Ability>>>("testarrayofsortedstruct", Self::VT_TESTARRAYOFSORTEDSTRUCT, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("flex", Self::VT_FLEX, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test5", Self::VT_TEST5, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i64>>>("vector_of_longs", Self::VT_VECTOR_OF_LONGS, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vector_of_doubles", Self::VT_VECTOR_OF_DOUBLES, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>("parent_namespace_test", Self::VT_PARENT_NAMESPACE_TEST, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_referrables", Self::VT_VECTOR_OF_REFERRABLES, false)? - .visit_field::("single_weak_reference", Self::VT_SINGLE_WEAK_REFERENCE, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("vector_of_weak_references", Self::VT_VECTOR_OF_WEAK_REFERENCES, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_strong_referrables", Self::VT_VECTOR_OF_STRONG_REFERRABLES, false)? - .visit_field::("co_owning_reference", Self::VT_CO_OWNING_REFERENCE, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::M", pos), - AnyUniqueAliases::TS => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::TS", pos), - AnyUniqueAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M1", pos), - AnyAmbiguousAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M2", pos), - AnyAmbiguousAliases::M3 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M3", pos), - _ => Ok(()), - } - })? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Color>>>("vector_of_enums", Self::VT_VECTOR_OF_ENUMS, false)? - .visit_field::("signed_enum", Self::VT_SIGNED_ENUM, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)? - .visit_field::("native_inline", Self::VT_NATIVE_INLINE, false)? - .visit_field::("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)? - .visit_field::("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)? - .visit_field::("nan_default", Self::VT_NAN_DEFAULT, false)? - .visit_field::("inf_default", Self::VT_INF_DEFAULT, false)? - .visit_field::("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)? - .visit_field::("infinity_default", Self::VT_INFINITY_DEFAULT, false)? - .visit_field::("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)? - .visit_field::("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)? - .visit_field::("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)? - .visit_field::("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("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::<::flatbuffers::ForwardsUOffset>("Any::Monster", pos), + Any::TestSimpleTableWithEnum => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::TestSimpleTableWithEnum", pos), + Any::MyGame_Example2_Monster => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::MyGame_Example2_Monster", pos), + _ => Ok(()), + } + })? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test4", Self::VT_TEST4, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring", Self::VT_TESTARRAYOFSTRING, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("testarrayoftables", Self::VT_TESTARRAYOFTABLES, false)? + .visit_field::<::flatbuffers::ForwardsUOffset>("enemy", Self::VT_ENEMY, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testnestedflatbuffer", Self::VT_TESTNESTEDFLATBUFFER, false)? + .visit_field::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, bool>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring2", Self::VT_TESTARRAYOFSTRING2, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Ability>>>("testarrayofsortedstruct", Self::VT_TESTARRAYOFSORTEDSTRUCT, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("flex", Self::VT_FLEX, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test5", Self::VT_TEST5, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i64>>>("vector_of_longs", Self::VT_VECTOR_OF_LONGS, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vector_of_doubles", Self::VT_VECTOR_OF_DOUBLES, false)? + .visit_field::<::flatbuffers::ForwardsUOffset>("parent_namespace_test", Self::VT_PARENT_NAMESPACE_TEST, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_referrables", Self::VT_VECTOR_OF_REFERRABLES, false)? + .visit_field::("single_weak_reference", Self::VT_SINGLE_WEAK_REFERENCE, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("vector_of_weak_references", Self::VT_VECTOR_OF_WEAK_REFERENCES, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_strong_referrables", Self::VT_VECTOR_OF_STRONG_REFERRABLES, false)? + .visit_field::("co_owning_reference", Self::VT_CO_OWNING_REFERENCE, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::M", pos), + AnyUniqueAliases::TS => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::TS", pos), + AnyUniqueAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M1", pos), + AnyAmbiguousAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M2", pos), + AnyAmbiguousAliases::M3 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M3", pos), + _ => Ok(()), + } + })? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Color>>>("vector_of_enums", Self::VT_VECTOR_OF_ENUMS, false)? + .visit_field::("signed_enum", Self::VT_SIGNED_ENUM, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)? + .visit_field::("native_inline", Self::VT_NATIVE_INLINE, false)? + .visit_field::("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)? + .visit_field::("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)? + .visit_field::("nan_default", Self::VT_NAN_DEFAULT, false)? + .visit_field::("inf_default", Self::VT_INF_DEFAULT, false)? + .visit_field::("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)? + .visit_field::("infinity_default", Self::VT_INFINITY_DEFAULT, false)? + .visit_field::("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)? + .visit_field::("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)? + .visit_field::("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)? + .visit_field::("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)? + .finish(); + Ok(()) + } } pub struct MonsterArgs<'a> { @@ -1202,857 +1202,857 @@ pub struct MonsterArgs<'a> { } 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, - native_inline: None, - long_enum_non_enum_default: Default::default(), - long_enum_normal_default: LongEnum::LongOne, - nan_default: f32::NAN, - inf_default: f32::INFINITY, - positive_inf_default: f32::INFINITY, - infinity_default: f32::INFINITY, - positive_infinity_default: f32::INFINITY, - negative_inf_default: f32::NEG_INFINITY, - negative_infinity_default: f32::NEG_INFINITY, - double_inf_default: f64::INFINITY, + #[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, + native_inline: None, + long_enum_non_enum_default: Default::default(), + long_enum_normal_default: LongEnum::LongOne, + nan_default: f32::NAN, + inf_default: f32::INFINITY, + positive_inf_default: f32::INFINITY, + infinity_default: f32::INFINITY, + positive_infinity_default: f32::INFINITY, + negative_inf_default: f32::NEG_INFINITY, + negative_infinity_default: f32::NEG_INFINITY, + double_inf_default: f64::INFINITY, + } } - } } pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> { - #[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::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name); - } - - #[inline] - pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST, test); - } - - #[inline] - pub fn add_test4(&mut self, test4: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST4, test4); - } - - #[inline] - pub fn add_testarrayofstring(&mut self, testarrayofstring: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); - } - - #[inline] - pub fn add_testarrayoftables(&mut self, testarrayoftables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); - } - - #[inline] - pub fn add_enemy(&mut self, enemy: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(Monster::VT_ENEMY, enemy); - } - - #[inline] - pub fn add_testnestedflatbuffer(&mut self, testnestedflatbuffer: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); - } - - #[inline] - pub fn add_testempty(&mut self, testempty: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(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<::flatbuffers::Vector<'b , bool>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); - } - - #[inline] - pub fn add_testarrayofsortedstruct(&mut self, testarrayofsortedstruct: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Ability>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); - } - - #[inline] - pub fn add_flex(&mut self, flex: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_FLEX, flex); - } - - #[inline] - pub fn add_test5(&mut self, test5: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST5, test5); - } - - #[inline] - pub fn add_vector_of_longs(&mut self, vector_of_longs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , i64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); - } - - #[inline] - pub fn add_vector_of_doubles(&mut self, vector_of_doubles: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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::<::flatbuffers::WIPOffset>(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); - } - - #[inline] - pub fn add_vector_of_referrables(&mut self, vector_of_referrables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); - } - - #[inline] - pub fn add_vector_of_enums(&mut self, vector_of_enums: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Color>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); - } - - #[inline] - pub fn add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); - } - - #[inline] - pub fn add_native_inline(&mut self, native_inline: &Test) { - self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline); - } - - #[inline] - pub fn add_long_enum_non_enum_default(&mut self, long_enum_non_enum_default: LongEnum) { - self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, long_enum_non_enum_default, Default::default()); - } - - #[inline] - pub fn add_long_enum_normal_default(&mut self, long_enum_normal_default: LongEnum) { - self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne); - } - - #[inline] - pub fn add_nan_default(&mut self, nan_default: f32) { - self.fbb_.push_slot::(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN); - } - - #[inline] - pub fn add_inf_default(&mut self, inf_default: f32) { - self.fbb_.push_slot::(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY); - } - - #[inline] - pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) { - self.fbb_.push_slot::(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY); - } - - #[inline] - pub fn add_infinity_default(&mut self, infinity_default: f32) { - self.fbb_.push_slot::(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY); - } - - #[inline] - pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) { - self.fbb_.push_slot::(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY); - } - - #[inline] - pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) { - self.fbb_.push_slot::(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY); - } - - #[inline] - pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) { - self.fbb_.push_slot::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY); - } - - #[inline] - pub fn add_double_inf_default(&mut self, double_inf_default: f64) { - self.fbb_.push_slot::(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - MonsterBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_pos(&mut self, pos: &Vec3) { + self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos); } - } - #[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()) - } + #[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::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name); + } + + #[inline] + pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST, test); + } + + #[inline] + pub fn add_test4(&mut self, test4: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST4, test4); + } + + #[inline] + pub fn add_testarrayofstring(&mut self, testarrayofstring: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); + } + + #[inline] + pub fn add_testarrayoftables(&mut self, testarrayoftables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); + } + + #[inline] + pub fn add_enemy(&mut self, enemy: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(Monster::VT_ENEMY, enemy); + } + + #[inline] + pub fn add_testnestedflatbuffer(&mut self, testnestedflatbuffer: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); + } + + #[inline] + pub fn add_testempty(&mut self, testempty: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(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<::flatbuffers::Vector<'b , bool>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); + } + + #[inline] + pub fn add_testarrayofsortedstruct(&mut self, testarrayofsortedstruct: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Ability>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); + } + + #[inline] + pub fn add_flex(&mut self, flex: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_FLEX, flex); + } + + #[inline] + pub fn add_test5(&mut self, test5: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST5, test5); + } + + #[inline] + pub fn add_vector_of_longs(&mut self, vector_of_longs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , i64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); + } + + #[inline] + pub fn add_vector_of_doubles(&mut self, vector_of_doubles: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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::<::flatbuffers::WIPOffset>(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); + } + + #[inline] + pub fn add_vector_of_referrables(&mut self, vector_of_referrables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); + } + + #[inline] + pub fn add_vector_of_enums(&mut self, vector_of_enums: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Color>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); + } + + #[inline] + pub fn add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); + } + + #[inline] + pub fn add_native_inline(&mut self, native_inline: &Test) { + self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline); + } + + #[inline] + pub fn add_long_enum_non_enum_default(&mut self, long_enum_non_enum_default: LongEnum) { + self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, long_enum_non_enum_default, Default::default()); + } + + #[inline] + pub fn add_long_enum_normal_default(&mut self, long_enum_normal_default: LongEnum) { + self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne); + } + + #[inline] + pub fn add_nan_default(&mut self, nan_default: f32) { + self.fbb_.push_slot::(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN); + } + + #[inline] + pub fn add_inf_default(&mut self, inf_default: f32) { + self.fbb_.push_slot::(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY); + } + + #[inline] + pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) { + self.fbb_.push_slot::(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY); + } + + #[inline] + pub fn add_infinity_default(&mut self, infinity_default: f32) { + self.fbb_.push_slot::(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY); + } + + #[inline] + pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) { + self.fbb_.push_slot::(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY); + } + + #[inline] + pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) { + self.fbb_.push_slot::(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY); + } + + #[inline] + pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) { + self.fbb_.push_slot::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY); + } + + #[inline] + pub fn add_double_inf_default(&mut self, double_inf_default: f64) { + self.fbb_.push_slot::(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for Monster<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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.field("native_inline", &self.native_inline()); - ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default()); - ds.field("long_enum_normal_default", &self.long_enum_normal_default()); - ds.field("nan_default", &self.nan_default()); - ds.field("inf_default", &self.inf_default()); - ds.field("positive_inf_default", &self.positive_inf_default()); - ds.field("infinity_default", &self.infinity_default()); - ds.field("positive_infinity_default", &self.positive_infinity_default()); - ds.field("negative_inf_default", &self.negative_inf_default()); - ds.field("negative_infinity_default", &self.negative_infinity_default()); - ds.field("double_inf_default", &self.double_inf_default()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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.field("native_inline", &self.native_inline()); + ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default()); + ds.field("long_enum_normal_default", &self.long_enum_normal_default()); + ds.field("nan_default", &self.nan_default()); + ds.field("inf_default", &self.inf_default()); + ds.field("positive_inf_default", &self.positive_inf_default()); + ds.field("infinity_default", &self.infinity_default()); + ds.field("positive_infinity_default", &self.positive_infinity_default()); + ds.field("negative_inf_default", &self.negative_inf_default()); + ds.field("negative_infinity_default", &self.negative_infinity_default()); + ds.field("double_inf_default", &self.double_inf_default()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct MonsterT { - pub pos: Option, - pub mana: i16, - pub hp: i16, - pub name: alloc::string::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>, - pub native_inline: Option, - pub long_enum_non_enum_default: LongEnum, - pub long_enum_normal_default: LongEnum, - pub nan_default: f32, - pub inf_default: f32, - pub positive_inf_default: f32, - pub infinity_default: f32, - pub positive_infinity_default: f32, - pub negative_inf_default: f32, - pub negative_infinity_default: f32, - pub double_inf_default: f64, + pub pos: Option, + pub mana: i16, + pub hp: i16, + pub name: alloc::string::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>, + pub native_inline: Option, + pub long_enum_non_enum_default: LongEnum, + pub long_enum_normal_default: LongEnum, + pub nan_default: f32, + pub inf_default: f32, + pub positive_inf_default: f32, + pub infinity_default: f32, + pub positive_infinity_default: f32, + pub negative_inf_default: f32, + pub negative_infinity_default: f32, + pub double_inf_default: f64, } impl Default for MonsterT { - fn default() -> Self { - Self { - pos: None, - mana: 150, - hp: 100, - name: alloc::string::ToString::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, - native_inline: None, - long_enum_non_enum_default: Default::default(), - long_enum_normal_default: LongEnum::LongOne, - nan_default: f32::NAN, - inf_default: f32::INFINITY, - positive_inf_default: f32::INFINITY, - infinity_default: f32::INFINITY, - positive_infinity_default: f32::INFINITY, - negative_inf_default: f32::NEG_INFINITY, - negative_infinity_default: f32::NEG_INFINITY, - double_inf_default: f64::INFINITY, + fn default() -> Self { + Self { + pos: None, + mana: 150, + hp: 100, + name: alloc::string::ToString::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, + native_inline: None, + long_enum_non_enum_default: Default::default(), + long_enum_normal_default: LongEnum::LongOne, + nan_default: f32::NAN, + inf_default: f32::INFINITY, + positive_inf_default: f32::INFINITY, + infinity_default: f32::INFINITY, + positive_infinity_default: f32::INFINITY, + negative_inf_default: f32::NEG_INFINITY, + negative_infinity_default: f32::NEG_INFINITY, + double_inf_default: f64::INFINITY, + } } - } } impl MonsterT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) - }); - let testarrayofstring = self.testarrayofstring.as_ref().map(|x|{ - let w: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) - }); - let testarrayoftables = self.testarrayoftables.as_ref().map(|x|{ - let w: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) - }); - let testarrayofsortedstruct = self.testarrayofsortedstruct.as_ref().map(|x|{ - let w: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) - }); - let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack()); - let native_inline = native_inline_tmp.as_ref(); - let long_enum_non_enum_default = self.long_enum_non_enum_default; - let long_enum_normal_default = self.long_enum_normal_default; - let nan_default = self.nan_default; - let inf_default = self.inf_default; - let positive_inf_default = self.positive_inf_default; - let infinity_default = self.infinity_default; - let positive_infinity_default = self.positive_infinity_default; - let negative_inf_default = self.negative_inf_default; - let negative_infinity_default = self.negative_infinity_default; - let double_inf_default = self.double_inf_default; - 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, - native_inline, - long_enum_non_enum_default, - long_enum_normal_default, - nan_default, - inf_default, - positive_inf_default, - infinity_default, - positive_infinity_default, - negative_inf_default, - negative_infinity_default, - double_inf_default, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) + }); + let testarrayofstring = self.testarrayofstring.as_ref().map(|x|{ + let w: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) + }); + let testarrayoftables = self.testarrayoftables.as_ref().map(|x|{ + let w: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) + }); + let testarrayofsortedstruct = self.testarrayofsortedstruct.as_ref().map(|x|{ + let w: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) + }); + let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack()); + let native_inline = native_inline_tmp.as_ref(); + let long_enum_non_enum_default = self.long_enum_non_enum_default; + let long_enum_normal_default = self.long_enum_normal_default; + let nan_default = self.nan_default; + let inf_default = self.inf_default; + let positive_inf_default = self.positive_inf_default; + let infinity_default = self.infinity_default; + let positive_infinity_default = self.positive_infinity_default; + let negative_inf_default = self.negative_inf_default; + let negative_infinity_default = self.negative_infinity_default; + let double_inf_default = self.double_inf_default; + 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, + native_inline, + long_enum_non_enum_default, + long_enum_normal_default, + nan_default, + inf_default, + positive_inf_default, + infinity_default, + positive_infinity_default, + negative_inf_default, + negative_infinity_default, + double_inf_default, + }) + } } /// Verifies that a buffer of bytes contains a `Monster` @@ -2063,7 +2063,7 @@ impl MonsterT { /// `root_as_monster_unchecked`. #[inline] pub fn root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) + ::flatbuffers::root::(buf) } /// Verifies that a buffer of bytes contains a size prefixed @@ -2074,7 +2074,7 @@ pub fn root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::Invalid /// `size_prefixed_root_as_monster_unchecked`. #[inline] pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) + ::flatbuffers::size_prefixed_root::(buf) } /// Verifies, with the given options, that a buffer of bytes @@ -2085,10 +2085,10 @@ pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result, ::flatbu /// `root_as_monster_unchecked`. #[inline] pub fn root_as_monster_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) + ::flatbuffers::root_with_opts::>(opts, buf) } /// Verifies, with the given verifier options, that a buffer of @@ -2099,10 +2099,10 @@ pub fn root_as_monster_with_opts<'b, 'o>( /// `root_as_monster_unchecked`. #[inline] pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } /// Assumes, without verification, that a buffer of bytes contains a Monster and returns it. @@ -2110,7 +2110,7 @@ pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>( /// Callers must trust the given bytes do indeed contain a valid `Monster`. #[inline] pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } + unsafe { ::flatbuffers::root_unchecked::(buf) } } /// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it. @@ -2118,19 +2118,19 @@ pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { /// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`. #[inline] pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + unsafe { ::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) + ::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) + ::flatbuffers::buffer_has_identifier(buf, MONSTER_IDENTIFIER, true) } pub const MONSTER_EXTENSION: &str = "mon"; @@ -2138,11 +2138,15 @@ pub const MONSTER_EXTENSION: &str = "mon"; #[inline] pub fn finish_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>) { - fbb.finish(root, Some(MONSTER_IDENTIFIER)); + root: ::flatbuffers::WIPOffset> +) { + fbb.finish(root, Some(MONSTER_IDENTIFIER)); } #[inline] -pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset>) { - fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER)); +pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset> +) { + fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER)); } diff --git a/tests/monster_test/my_game/example/race_generated.rs b/tests/monster_test/my_game/example/race_generated.rs index 013ceb33d..18516548e 100644 --- a/tests/monster_test/my_game/example/race_generated.rs +++ b/tests/monster_test/my_game/example/race_generated.rs @@ -12,10 +12,10 @@ 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, + Race::None, + Race::Human, + Race::Dwarf, + Race::Elf, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -24,50 +24,50 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for Race { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -80,28 +80,28 @@ impl ::flatbuffers::Push for Race { } impl ::flatbuffers::EndianScalar for Race { - type Scalar = i8; + type Scalar = i8; - #[inline] - fn to_little_endian(self) -> i8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i8) -> Self { - let b = i8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i8) -> Self { + let b = i8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for Race { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Race {} diff --git a/tests/monster_test/my_game/example/referrable_generated.rs b/tests/monster_test/my_game/example/referrable_generated.rs index 09832db42..38e259a3e 100644 --- a/tests/monster_test/my_game/example/referrable_generated.rs +++ b/tests/monster_test/my_game/example/referrable_generated.rs @@ -7,77 +7,77 @@ pub enum ReferrableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Referrable<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Referrable<'a> { - type Inner = Referrable<'a>; + type Inner = Referrable<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Referrable<'a> { - pub const VT_ID: ::flatbuffers::VOffsetT = 4; + pub const VT_ID: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.Referrable" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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 fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Referrable" } - } - #[inline] - pub fn id(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Referrable::VT_ID, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Referrable { _tab: table } + } - #[inline] - pub fn key_compare_less_than(&self, o: &Referrable) -> bool { - self.id() < o.id() - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args ReferrableArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = ReferrableBuilder::new(_fbb); + builder.add_id(args.id); + builder.finish() + } - #[inline] - pub fn key_compare_with_value(&self, val: u64) -> ::core::cmp::Ordering { - let key = self.id(); - key.cmp(&val) - } + pub fn unpack(&self) -> ReferrableT { + let id = self.id(); + ReferrableT { + id, + } + } + + #[inline] + pub fn id(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { 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) -> ::core::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> { - v.visit_table(pos)? - .visit_field::("id", Self::VT_ID, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("id", Self::VT_ID, false)? + .finish(); + Ok(()) + } } pub struct ReferrableArgs { @@ -85,71 +85,71 @@ pub struct ReferrableArgs { } impl<'a> Default for ReferrableArgs { - #[inline] - fn default() -> Self { - ReferrableArgs { - id: 0, + #[inline] + fn default() -> Self { + ReferrableArgs { + id: 0, + } } - } } pub struct ReferrableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ReferrableBuilder<'a, 'b, A> { - #[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, A>) -> ReferrableBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - ReferrableBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_id(&mut self, id: u64) { + self.fbb_.push_slot::(Referrable::VT_ID, id, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ReferrableBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for Referrable<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Referrable"); - ds.field("id", &self.id()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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, + pub id: u64, } impl Default for ReferrableT { - fn default() -> Self { - Self { - id: 0, + fn default() -> Self { + Self { + id: 0, + } } - } } impl ReferrableT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let id = self.id; - Referrable::create(_fbb, &ReferrableArgs{ - id, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let id = self.id; + Referrable::create(_fbb, &ReferrableArgs{ + id, + }) + } } diff --git a/tests/monster_test/my_game/example/stat_generated.rs b/tests/monster_test/my_game/example/stat_generated.rs index 223631b6f..939461343 100644 --- a/tests/monster_test/my_game/example/stat_generated.rs +++ b/tests/monster_test/my_game/example/stat_generated.rs @@ -7,105 +7,105 @@ pub enum StatOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Stat<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Stat<'a> { - type Inner = Stat<'a>; + type Inner = Stat<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Stat<'a> { - pub const VT_ID: ::flatbuffers::VOffsetT = 4; - pub const VT_VAL: ::flatbuffers::VOffsetT = 6; - pub const VT_COUNT: ::flatbuffers::VOffsetT = 8; + pub const VT_ID: ::flatbuffers::VOffsetT = 4; + pub const VT_VAL: ::flatbuffers::VOffsetT = 6; + pub const VT_COUNT: ::flatbuffers::VOffsetT = 8; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.Stat" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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| { - alloc::string::ToString::to_string(x) - }); - let val = self.val(); - let count = self.count(); - StatT { - id, - val, - count, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Stat" } - } - #[inline] - pub fn id(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Stat::VT_ID, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Stat { _tab: table } + } - #[inline] - pub fn val(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Stat::VT_VAL, Some(0)).unwrap()} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + 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() + } - #[inline] - pub fn count(&self) -> u16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Stat::VT_COUNT, Some(0)).unwrap()} - } + pub fn unpack(&self) -> StatT { + let id = self.id().map(|x| { + alloc::string::ToString::to_string(x) + }); + let val = self.val(); + let count = self.count(); + StatT { + id, + val, + count, + } + } - #[inline] - pub fn key_compare_less_than(&self, o: &Stat) -> bool { - self.count() < o.count() - } + #[inline] + pub fn id(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Stat::VT_ID, None)} + } - #[inline] - pub fn key_compare_with_value(&self, val: u16) -> ::core::cmp::Ordering { - let key = self.count(); - key.cmp(&val) - } + #[inline] + pub fn val(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Stat::VT_VAL, Some(0)).unwrap()} + } + + #[inline] + pub fn count(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { 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) -> ::core::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> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)? - .visit_field::("val", Self::VT_VAL, false)? - .visit_field::("count", Self::VT_COUNT, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("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> { @@ -115,95 +115,95 @@ pub struct StatArgs<'a> { } impl<'a> Default for StatArgs<'a> { - #[inline] - fn default() -> Self { - StatArgs { - id: None, - val: 0, - count: 0, + #[inline] + fn default() -> Self { + StatArgs { + id: None, + val: 0, + count: 0, + } } - } } pub struct StatBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StatBuilder<'a, 'b, A> { - #[inline] - pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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, A>) -> StatBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - StatBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Stat::VT_ID, id); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[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, A>) -> StatBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for Stat<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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, + pub id: Option, + pub val: i64, + pub count: u16, } impl Default for StatT { - fn default() -> Self { - Self { - id: None, - val: 0, - count: 0, + fn default() -> Self { + Self { + id: None, + val: 0, + count: 0, + } } - } } impl StatT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::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 fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::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, + }) + } } diff --git a/tests/monster_test/my_game/example/struct_of_structs_generated.rs b/tests/monster_test/my_game/example/struct_of_structs_generated.rs index b957d26b5..f0d803f7a 100644 --- a/tests/monster_test/my_game/example/struct_of_structs_generated.rs +++ b/tests/monster_test/my_game/example/struct_of_structs_generated.rs @@ -8,40 +8,40 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct StructOfStructs(pub [u8; 20]); -impl Default for StructOfStructs { - fn default() -> Self { - Self([0; 20]) - } +impl Default for StructOfStructs { + fn default() -> Self { + Self([0; 20]) + } } impl ::core::fmt::Debug for StructOfStructs { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("StructOfStructs") - .field("a", &self.a()) - .field("b", &self.b()) - .field("c", &self.c()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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<'a> ::flatbuffers::Follow<'a> for StructOfStructs { - type Inner = &'a StructOfStructs; + type Inner = &'a StructOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a StructOfStructs>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a StructOfStructs>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a StructOfStructs { - type Inner = &'a StructOfStructs; + type Inner = &'a StructOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for StructOfStructs { @@ -60,90 +60,90 @@ impl<'b> ::flatbuffers::Push for StructOfStructs { } impl<'a> ::flatbuffers::Verifiable for StructOfStructs { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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 { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[0..].as_ptr() as *const Ability) } - } - - #[allow(clippy::identity_op)] - pub fn set_a(&mut self, x: &Ability) { - self.0[0..0 + 8].copy_from_slice(&x.0) - } - - pub fn b(&self) -> &Test { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[8..].as_ptr() as *const Test) } - } - - #[allow(clippy::identity_op)] - pub fn set_b(&mut self, x: &Test) { - self.0[8..8 + 4].copy_from_slice(&x.0) - } - - pub fn c(&self) -> &Ability { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[12..].as_ptr() as *const Ability) } - } - - #[allow(clippy::identity_op)] - 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(), + #[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 { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[0..].as_ptr() as *const Ability) } + } + + #[allow(clippy::identity_op)] + pub fn set_a(&mut self, x: &Ability) { + self.0[0..0 + 8].copy_from_slice(&x.0) + } + + pub fn b(&self) -> &Test { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[8..].as_ptr() as *const Test) } + } + + #[allow(clippy::identity_op)] + pub fn set_b(&mut self, x: &Test) { + self.0[8..8 + 4].copy_from_slice(&x.0) + } + + pub fn c(&self) -> &Ability { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[12..].as_ptr() as *const Ability) } + } + + #[allow(clippy::identity_op)] + 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, + 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 fn pack(&self) -> StructOfStructs { + StructOfStructs::new( + &self.a.pack(), + &self.b.pack(), + &self.c.pack(), + ) + } } diff --git a/tests/monster_test/my_game/example/struct_of_structs_of_structs_generated.rs b/tests/monster_test/my_game/example/struct_of_structs_of_structs_generated.rs index 34a4832ae..1d8887816 100644 --- a/tests/monster_test/my_game/example/struct_of_structs_of_structs_generated.rs +++ b/tests/monster_test/my_game/example/struct_of_structs_of_structs_generated.rs @@ -8,38 +8,38 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct StructOfStructsOfStructs(pub [u8; 20]); -impl Default for StructOfStructsOfStructs { - fn default() -> Self { - Self([0; 20]) - } +impl Default for StructOfStructsOfStructs { + fn default() -> Self { + Self([0; 20]) + } } impl ::core::fmt::Debug for StructOfStructsOfStructs { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("StructOfStructsOfStructs") - .field("a", &self.a()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("StructOfStructsOfStructs") + .field("a", &self.a()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for StructOfStructsOfStructs {} impl<'a> ::flatbuffers::Follow<'a> for StructOfStructsOfStructs { - type Inner = &'a StructOfStructsOfStructs; + type Inner = &'a StructOfStructsOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a StructOfStructsOfStructs>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a StructOfStructsOfStructs>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a StructOfStructsOfStructs { - type Inner = &'a StructOfStructsOfStructs; + type Inner = &'a StructOfStructsOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for StructOfStructsOfStructs { @@ -58,56 +58,56 @@ impl<'b> ::flatbuffers::Push for StructOfStructsOfStructs { } impl<'a> ::flatbuffers::Verifiable for StructOfStructsOfStructs { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> StructOfStructsOfStructs { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: &StructOfStructs, - ) -> Self { - let mut s = Self([0; 20]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.StructOfStructsOfStructs" - } - - pub fn a(&self) -> &StructOfStructs { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[0..].as_ptr() as *const StructOfStructs) } - } - - #[allow(clippy::identity_op)] - pub fn set_a(&mut self, x: &StructOfStructs) { - self.0[0..0 + 20].copy_from_slice(&x.0) - } - - pub fn unpack(&self) -> StructOfStructsOfStructsT { - StructOfStructsOfStructsT { - a: self.a().unpack(), + #[allow(clippy::too_many_arguments)] + pub fn new( + a: &StructOfStructs, + ) -> Self { + let mut s = Self([0; 20]); + s.set_a(a); + s + } + + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.StructOfStructsOfStructs" + } + + pub fn a(&self) -> &StructOfStructs { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[0..].as_ptr() as *const StructOfStructs) } + } + + #[allow(clippy::identity_op)] + pub fn set_a(&mut self, x: &StructOfStructs) { + self.0[0..0 + 20].copy_from_slice(&x.0) + } + + pub fn unpack(&self) -> StructOfStructsOfStructsT { + StructOfStructsOfStructsT { + a: self.a().unpack(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct StructOfStructsOfStructsT { - pub a: StructOfStructsT, + pub a: StructOfStructsT, } impl StructOfStructsOfStructsT { - pub fn pack(&self) -> StructOfStructsOfStructs { - StructOfStructsOfStructs::new( - &self.a.pack(), - ) - } + pub fn pack(&self) -> StructOfStructsOfStructs { + StructOfStructsOfStructs::new( + &self.a.pack(), + ) + } } diff --git a/tests/monster_test/my_game/example/test_generated.rs b/tests/monster_test/my_game/example/test_generated.rs index a5984a9de..b71376475 100644 --- a/tests/monster_test/my_game/example/test_generated.rs +++ b/tests/monster_test/my_game/example/test_generated.rs @@ -8,39 +8,39 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Test(pub [u8; 4]); -impl Default for Test { - fn default() -> Self { - Self([0; 4]) - } +impl Default for Test { + fn default() -> Self { + Self([0; 4]) + } } impl ::core::fmt::Debug for Test { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Test") - .field("a", &self.a()) - .field("b", &self.b()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Test") + .field("a", &self.a()) + .field("b", &self.b()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Test {} impl<'a> ::flatbuffers::Follow<'a> for Test { - type Inner = &'a Test; + type Inner = &'a Test; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Test>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Test>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Test { - type Inner = &'a Test; + type Inner = &'a Test; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Test { @@ -59,107 +59,107 @@ impl<'b> ::flatbuffers::Push for Test { } impl<'a> ::flatbuffers::Verifiable for Test { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i16) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[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 fn b(&self) -> i8 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[2..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_b(&mut self, x: i8) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[2..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Test" } - } - pub fn unpack(&self) -> TestT { - TestT { - a: self.a(), - b: self.b(), + pub fn a(&self) -> i16 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i16) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn b(&self) -> i8 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[2..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_b(&mut self, x: i8) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[2..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + 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, + pub a: i16, + pub b: i8, } impl TestT { - pub fn pack(&self) -> Test { - Test::new( - self.a, - self.b, - ) - } + pub fn pack(&self) -> Test { + Test::new( + self.a, + self.b, + ) + } } diff --git a/tests/monster_test/my_game/example/test_simple_table_with_enum_generated.rs b/tests/monster_test/my_game/example/test_simple_table_with_enum_generated.rs index d00ad65ff..bbb18acbd 100644 --- a/tests/monster_test/my_game/example/test_simple_table_with_enum_generated.rs +++ b/tests/monster_test/my_game/example/test_simple_table_with_enum_generated.rs @@ -7,66 +7,66 @@ pub enum TestSimpleTableWithEnumOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TestSimpleTableWithEnum<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TestSimpleTableWithEnum<'a> { - type Inner = TestSimpleTableWithEnum<'a>; + type Inner = TestSimpleTableWithEnum<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TestSimpleTableWithEnum<'a> { - pub const VT_COLOR: ::flatbuffers::VOffsetT = 4; + pub const VT_COLOR: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.TestSimpleTableWithEnum" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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 fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.TestSimpleTableWithEnum" } - } - #[inline] - pub fn color(&self) -> Color { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TestSimpleTableWithEnum::VT_COLOR, Some(Color::Green)).unwrap()} - } + #[inline] + pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + 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, + } + } + + #[inline] + pub fn color(&self) -> Color { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { 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> { - v.visit_table(pos)? - .visit_field::("color", Self::VT_COLOR, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("color", Self::VT_COLOR, false)? + .finish(); + Ok(()) + } } pub struct TestSimpleTableWithEnumArgs { @@ -74,71 +74,71 @@ pub struct TestSimpleTableWithEnumArgs { } impl<'a> Default for TestSimpleTableWithEnumArgs { - #[inline] - fn default() -> Self { - TestSimpleTableWithEnumArgs { - color: Color::Green, + #[inline] + fn default() -> Self { + TestSimpleTableWithEnumArgs { + color: Color::Green, + } } - } } pub struct TestSimpleTableWithEnumBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TestSimpleTableWithEnumBuilder<'a, 'b, A> { - #[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, A>) -> TestSimpleTableWithEnumBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TestSimpleTableWithEnumBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_color(&mut self, color: Color) { + self.fbb_.push_slot::(TestSimpleTableWithEnum::VT_COLOR, color, Color::Green); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TestSimpleTableWithEnumBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for TestSimpleTableWithEnum<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TestSimpleTableWithEnum"); - ds.field("color", &self.color()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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, + pub color: Color, } impl Default for TestSimpleTableWithEnumT { - fn default() -> Self { - Self { - color: Color::Green, + fn default() -> Self { + Self { + color: Color::Green, + } } - } } impl TestSimpleTableWithEnumT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let color = self.color; - TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{ - color, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let color = self.color; + TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{ + color, + }) + } } diff --git a/tests/monster_test/my_game/example/type_aliases_generated.rs b/tests/monster_test/my_game/example/type_aliases_generated.rs index 9ef6c101a..35d064d05 100644 --- a/tests/monster_test/my_game/example/type_aliases_generated.rs +++ b/tests/monster_test/my_game/example/type_aliases_generated.rs @@ -7,213 +7,213 @@ pub enum TypeAliasesOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TypeAliases<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TypeAliases<'a> { - type Inner = TypeAliases<'a>; + type Inner = TypeAliases<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TypeAliases<'a> { - 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; + 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; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.TypeAliases" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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.into_iter().collect() - }); - 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 fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.TypeAliases" } - } - #[inline] - pub fn i8_(&self) -> i8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I8_, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TypeAliases { _tab: table } + } - #[inline] - pub fn u8_(&self) -> u8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U8_, Some(0)).unwrap()} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + 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() + } - #[inline] - pub fn i16_(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I16_, Some(0)).unwrap()} - } + 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.into_iter().collect() + }); + let vf64 = self.vf64().map(|x| { + x.into_iter().collect() + }); + TypeAliasesT { + i8_, + u8_, + i16_, + u16_, + i32_, + u32_, + i64_, + u64_, + f32_, + f64_, + v8, + vf64, + } + } - #[inline] - pub fn u16_(&self) -> u16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U16_, Some(0)).unwrap()} - } + #[inline] + pub fn i8_(&self) -> i8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I8_, Some(0)).unwrap()} + } - #[inline] - pub fn i32_(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I32_, Some(0)).unwrap()} - } + #[inline] + pub fn u8_(&self) -> u8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U8_, Some(0)).unwrap()} + } - #[inline] - pub fn u32_(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U32_, Some(0)).unwrap()} - } + #[inline] + pub fn i16_(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I16_, Some(0)).unwrap()} + } - #[inline] - pub fn i64_(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I64_, Some(0)).unwrap()} - } + #[inline] + pub fn u16_(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U16_, Some(0)).unwrap()} + } - #[inline] - pub fn u64_(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U64_, Some(0)).unwrap()} - } + #[inline] + pub fn i32_(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I32_, Some(0)).unwrap()} + } - #[inline] - pub fn f32_(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_F32_, Some(0.0)).unwrap()} - } + #[inline] + pub fn u32_(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U32_, Some(0)).unwrap()} + } - #[inline] - pub fn f64_(&self) -> f64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_F64_, Some(0.0)).unwrap()} - } + #[inline] + pub fn i64_(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I64_, Some(0)).unwrap()} + } - #[inline] - pub fn v8(&self) -> Option<::flatbuffers::Vector<'a, i8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i8>>>(TypeAliases::VT_V8, None)} - } + #[inline] + pub fn u64_(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U64_, Some(0)).unwrap()} + } - #[inline] - pub fn vf64(&self) -> Option<::flatbuffers::Vector<'a, f64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(TypeAliases::VT_VF64, None)} - } + #[inline] + pub fn f32_(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_F32_, Some(0.0)).unwrap()} + } + + #[inline] + pub fn f64_(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_F64_, Some(0.0)).unwrap()} + } + + #[inline] + pub fn v8(&self) -> Option<::flatbuffers::Vector<'a, i8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i8>>>(TypeAliases::VT_V8, None)} + } + + #[inline] + pub fn vf64(&self) -> Option<::flatbuffers::Vector<'a, f64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(TypeAliases::VT_VF64, None)} + } } impl ::flatbuffers::Verifiable for TypeAliases<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - 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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i8>>>("v8", Self::VT_V8, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vf64", Self::VT_VF64, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i8>>>("v8", Self::VT_V8, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vf64", Self::VT_VF64, false)? + .finish(); + Ok(()) + } } pub struct TypeAliasesArgs<'a> { @@ -232,196 +232,196 @@ pub struct TypeAliasesArgs<'a> { } 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, + #[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, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TypeAliasesBuilder<'a, 'b, A> { - #[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<::flatbuffers::Vector<'b , i8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_V8, v8); - } - - #[inline] - pub fn add_vf64(&mut self, vf64: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TypeAliasesBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TypeAliasesBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_i8_(&mut self, i8_: i8) { + self.fbb_.push_slot::(TypeAliases::VT_I8_, i8_, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[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<::flatbuffers::Vector<'b , i8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_V8, v8); + } + + #[inline] + pub fn add_vf64(&mut self, vf64: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TypeAliasesBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for TypeAliases<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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>, + 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, + 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, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::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, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::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, + }) + } } diff --git a/tests/monster_test/my_game/example/vec_3_generated.rs b/tests/monster_test/my_game/example/vec_3_generated.rs index 1a2c4cd23..23ed77161 100644 --- a/tests/monster_test/my_game/example/vec_3_generated.rs +++ b/tests/monster_test/my_game/example/vec_3_generated.rs @@ -8,43 +8,43 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Vec3(pub [u8; 32]); -impl Default for Vec3 { - fn default() -> Self { - Self([0; 32]) - } +impl Default for Vec3 { + fn default() -> Self { + Self([0; 32]) + } } impl ::core::fmt::Debug for Vec3 { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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<'a> ::flatbuffers::Follow<'a> for Vec3 { - type Inner = &'a Vec3; + type Inner = &'a Vec3; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Vec3>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Vec3>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Vec3 { - type Inner = &'a Vec3; + type Inner = &'a Vec3; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Vec3 { @@ -63,226 +63,226 @@ impl<'b> ::flatbuffers::Push for Vec3 { } impl<'a> ::flatbuffers::Verifiable for Vec3 { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_x(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[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 fn y(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[4..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_y(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[4..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Vec3" } - } - pub fn z(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[8..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_z(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[8..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn x(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) } - } - pub fn test1(&self) -> f64 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[16..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_test1(&mut self, x: f64) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[16..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn set_x(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } } - } - pub fn test2(&self) -> Color { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[24..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_test2(&mut self, x: Color) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[24..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn y(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[4..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) } - } - pub fn test3(&self) -> &Test { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[26..].as_ptr() as *const Test) } - } - - #[allow(clippy::identity_op)] - 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(), + pub fn set_y(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[4..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn z(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[8..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_z(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[8..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn test1(&self) -> f64 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[16..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_test1(&mut self, x: f64) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[16..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn test2(&self) -> Color { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[24..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_test2(&mut self, x: Color) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[24..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn test3(&self) -> &Test { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[26..].as_ptr() as *const Test) } + } + + #[allow(clippy::identity_op)] + 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, + 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(), - ) - } + pub fn pack(&self) -> Vec3 { + Vec3::new( + self.x, + self.y, + self.z, + self.test1, + self.test2, + &self.test3.pack(), + ) + } } diff --git a/tests/monster_test/my_game/example_2/monster_generated.rs b/tests/monster_test/my_game/example_2/monster_generated.rs index 6e142f106..c908f0a2b 100644 --- a/tests/monster_test/my_game/example_2/monster_generated.rs +++ b/tests/monster_test/my_game/example_2/monster_generated.rs @@ -7,92 +7,92 @@ pub enum MonsterOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Monster<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> { - type Inner = Monster<'a>; + type Inner = Monster<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Monster<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example2.Monster" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args MonsterArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = MonsterBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> MonsterT { - MonsterT { + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example2.Monster" + } + + #[inline] + pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _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> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct MonsterArgs { } impl<'a> Default for MonsterArgs { - #[inline] - fn default() -> Self { - MonsterArgs { + #[inline] + fn default() -> Self { + MonsterArgs { + } } - } } pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - MonsterBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { + 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()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for Monster<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Monster"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Monster"); + ds.finish() + } } #[non_exhaustive] @@ -101,18 +101,18 @@ pub struct MonsterT { } impl Default for MonsterT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl MonsterT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - Monster::create(_fbb, &MonsterArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + Monster::create(_fbb, &MonsterArgs{ + }) + } } diff --git a/tests/monster_test/my_game/in_parent_namespace_generated.rs b/tests/monster_test/my_game/in_parent_namespace_generated.rs index 9911d3d08..72c1ed530 100644 --- a/tests/monster_test/my_game/in_parent_namespace_generated.rs +++ b/tests/monster_test/my_game/in_parent_namespace_generated.rs @@ -7,92 +7,92 @@ pub enum InParentNamespaceOffset {} #[derive(Copy, Clone, PartialEq)] pub struct InParentNamespace<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for InParentNamespace<'a> { - type Inner = InParentNamespace<'a>; + type Inner = InParentNamespace<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> InParentNamespace<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.InParentNamespace" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args InParentNamespaceArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = InParentNamespaceBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> InParentNamespaceT { - InParentNamespaceT { + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.InParentNamespace" + } + + #[inline] + pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _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> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct InParentNamespaceArgs { } impl<'a> Default for InParentNamespaceArgs { - #[inline] - fn default() -> Self { - InParentNamespaceArgs { + #[inline] + fn default() -> Self { + InParentNamespaceArgs { + } } - } } pub struct InParentNamespaceBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> InParentNamespaceBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> InParentNamespaceBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - InParentNamespaceBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> InParentNamespaceBuilder<'a, 'b, A> { + 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()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for InParentNamespace<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("InParentNamespace"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("InParentNamespace"); + ds.finish() + } } #[non_exhaustive] @@ -101,18 +101,18 @@ pub struct InParentNamespaceT { } impl Default for InParentNamespaceT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl InParentNamespaceT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - InParentNamespace::create(_fbb, &InParentNamespaceArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + InParentNamespace::create(_fbb, &InParentNamespaceArgs{ + }) + } } diff --git a/tests/monster_test/my_game/other_name_space/from_include_generated.rs b/tests/monster_test/my_game/other_name_space/from_include_generated.rs index 4e03e2dec..ada294725 100644 --- a/tests/monster_test/my_game/other_name_space/from_include_generated.rs +++ b/tests/monster_test/my_game/other_name_space/from_include_generated.rs @@ -12,7 +12,7 @@ pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; #[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_FROM_INCLUDE: [FromInclude; 1] = [ - FromInclude::IncludeVal, + FromInclude::IncludeVal, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -21,41 +21,41 @@ pub struct FromInclude(pub i64); #[allow(non_upper_case_globals)] impl FromInclude { - pub const IncludeVal: Self = Self(0); + pub const IncludeVal: Self = Self(0); - pub const ENUM_MIN: i64 = 0; - pub const ENUM_MAX: i64 = 0; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::IncludeVal, - ]; + pub const ENUM_MIN: i64 = 0; + pub const ENUM_MAX: i64 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::IncludeVal, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::IncludeVal => Some("IncludeVal"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::IncludeVal => Some("IncludeVal"), + _ => None, + } } - } } impl ::core::fmt::Debug for FromInclude { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 FromInclude { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for FromInclude { @@ -68,28 +68,28 @@ impl ::flatbuffers::Push for FromInclude { } impl ::flatbuffers::EndianScalar for FromInclude { - type Scalar = i64; + type Scalar = i64; - #[inline] - fn to_little_endian(self) -> i64 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i64 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i64) -> Self { - let b = i64::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i64) -> Self { + let b = i64::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for FromInclude { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i64::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i64::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} diff --git a/tests/monster_test/my_game/other_name_space/table_b_generated.rs b/tests/monster_test/my_game/other_name_space/table_b_generated.rs index 5e969c2dc..5434e448a 100644 --- a/tests/monster_test/my_game/other_name_space/table_b_generated.rs +++ b/tests/monster_test/my_game/other_name_space/table_b_generated.rs @@ -7,68 +7,68 @@ pub enum TableBOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableB<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { - type Inner = TableB<'a>; + type Inner = TableB<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableB<'a> { - pub const VT_A: ::flatbuffers::VOffsetT = 4; + pub const VT_A: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.TableB" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableB { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableBArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableBBuilder::new(_fbb); - if let Some(x) = args.a { builder.add_a(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableBT { - let a = self.a().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableBT { - a, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.TableB" } - } - #[inline] - pub fn a(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableB { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableBArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableBBuilder::new(_fbb); + if let Some(x) = args.a { builder.add_a(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableBT { + let a = self.a().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableBT { + a, + } + } + + #[inline] + pub fn a(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} + } } impl ::flatbuffers::Verifiable for TableB<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? + .finish(); + Ok(()) + } } pub struct TableBArgs<'a> { @@ -76,73 +76,73 @@ pub struct TableBArgs<'a> { } impl<'a> Default for TableBArgs<'a> { - #[inline] - fn default() -> Self { - TableBArgs { - a: None, + #[inline] + fn default() -> Self { + TableBArgs { + a: None, + } } - } } pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { - #[inline] - pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableBBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableBBuilder { + 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 ::core::fmt::Debug for TableB<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableB"); - ds.field("a", &self.a()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableB"); + ds.field("a", &self.a()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableBT { - pub a: Option>, + pub a: Option>, } impl Default for TableBT { - fn default() -> Self { - Self { - a: None, + fn default() -> Self { + Self { + a: None, + } } - } } impl TableBT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let a = self.a.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableB::create(_fbb, &TableBArgs{ - a, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let a = self.a.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableB::create(_fbb, &TableBArgs{ + a, + }) + } } diff --git a/tests/monster_test/my_game/other_name_space/unused_generated.rs b/tests/monster_test/my_game/other_name_space/unused_generated.rs index e8639acf2..12f7fa768 100644 --- a/tests/monster_test/my_game/other_name_space/unused_generated.rs +++ b/tests/monster_test/my_game/other_name_space/unused_generated.rs @@ -8,38 +8,38 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Unused(pub [u8; 4]); -impl Default for Unused { - fn default() -> Self { - Self([0; 4]) - } +impl Default for Unused { + fn default() -> Self { + Self([0; 4]) + } } impl ::core::fmt::Debug for Unused { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Unused") - .field("a", &self.a()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Unused") + .field("a", &self.a()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} impl<'a> ::flatbuffers::Follow<'a> for Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Unused>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Unused>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Unused { @@ -58,73 +58,73 @@ impl<'b> ::flatbuffers::Push for Unused { } impl<'a> ::flatbuffers::Verifiable for Unused { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> Unused { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: i32, - ) -> Self { - let mut s = Self([0; 4]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.Unused" - } - - pub fn a(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + a: i32, + ) -> Self { + let mut s = Self([0; 4]); + s.set_a(a); + s } - } - pub fn unpack(&self) -> UnusedT { - UnusedT { - a: self.a(), + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.Unused" + } + + pub fn a(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> UnusedT { + UnusedT { + a: self.a(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct UnusedT { - pub a: i32, + pub a: i32, } impl UnusedT { - pub fn pack(&self) -> Unused { - Unused::new( - self.a, - ) - } + pub fn pack(&self) -> Unused { + Unused::new( + self.a, + ) + } } diff --git a/tests/monster_test/table_a_generated.rs b/tests/monster_test/table_a_generated.rs index 2558b8406..467c514a1 100644 --- a/tests/monster_test/table_a_generated.rs +++ b/tests/monster_test/table_a_generated.rs @@ -7,68 +7,68 @@ pub enum TableAOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableA<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> { - type Inner = TableA<'a>; + type Inner = TableA<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableA<'a> { - pub const VT_B: ::flatbuffers::VOffsetT = 4; + pub const VT_B: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "TableA" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableA { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableAArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableABuilder::new(_fbb); - if let Some(x) = args.b { builder.add_b(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableAT { - let b = self.b().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableAT { - b, + pub const fn get_fully_qualified_name() -> &'static str { + "TableA" } - } - #[inline] - pub fn b(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableA { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableAArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableABuilder::new(_fbb); + if let Some(x) = args.b { builder.add_b(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableAT { + let b = self.b().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableAT { + b, + } + } + + #[inline] + pub fn b(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} + } } impl ::flatbuffers::Verifiable for TableA<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? + .finish(); + Ok(()) + } } pub struct TableAArgs<'a> { @@ -76,73 +76,73 @@ pub struct TableAArgs<'a> { } impl<'a> Default for TableAArgs<'a> { - #[inline] - fn default() -> Self { - TableAArgs { - b: None, + #[inline] + fn default() -> Self { + TableAArgs { + b: None, + } } - } } pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> { - #[inline] - pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableABuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableABuilder { + 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 ::core::fmt::Debug for TableA<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableA"); - ds.field("b", &self.b()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableA"); + ds.field("b", &self.b()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableAT { - pub b: Option>, + pub b: Option>, } impl Default for TableAT { - fn default() -> Self { - Self { - b: None, + fn default() -> Self { + Self { + b: None, + } } - } } impl TableAT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let b = self.b.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableA::create(_fbb, &TableAArgs{ - b, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let b = self.b.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableA::create(_fbb, &TableAArgs{ + b, + }) + } } diff --git a/tests/monster_test_serialize/mod.rs b/tests/monster_test_serialize/mod.rs index 7f1fab136..27af0f287 100644 --- a/tests/monster_test_serialize/mod.rs +++ b/tests/monster_test_serialize/mod.rs @@ -1,58 +1,58 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod my_game { - use super::*; - pub mod example { use super::*; - mod color_generated; - pub use self::color_generated::*; - mod race_generated; - pub use self::race_generated::*; - mod long_enum_generated; - pub use self::long_enum_generated::*; - mod any_generated; - pub use self::any_generated::*; - mod any_unique_aliases_generated; - pub use self::any_unique_aliases_generated::*; - mod any_ambiguous_aliases_generated; - pub use self::any_ambiguous_aliases_generated::*; - mod test_generated; - pub use self::test_generated::*; - mod test_simple_table_with_enum_generated; - pub use self::test_simple_table_with_enum_generated::*; - mod vec_3_generated; - pub use self::vec_3_generated::*; - mod ability_generated; - pub use self::ability_generated::*; - mod struct_of_structs_generated; - pub use self::struct_of_structs_generated::*; - mod struct_of_structs_of_structs_generated; - pub use self::struct_of_structs_of_structs_generated::*; - mod stat_generated; - pub use self::stat_generated::*; - mod referrable_generated; - pub use self::referrable_generated::*; - mod monster_generated; - pub use self::monster_generated::*; - mod type_aliases_generated; - pub use self::type_aliases_generated::*; - } // example - pub mod example_2 { - use super::*; - mod monster_generated; - pub use self::monster_generated::*; - } // example_2 - pub mod other_name_space { - use super::*; - mod from_include_generated; - pub use self::from_include_generated::*; - mod unused_generated; - pub use self::unused_generated::*; - mod table_b_generated; - pub use self::table_b_generated::*; - } // other_name_space - mod in_parent_namespace_generated; - pub use self::in_parent_namespace_generated::*; + pub mod example { + use super::*; + mod color_generated; + pub use self::color_generated::*; + mod race_generated; + pub use self::race_generated::*; + mod long_enum_generated; + pub use self::long_enum_generated::*; + mod any_generated; + pub use self::any_generated::*; + mod any_unique_aliases_generated; + pub use self::any_unique_aliases_generated::*; + mod any_ambiguous_aliases_generated; + pub use self::any_ambiguous_aliases_generated::*; + mod test_generated; + pub use self::test_generated::*; + mod test_simple_table_with_enum_generated; + pub use self::test_simple_table_with_enum_generated::*; + mod vec_3_generated; + pub use self::vec_3_generated::*; + mod ability_generated; + pub use self::ability_generated::*; + mod struct_of_structs_generated; + pub use self::struct_of_structs_generated::*; + mod struct_of_structs_of_structs_generated; + pub use self::struct_of_structs_of_structs_generated::*; + mod stat_generated; + pub use self::stat_generated::*; + mod referrable_generated; + pub use self::referrable_generated::*; + mod monster_generated; + pub use self::monster_generated::*; + mod type_aliases_generated; + pub use self::type_aliases_generated::*; + } // example + pub mod example_2 { + use super::*; + mod monster_generated; + pub use self::monster_generated::*; + } // example_2 + pub mod other_name_space { + use super::*; + mod from_include_generated; + pub use self::from_include_generated::*; + mod unused_generated; + pub use self::unused_generated::*; + mod table_b_generated; + pub use self::table_b_generated::*; + } // other_name_space + mod in_parent_namespace_generated; + pub use self::in_parent_namespace_generated::*; } // my_game mod table_a_generated; pub use self::table_a_generated::*; diff --git a/tests/monster_test_serialize/my_game/example/ability_generated.rs b/tests/monster_test_serialize/my_game/example/ability_generated.rs index 1e1aebc8f..0c866a584 100644 --- a/tests/monster_test_serialize/my_game/example/ability_generated.rs +++ b/tests/monster_test_serialize/my_game/example/ability_generated.rs @@ -10,39 +10,39 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Ability(pub [u8; 8]); -impl Default for Ability { - fn default() -> Self { - Self([0; 8]) - } +impl Default for Ability { + fn default() -> Self { + Self([0; 8]) + } } impl ::core::fmt::Debug for Ability { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Ability") - .field("id", &self.id()) - .field("distance", &self.distance()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Ability") + .field("id", &self.id()) + .field("distance", &self.distance()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Ability {} impl<'a> ::flatbuffers::Follow<'a> for Ability { - type Inner = &'a Ability; + type Inner = &'a Ability; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Ability>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Ability>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Ability { - type Inner = &'a Ability; + type Inner = &'a Ability; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Ability { @@ -61,130 +61,130 @@ impl<'b> ::flatbuffers::Push for Ability { } impl<'a> ::flatbuffers::Verifiable for Ability { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl Serialize for Ability { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { let mut s = serializer.serialize_struct("Ability", 2)?; - s.serialize_field("id", &self.id())?; - s.serialize_field("distance", &self.distance())?; - s.end() - } + s.serialize_field("id", &self.id())?; + s.serialize_field("distance", &self.distance())?; + s.end() + } } 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::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_id(&mut self, x: u32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[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 } - } - - #[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) -> ::core::cmp::Ordering { - let key = self.id(); - key.cmp(&val) - } - pub fn distance(&self) -> u32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[4..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_distance(&mut self, x: u32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[4..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Ability" } - } - pub fn unpack(&self) -> AbilityT { - AbilityT { - id: self.id(), - distance: self.distance(), + pub fn id(&self) -> u32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_id(&mut self, x: u32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + + #[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) -> ::core::cmp::Ordering { + let key = self.id(); + key.cmp(&val) + } + pub fn distance(&self) -> u32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[4..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_distance(&mut self, x: u32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[4..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + 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, + pub id: u32, + pub distance: u32, } impl AbilityT { - pub fn pack(&self) -> Ability { - Ability::new( - self.id, - self.distance, - ) - } + pub fn pack(&self) -> Ability { + Ability::new( + self.id, + self.distance, + ) + } } diff --git a/tests/monster_test_serialize/my_game/example/any_ambiguous_aliases_generated.rs b/tests/monster_test_serialize/my_game/example/any_ambiguous_aliases_generated.rs index ec6c62cc0..415961c78 100644 --- a/tests/monster_test_serialize/my_game/example/any_ambiguous_aliases_generated.rs +++ b/tests/monster_test_serialize/my_game/example/any_ambiguous_aliases_generated.rs @@ -14,10 +14,10 @@ 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, + AnyAmbiguousAliases::NONE, + AnyAmbiguousAliases::M1, + AnyAmbiguousAliases::M2, + AnyAmbiguousAliases::M3, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -26,49 +26,49 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for AnyAmbiguousAliases { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } } - } } impl Serialize for AnyAmbiguousAliases { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_unit_variant("AnyAmbiguousAliases", self.0 as u32, self.variant_name().unwrap()) - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_unit_variant("AnyAmbiguousAliases", self.0 as u32, self.variant_name().unwrap()) + } } impl<'de> serde::Deserialize<'de> for AnyAmbiguousAliases { @@ -91,13 +91,13 @@ impl<'de> serde::Deserialize<'de> for AnyAmbiguousAliases { } impl<'a> ::flatbuffers::Follow<'a> for AnyAmbiguousAliases { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -110,28 +110,28 @@ impl ::flatbuffers::Push for AnyAmbiguousAliases { } impl ::flatbuffers::EndianScalar for AnyAmbiguousAliases { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for AnyAmbiguousAliases { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for AnyAmbiguousAliases {} @@ -142,107 +142,107 @@ pub struct AnyAmbiguousAliasesUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyAmbiguousAliasesT { - NONE, - M1(alloc::boxed::Box), - M2(alloc::boxed::Box), - M3(alloc::boxed::Box), + NONE, + M1(alloc::boxed::Box), + M2(alloc::boxed::Box), + M3(alloc::boxed::Box), } impl Default for AnyAmbiguousAliasesT { - fn default() -> Self { - Self::NONE - } + 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 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<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - 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()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M1(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// 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 = ::core::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 = ::core::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_m1(&self) -> Option<&MonsterT> { + if let Self::M1(v) = self { Some(v.as_ref()) } 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M3(w) = v { - Some(w) - } else { - unreachable!() - } - } 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 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 the owned MonsterT, setting the union to NONE. + pub fn take_m2(&mut self) -> Option> { + if let Self::M2(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::M2(w) = v { + Some(w) + } else { + unreachable!() + } + } 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 } - } + /// 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 = ::core::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 } + } } diff --git a/tests/monster_test_serialize/my_game/example/any_generated.rs b/tests/monster_test_serialize/my_game/example/any_generated.rs index 0f5be1a87..5f4ab10c0 100644 --- a/tests/monster_test_serialize/my_game/example/any_generated.rs +++ b/tests/monster_test_serialize/my_game/example/any_generated.rs @@ -14,10 +14,10 @@ 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, + Any::NONE, + Any::Monster, + Any::TestSimpleTableWithEnum, + Any::MyGame_Example2_Monster, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -26,49 +26,49 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for Any { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } } - } } impl Serialize for Any { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_unit_variant("Any", self.0 as u32, self.variant_name().unwrap()) - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_unit_variant("Any", self.0 as u32, self.variant_name().unwrap()) + } } impl<'de> serde::Deserialize<'de> for Any { @@ -91,13 +91,13 @@ impl<'de> serde::Deserialize<'de> for Any { } impl<'a> ::flatbuffers::Follow<'a> for Any { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -110,28 +110,28 @@ impl ::flatbuffers::Push for Any { } impl ::flatbuffers::EndianScalar for Any { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for Any { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Any {} @@ -142,107 +142,107 @@ pub struct AnyUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyT { - NONE, - Monster(alloc::boxed::Box), - TestSimpleTableWithEnum(alloc::boxed::Box), - MyGameExample2Monster(alloc::boxed::Box), + NONE, + Monster(alloc::boxed::Box), + TestSimpleTableWithEnum(alloc::boxed::Box), + MyGameExample2Monster(alloc::boxed::Box), } impl Default for AnyT { - fn default() -> Self { - Self::NONE - } + 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 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<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - 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()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + 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 = ::core::mem::replace(self, Self::NONE); - if let Self::Monster(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// 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 = ::core::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 = ::core::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 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 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 = ::core::mem::replace(self, Self::NONE); - if let Self::MyGameExample2Monster(w) = v { - Some(w) - } else { - unreachable!() - } - } 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 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 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 = ::core::mem::replace(self, Self::NONE); + if let Self::TestSimpleTableWithEnum(w) = v { + Some(w) + } else { + unreachable!() + } + } 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 } - } + /// 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 = ::core::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 } + } } diff --git a/tests/monster_test_serialize/my_game/example/any_unique_aliases_generated.rs b/tests/monster_test_serialize/my_game/example/any_unique_aliases_generated.rs index 067f2f620..12286c683 100644 --- a/tests/monster_test_serialize/my_game/example/any_unique_aliases_generated.rs +++ b/tests/monster_test_serialize/my_game/example/any_unique_aliases_generated.rs @@ -14,10 +14,10 @@ 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, + AnyUniqueAliases::NONE, + AnyUniqueAliases::M, + AnyUniqueAliases::TS, + AnyUniqueAliases::M2, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -26,49 +26,49 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for AnyUniqueAliases { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } } - } } impl Serialize for AnyUniqueAliases { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_unit_variant("AnyUniqueAliases", self.0 as u32, self.variant_name().unwrap()) - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_unit_variant("AnyUniqueAliases", self.0 as u32, self.variant_name().unwrap()) + } } impl<'de> serde::Deserialize<'de> for AnyUniqueAliases { @@ -91,13 +91,13 @@ impl<'de> serde::Deserialize<'de> for AnyUniqueAliases { } impl<'a> ::flatbuffers::Follow<'a> for AnyUniqueAliases { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -110,28 +110,28 @@ impl ::flatbuffers::Push for AnyUniqueAliases { } impl ::flatbuffers::EndianScalar for AnyUniqueAliases { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for AnyUniqueAliases { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for AnyUniqueAliases {} @@ -142,107 +142,107 @@ pub struct AnyUniqueAliasesUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum AnyUniqueAliasesT { - NONE, - M(alloc::boxed::Box), - TS(alloc::boxed::Box), - M2(alloc::boxed::Box), + NONE, + M(alloc::boxed::Box), + TS(alloc::boxed::Box), + M2(alloc::boxed::Box), } impl Default for AnyUniqueAliasesT { - fn default() -> Self { - Self::NONE - } + 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 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<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - 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()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// 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 = ::core::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 = ::core::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 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 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 = ::core::mem::replace(self, Self::NONE); - if let Self::M2(w) = v { - Some(w) - } else { - unreachable!() - } - } 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 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 the owned TestSimpleTableWithEnumT, setting the union to NONE. + pub fn take_ts(&mut self) -> Option> { + if let Self::TS(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::TS(w) = v { + Some(w) + } else { + unreachable!() + } + } 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 } - } + /// 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 = ::core::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 } + } } diff --git a/tests/monster_test_serialize/my_game/example/color_generated.rs b/tests/monster_test_serialize/my_game/example/color_generated.rs index bfcfd8354..12ea6d5aa 100644 --- a/tests/monster_test_serialize/my_game/example/color_generated.rs +++ b/tests/monster_test_serialize/my_game/example/color_generated.rs @@ -7,39 +7,39 @@ use super::*; #[allow(non_upper_case_globals)] mod bitflags_color { - ::flatbuffers::bitflags::bitflags! { - /// Composite components of Monster color. - #[derive(Default, Debug, Clone, Copy, PartialEq)] - 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; + ::flatbuffers::bitflags::bitflags! { + /// Composite components of Monster color. + #[derive(Default, Debug, Clone, Copy, PartialEq)] + 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 Serialize for Color { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_u32(self.bits() as u32) - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_u32(self.bits() as u32) + } } impl<'a> ::flatbuffers::Follow<'a> for Color { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self::from_bits_retain(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self::from_bits_retain(b) + } } impl ::flatbuffers::Push for Color { @@ -52,28 +52,28 @@ impl ::flatbuffers::Push for Color { } impl ::flatbuffers::EndianScalar for Color { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.bits().to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.bits().to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self::from_bits_retain(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self::from_bits_retain(b) + } } impl<'a> ::flatbuffers::Verifiable for Color { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Color {} diff --git a/tests/monster_test_serialize/my_game/example/long_enum_generated.rs b/tests/monster_test_serialize/my_game/example/long_enum_generated.rs index 0d0071637..90ad8e4f5 100644 --- a/tests/monster_test_serialize/my_game/example/long_enum_generated.rs +++ b/tests/monster_test_serialize/my_game/example/long_enum_generated.rs @@ -7,35 +7,35 @@ use super::*; #[allow(non_upper_case_globals)] mod bitflags_long_enum { - ::flatbuffers::bitflags::bitflags! { - #[derive(Default, Debug, Clone, Copy, PartialEq)] - pub struct LongEnum: u64 { - const LongOne = 2; - const LongTwo = 4; - const LongBig = 1099511627776; + ::flatbuffers::bitflags::bitflags! { + #[derive(Default, Debug, Clone, Copy, PartialEq)] + pub struct LongEnum: u64 { + const LongOne = 2; + const LongTwo = 4; + const LongBig = 1099511627776; + } } - } } pub use self::bitflags_long_enum::LongEnum; impl Serialize for LongEnum { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_u32(self.bits() as u32) - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_u32(self.bits() as u32) + } } impl<'a> ::flatbuffers::Follow<'a> for LongEnum { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self::from_bits_retain(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self::from_bits_retain(b) + } } impl ::flatbuffers::Push for LongEnum { @@ -48,28 +48,28 @@ impl ::flatbuffers::Push for LongEnum { } impl ::flatbuffers::EndianScalar for LongEnum { - type Scalar = u64; + type Scalar = u64; - #[inline] - fn to_little_endian(self) -> u64 { - self.bits().to_le() - } + #[inline] + fn to_little_endian(self) -> u64 { + self.bits().to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u64) -> Self { - let b = u64::from_le(v); - Self::from_bits_retain(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u64) -> Self { + let b = u64::from_le(v); + Self::from_bits_retain(b) + } } impl<'a> ::flatbuffers::Verifiable for LongEnum { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u64::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u64::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for LongEnum {} diff --git a/tests/monster_test_serialize/my_game/example/monster_generated.rs b/tests/monster_test_serialize/my_game/example/monster_generated.rs index 1f8128c1c..26652e1c9 100644 --- a/tests/monster_test_serialize/my_game/example/monster_generated.rs +++ b/tests/monster_test_serialize/my_game/example/monster_generated.rs @@ -10,1133 +10,1133 @@ pub enum MonsterOffset {} /// an example documentation comment: "monster object" #[derive(Copy, Clone, PartialEq)] pub struct Monster<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> { - type Inner = Monster<'a>; + type Inner = Monster<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Monster<'a> { - 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; - pub const VT_NATIVE_INLINE: ::flatbuffers::VOffsetT = 106; - pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: ::flatbuffers::VOffsetT = 108; - pub const VT_LONG_ENUM_NORMAL_DEFAULT: ::flatbuffers::VOffsetT = 110; - pub const VT_NAN_DEFAULT: ::flatbuffers::VOffsetT = 112; - pub const VT_INF_DEFAULT: ::flatbuffers::VOffsetT = 114; - pub const VT_POSITIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 116; - pub const VT_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 118; - pub const VT_POSITIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 120; - pub const VT_NEGATIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 122; - pub const VT_NEGATIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 124; - pub const VT_DOUBLE_INF_DEFAULT: ::flatbuffers::VOffsetT = 126; + 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; + pub const VT_NATIVE_INLINE: ::flatbuffers::VOffsetT = 106; + pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: ::flatbuffers::VOffsetT = 108; + pub const VT_LONG_ENUM_NORMAL_DEFAULT: ::flatbuffers::VOffsetT = 110; + pub const VT_NAN_DEFAULT: ::flatbuffers::VOffsetT = 112; + pub const VT_INF_DEFAULT: ::flatbuffers::VOffsetT = 114; + pub const VT_POSITIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 116; + pub const VT_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 118; + pub const VT_POSITIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 120; + pub const VT_NEGATIVE_INF_DEFAULT: ::flatbuffers::VOffsetT = 122; + pub const VT_NEGATIVE_INFINITY_DEFAULT: ::flatbuffers::VOffsetT = 124; + pub const VT_DOUBLE_INF_DEFAULT: ::flatbuffers::VOffsetT = 126; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.Monster" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args MonsterArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = MonsterBuilder::new(_fbb); - builder.add_double_inf_default(args.double_inf_default); - builder.add_long_enum_normal_default(args.long_enum_normal_default); - builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default); - 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); - builder.add_negative_infinity_default(args.negative_infinity_default); - builder.add_negative_inf_default(args.negative_inf_default); - builder.add_positive_infinity_default(args.positive_infinity_default); - builder.add_infinity_default(args.infinity_default); - builder.add_positive_inf_default(args.positive_inf_default); - builder.add_inf_default(args.inf_default); - builder.add_nan_default(args.nan_default); - if let Some(x) = args.native_inline { builder.add_native_inline(x); } - 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(); - alloc::string::ToString::to_string(x) - }; - let inventory = self.inventory().map(|x| { - x.into_iter().collect() - }); - let color = self.color(); - let test = match self.test_type() { - Any::NONE => AnyT::NONE, - Any::Monster => AnyT::Monster(alloc::boxed::Box::new( - self.test_as_monster() - .expect("Invalid union table, expected `Any::Monster`.") - .unpack() - )), - Any::TestSimpleTableWithEnum => AnyT::TestSimpleTableWithEnum(alloc::boxed::Box::new( - self.test_as_test_simple_table_with_enum() - .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`.") - .unpack() - )), - Any::MyGame_Example2_Monster => AnyT::MyGameExample2Monster(alloc::boxed::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| alloc::string::ToString::to_string(s)).collect() - }); - let testarrayoftables = self.testarrayoftables().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - let enemy = self.enemy().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - let testnestedflatbuffer = self.testnestedflatbuffer().map(|x| { - x.into_iter().collect() - }); - let testempty = self.testempty().map(|x| { - alloc::boxed::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.into_iter().collect() - }); - let testf = self.testf(); - let testf2 = self.testf2(); - let testf3 = self.testf3(); - let testarrayofstring2 = self.testarrayofstring2().map(|x| { - x.iter().map(|s| alloc::string::ToString::to_string(s)).collect() - }); - let testarrayofsortedstruct = self.testarrayofsortedstruct().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - let flex = self.flex().map(|x| { - x.into_iter().collect() - }); - 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| { - alloc::boxed::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(alloc::boxed::Box::new( - self.any_unique_as_m() - .expect("Invalid union table, expected `AnyUniqueAliases::M`.") - .unpack() - )), - AnyUniqueAliases::TS => AnyUniqueAliasesT::TS(alloc::boxed::Box::new( - self.any_unique_as_ts() - .expect("Invalid union table, expected `AnyUniqueAliases::TS`.") - .unpack() - )), - AnyUniqueAliases::M2 => AnyUniqueAliasesT::M2(alloc::boxed::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(alloc::boxed::Box::new( - self.any_ambiguous_as_m1() - .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`.") - .unpack() - )), - AnyAmbiguousAliases::M2 => AnyAmbiguousAliasesT::M2(alloc::boxed::Box::new( - self.any_ambiguous_as_m2() - .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`.") - .unpack() - )), - AnyAmbiguousAliases::M3 => AnyAmbiguousAliasesT::M3(alloc::boxed::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.into_iter().collect() - }); - let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| { - x.iter().map(|t| t.unpack()).collect() - }); - let native_inline = self.native_inline().map(|x| { - x.unpack() - }); - let long_enum_non_enum_default = self.long_enum_non_enum_default(); - let long_enum_normal_default = self.long_enum_normal_default(); - let nan_default = self.nan_default(); - let inf_default = self.inf_default(); - let positive_inf_default = self.positive_inf_default(); - let infinity_default = self.infinity_default(); - let positive_infinity_default = self.positive_infinity_default(); - let negative_inf_default = self.negative_inf_default(); - let negative_infinity_default = self.negative_infinity_default(); - let double_inf_default = self.double_inf_default(); - 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, - native_inline, - long_enum_non_enum_default, - long_enum_normal_default, - nan_default, - inf_default, - positive_inf_default, - infinity_default, - positive_infinity_default, - negative_inf_default, - negative_infinity_default, - double_inf_default, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Monster" } - } - #[inline] - pub fn pos(&self) -> Option<&'a Vec3> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_POS, None)} - } - - #[inline] - pub fn mana(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_MANA, Some(150)).unwrap()} - } - - #[inline] - pub fn hp(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_HP, Some(100)).unwrap()} - } - - #[inline] - pub fn name(&self) -> &'a str { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(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) -> ::core::cmp::Ordering { - let key = self.name(); - key.cmp(val) - } - - #[inline] - pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)} - } - - #[inline] - pub fn color(&self) -> Color { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_COLOR, Some(Color::Blue)).unwrap()} - } - - #[inline] - pub fn test_type(&self) -> Any { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TEST_TYPE, Some(Any::NONE)).unwrap()} - } - - #[inline] - pub fn test(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_TEST, None)} - } - - #[inline] - pub fn test4(&self) -> Option<::flatbuffers::Vector<'a, Test>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST4, None)} - } - - #[inline] - pub fn testarrayofstring(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING, None)} - } - - /// an example documentation comment: this will end up in the generated code - /// multiline too - #[inline] - pub fn testarrayoftables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_TESTARRAYOFTABLES, None)} - } - - #[inline] - pub fn enemy(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_ENEMY, None)} - } - - #[inline] - pub fn testnestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTNESTEDFLATBUFFER, None)} - } - - pub fn testnestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { - self.testnestedflatbuffer().map(|data| { - use ::flatbuffers::Follow; - // Safety: - // Created from a valid Table for this object - // Which contains a valid flatbuffer in this slot - unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } - }) - } - - #[inline] - pub fn testempty(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_TESTEMPTY, None)} - } - - #[inline] - pub fn testbool(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTBOOL, Some(false)).unwrap()} - } - - #[inline] - pub fn testhashs32_fnv1(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu32_fnv1(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashs64_fnv1(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu64_fnv1(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashs32_fnv1a(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu32_fnv1a(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashs64_fnv1a(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testhashu64_fnv1a(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1A, Some(0)).unwrap()} - } - - #[inline] - pub fn testarrayofbools(&self) -> Option<::flatbuffers::Vector<'a, bool>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, bool>>>(Monster::VT_TESTARRAYOFBOOLS, None)} - } - - #[inline] - pub fn testf(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTF, Some(3.14159)).unwrap()} - } - - #[inline] - pub fn testf2(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTF2, Some(3.0)).unwrap()} - } - - #[inline] - pub fn testf3(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_TESTF3, Some(0.0)).unwrap()} - } - - #[inline] - pub fn testarrayofstring2(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING2, None)} - } - - #[inline] - pub fn testarrayofsortedstruct(&self) -> Option<::flatbuffers::Vector<'a, Ability>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Ability>>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, None)} - } - - #[inline] - pub fn flex(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_FLEX, None)} - } - - #[inline] - pub fn test5(&self) -> Option<::flatbuffers::Vector<'a, Test>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST5, None)} - } - - #[inline] - pub fn vector_of_longs(&self) -> Option<::flatbuffers::Vector<'a, i64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i64>>>(Monster::VT_VECTOR_OF_LONGS, None)} - } - - #[inline] - pub fn vector_of_doubles(&self) -> Option<::flatbuffers::Vector<'a, f64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(Monster::VT_VECTOR_OF_DOUBLES, None)} - } - - #[inline] - pub fn parent_namespace_test(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_PARENT_NAMESPACE_TEST, None)} - } - - #[inline] - pub fn vector_of_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_REFERRABLES, None)} - } - - #[inline] - pub fn single_weak_reference(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_SINGLE_WEAK_REFERENCE, Some(0)).unwrap()} - } - - #[inline] - pub fn vector_of_weak_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, None)} - } - - #[inline] - pub fn vector_of_strong_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, None)} - } - - #[inline] - pub fn co_owning_reference(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_CO_OWNING_REFERENCE, Some(0)).unwrap()} - } - - #[inline] - pub fn vector_of_co_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, None)} - } - - #[inline] - pub fn non_owning_reference(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NON_OWNING_REFERENCE, Some(0)).unwrap()} - } - - #[inline] - pub fn vector_of_non_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, None)} - } - - #[inline] - pub fn any_unique_type(&self) -> AnyUniqueAliases { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_ANY_UNIQUE_TYPE, Some(AnyUniqueAliases::NONE)).unwrap()} - } - - #[inline] - pub fn any_unique(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_UNIQUE, None)} - } - - #[inline] - pub fn any_ambiguous_type(&self) -> AnyAmbiguousAliases { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_ANY_AMBIGUOUS_TYPE, Some(AnyAmbiguousAliases::NONE)).unwrap()} - } - - #[inline] - pub fn any_ambiguous(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_AMBIGUOUS, None)} - } - - #[inline] - pub fn vector_of_enums(&self) -> Option<::flatbuffers::Vector<'a, Color>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Color>>>(Monster::VT_VECTOR_OF_ENUMS, None)} - } - - #[inline] - pub fn signed_enum(&self) -> Race { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()} - } - - #[inline] - pub fn testrequirednestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None)} - } - - pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { - self.testrequirednestedflatbuffer().map(|data| { - use ::flatbuffers::Follow; - // Safety: - // Created from a valid Table for this object - // Which contains a valid flatbuffer in this slot - unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } - }) - } - - #[inline] - pub fn scalar_key_sorted_tables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)} - } - - #[inline] - pub fn native_inline(&self) -> Option<&'a Test> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NATIVE_INLINE, None)} - } - - #[inline] - pub fn long_enum_non_enum_default(&self) -> LongEnum { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, Some(Default::default())).unwrap()} - } - - #[inline] - pub fn long_enum_normal_default(&self) -> LongEnum { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()} - } - - #[inline] - pub fn nan_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()} - } - - #[inline] - pub fn inf_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn positive_inf_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn infinity_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn positive_infinity_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} - } - - #[inline] - pub fn negative_inf_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} - } - - #[inline] - pub fn negative_infinity_default(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} - } - - #[inline] - pub fn double_inf_default(&self) -> f64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()} - } - - #[inline] - #[allow(non_snake_case)] - pub fn test_as_monster(&self) -> Option> { - if self.test_type() == Any::Monster { - self.test().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Monster { _tab: table } } - } - #[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(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TestSimpleTableWithEnum::init_from_table(t) } - }) - } else { - None + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args MonsterArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = MonsterBuilder::new(_fbb); + builder.add_double_inf_default(args.double_inf_default); + builder.add_long_enum_normal_default(args.long_enum_normal_default); + builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default); + 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); + builder.add_negative_infinity_default(args.negative_infinity_default); + builder.add_negative_inf_default(args.negative_inf_default); + builder.add_positive_infinity_default(args.positive_infinity_default); + builder.add_infinity_default(args.infinity_default); + builder.add_positive_inf_default(args.positive_inf_default); + builder.add_inf_default(args.inf_default); + builder.add_nan_default(args.nan_default); + if let Some(x) = args.native_inline { builder.add_native_inline(x); } + 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() } - } - #[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(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { super::example_2::Monster::init_from_table(t) } - }) - } else { - None + 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(); + alloc::string::ToString::to_string(x) + }; + let inventory = self.inventory().map(|x| { + x.into_iter().collect() + }); + let color = self.color(); + let test = match self.test_type() { + Any::NONE => AnyT::NONE, + Any::Monster => AnyT::Monster(alloc::boxed::Box::new( + self.test_as_monster() + .expect("Invalid union table, expected `Any::Monster`.") + .unpack() + )), + Any::TestSimpleTableWithEnum => AnyT::TestSimpleTableWithEnum(alloc::boxed::Box::new( + self.test_as_test_simple_table_with_enum() + .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`.") + .unpack() + )), + Any::MyGame_Example2_Monster => AnyT::MyGameExample2Monster(alloc::boxed::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| alloc::string::ToString::to_string(s)).collect() + }); + let testarrayoftables = self.testarrayoftables().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + let enemy = self.enemy().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + let testnestedflatbuffer = self.testnestedflatbuffer().map(|x| { + x.into_iter().collect() + }); + let testempty = self.testempty().map(|x| { + alloc::boxed::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.into_iter().collect() + }); + let testf = self.testf(); + let testf2 = self.testf2(); + let testf3 = self.testf3(); + let testarrayofstring2 = self.testarrayofstring2().map(|x| { + x.iter().map(|s| alloc::string::ToString::to_string(s)).collect() + }); + let testarrayofsortedstruct = self.testarrayofsortedstruct().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + let flex = self.flex().map(|x| { + x.into_iter().collect() + }); + 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| { + alloc::boxed::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(alloc::boxed::Box::new( + self.any_unique_as_m() + .expect("Invalid union table, expected `AnyUniqueAliases::M`.") + .unpack() + )), + AnyUniqueAliases::TS => AnyUniqueAliasesT::TS(alloc::boxed::Box::new( + self.any_unique_as_ts() + .expect("Invalid union table, expected `AnyUniqueAliases::TS`.") + .unpack() + )), + AnyUniqueAliases::M2 => AnyUniqueAliasesT::M2(alloc::boxed::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(alloc::boxed::Box::new( + self.any_ambiguous_as_m1() + .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`.") + .unpack() + )), + AnyAmbiguousAliases::M2 => AnyAmbiguousAliasesT::M2(alloc::boxed::Box::new( + self.any_ambiguous_as_m2() + .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`.") + .unpack() + )), + AnyAmbiguousAliases::M3 => AnyAmbiguousAliasesT::M3(alloc::boxed::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.into_iter().collect() + }); + let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| { + x.iter().map(|t| t.unpack()).collect() + }); + let native_inline = self.native_inline().map(|x| { + x.unpack() + }); + let long_enum_non_enum_default = self.long_enum_non_enum_default(); + let long_enum_normal_default = self.long_enum_normal_default(); + let nan_default = self.nan_default(); + let inf_default = self.inf_default(); + let positive_inf_default = self.positive_inf_default(); + let infinity_default = self.infinity_default(); + let positive_infinity_default = self.positive_infinity_default(); + let negative_inf_default = self.negative_inf_default(); + let negative_infinity_default = self.negative_infinity_default(); + let double_inf_default = self.double_inf_default(); + 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, + native_inline, + long_enum_non_enum_default, + long_enum_normal_default, + nan_default, + inf_default, + positive_inf_default, + infinity_default, + positive_infinity_default, + negative_inf_default, + negative_infinity_default, + double_inf_default, + } } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_unique_as_m(&self) -> Option> { - if self.any_unique_type() == AnyUniqueAliases::M { - self.any_unique().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn pos(&self) -> Option<&'a Vec3> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_POS, 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(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TestSimpleTableWithEnum::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn mana(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_MANA, Some(150)).unwrap()} } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_unique_as_m2(&self) -> Option> { - if self.any_unique_type() == AnyUniqueAliases::M2 { - self.any_unique().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { super::example_2::Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn hp(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_HP, Some(100)).unwrap()} } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_ambiguous_as_m1(&self) -> Option> { - if self.any_ambiguous_type() == AnyAmbiguousAliases::M1 { - self.any_ambiguous().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn name(&self) -> &'a str { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None).unwrap()} } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_ambiguous_as_m2(&self) -> Option> { - if self.any_ambiguous_type() == AnyAmbiguousAliases::M2 { - self.any_ambiguous().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn key_compare_less_than(&self, o: &Monster) -> bool { + self.name() < o.name() } - } - #[inline] - #[allow(non_snake_case)] - pub fn any_ambiguous_as_m3(&self) -> Option> { - if self.any_ambiguous_type() == AnyAmbiguousAliases::M3 { - self.any_ambiguous().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Monster::init_from_table(t) } - }) - } else { - None + #[inline] + pub fn key_compare_with_value(&self, val: & str) -> ::core::cmp::Ordering { + let key = self.name(); + key.cmp(val) + } + + #[inline] + pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)} + } + + #[inline] + pub fn color(&self) -> Color { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_COLOR, Some(Color::Blue)).unwrap()} + } + + #[inline] + pub fn test_type(&self) -> Any { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TEST_TYPE, Some(Any::NONE)).unwrap()} + } + + #[inline] + pub fn test(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_TEST, None)} + } + + #[inline] + pub fn test4(&self) -> Option<::flatbuffers::Vector<'a, Test>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST4, None)} + } + + #[inline] + pub fn testarrayofstring(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING, None)} + } + + /// an example documentation comment: this will end up in the generated code + /// multiline too + #[inline] + pub fn testarrayoftables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_TESTARRAYOFTABLES, None)} + } + + #[inline] + pub fn enemy(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_ENEMY, None)} + } + + #[inline] + pub fn testnestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTNESTEDFLATBUFFER, None)} + } + + pub fn testnestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { + self.testnestedflatbuffer().map(|data| { + use ::flatbuffers::Follow; + // Safety: + // Created from a valid Table for this object + // Which contains a valid flatbuffer in this slot + unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } + }) + } + + #[inline] + pub fn testempty(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_TESTEMPTY, None)} + } + + #[inline] + pub fn testbool(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTBOOL, Some(false)).unwrap()} + } + + #[inline] + pub fn testhashs32_fnv1(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu32_fnv1(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashs64_fnv1(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu64_fnv1(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashs32_fnv1a(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS32_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu32_fnv1a(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU32_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashs64_fnv1a(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHS64_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testhashu64_fnv1a(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTHASHU64_FNV1A, Some(0)).unwrap()} + } + + #[inline] + pub fn testarrayofbools(&self) -> Option<::flatbuffers::Vector<'a, bool>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, bool>>>(Monster::VT_TESTARRAYOFBOOLS, None)} + } + + #[inline] + pub fn testf(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTF, Some(3.14159)).unwrap()} + } + + #[inline] + pub fn testf2(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTF2, Some(3.0)).unwrap()} + } + + #[inline] + pub fn testf3(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_TESTF3, Some(0.0)).unwrap()} + } + + #[inline] + pub fn testarrayofstring2(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING2, None)} + } + + #[inline] + pub fn testarrayofsortedstruct(&self) -> Option<::flatbuffers::Vector<'a, Ability>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Ability>>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, None)} + } + + #[inline] + pub fn flex(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_FLEX, None)} + } + + #[inline] + pub fn test5(&self) -> Option<::flatbuffers::Vector<'a, Test>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST5, None)} + } + + #[inline] + pub fn vector_of_longs(&self) -> Option<::flatbuffers::Vector<'a, i64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i64>>>(Monster::VT_VECTOR_OF_LONGS, None)} + } + + #[inline] + pub fn vector_of_doubles(&self) -> Option<::flatbuffers::Vector<'a, f64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(Monster::VT_VECTOR_OF_DOUBLES, None)} + } + + #[inline] + pub fn parent_namespace_test(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(Monster::VT_PARENT_NAMESPACE_TEST, None)} + } + + #[inline] + pub fn vector_of_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_REFERRABLES, None)} + } + + #[inline] + pub fn single_weak_reference(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_SINGLE_WEAK_REFERENCE, Some(0)).unwrap()} + } + + #[inline] + pub fn vector_of_weak_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, None)} + } + + #[inline] + pub fn vector_of_strong_referrables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, None)} + } + + #[inline] + pub fn co_owning_reference(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_CO_OWNING_REFERENCE, Some(0)).unwrap()} + } + + #[inline] + pub fn vector_of_co_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, None)} + } + + #[inline] + pub fn non_owning_reference(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NON_OWNING_REFERENCE, Some(0)).unwrap()} + } + + #[inline] + pub fn vector_of_non_owning_references(&self) -> Option<::flatbuffers::Vector<'a, u64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, None)} + } + + #[inline] + pub fn any_unique_type(&self) -> AnyUniqueAliases { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_ANY_UNIQUE_TYPE, Some(AnyUniqueAliases::NONE)).unwrap()} + } + + #[inline] + pub fn any_unique(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_UNIQUE, None)} + } + + #[inline] + pub fn any_ambiguous_type(&self) -> AnyAmbiguousAliases { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_ANY_AMBIGUOUS_TYPE, Some(AnyAmbiguousAliases::NONE)).unwrap()} + } + + #[inline] + pub fn any_ambiguous(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_ANY_AMBIGUOUS, None)} + } + + #[inline] + pub fn vector_of_enums(&self) -> Option<::flatbuffers::Vector<'a, Color>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Color>>>(Monster::VT_VECTOR_OF_ENUMS, None)} + } + + #[inline] + pub fn signed_enum(&self) -> Race { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()} + } + + #[inline] + pub fn testrequirednestedflatbuffer(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None)} + } + + pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option> { + self.testrequirednestedflatbuffer().map(|data| { + use ::flatbuffers::Follow; + // Safety: + // Created from a valid Table for this object + // Which contains a valid flatbuffer in this slot + unsafe { <::flatbuffers::ForwardsUOffset>>::follow(data.bytes(), 0) } + }) + } + + #[inline] + pub fn scalar_key_sorted_tables(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)} + } + + #[inline] + pub fn native_inline(&self) -> Option<&'a Test> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NATIVE_INLINE, None)} + } + + #[inline] + pub fn long_enum_non_enum_default(&self) -> LongEnum { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, Some(Default::default())).unwrap()} + } + + #[inline] + pub fn long_enum_normal_default(&self) -> LongEnum { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()} + } + + #[inline] + pub fn nan_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()} + } + + #[inline] + pub fn inf_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn positive_inf_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn infinity_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn positive_infinity_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()} + } + + #[inline] + pub fn negative_inf_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} + } + + #[inline] + pub fn negative_infinity_default(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()} + } + + #[inline] + pub fn double_inf_default(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()} + } + + #[inline] + #[allow(non_snake_case)] + pub fn test_as_monster(&self) -> Option> { + if self.test_type() == Any::Monster { + self.test().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TestSimpleTableWithEnum::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { super::example_2::Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TestSimpleTableWithEnum::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { super::example_2::Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } 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(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { Monster::init_from_table(t) } + }) + } else { + None + } } - } } impl ::flatbuffers::Verifiable for Monster<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - 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::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("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::<::flatbuffers::ForwardsUOffset>("Any::Monster", pos), - Any::TestSimpleTableWithEnum => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::TestSimpleTableWithEnum", pos), - Any::MyGame_Example2_Monster => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::MyGame_Example2_Monster", pos), - _ => Ok(()), - } - })? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test4", Self::VT_TEST4, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring", Self::VT_TESTARRAYOFSTRING, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("testarrayoftables", Self::VT_TESTARRAYOFTABLES, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>("enemy", Self::VT_ENEMY, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testnestedflatbuffer", Self::VT_TESTNESTEDFLATBUFFER, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, bool>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring2", Self::VT_TESTARRAYOFSTRING2, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Ability>>>("testarrayofsortedstruct", Self::VT_TESTARRAYOFSORTEDSTRUCT, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("flex", Self::VT_FLEX, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test5", Self::VT_TEST5, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i64>>>("vector_of_longs", Self::VT_VECTOR_OF_LONGS, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vector_of_doubles", Self::VT_VECTOR_OF_DOUBLES, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>("parent_namespace_test", Self::VT_PARENT_NAMESPACE_TEST, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_referrables", Self::VT_VECTOR_OF_REFERRABLES, false)? - .visit_field::("single_weak_reference", Self::VT_SINGLE_WEAK_REFERENCE, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("vector_of_weak_references", Self::VT_VECTOR_OF_WEAK_REFERENCES, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_strong_referrables", Self::VT_VECTOR_OF_STRONG_REFERRABLES, false)? - .visit_field::("co_owning_reference", Self::VT_CO_OWNING_REFERENCE, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::M", pos), - AnyUniqueAliases::TS => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::TS", pos), - AnyUniqueAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M1", pos), - AnyAmbiguousAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M2", pos), - AnyAmbiguousAliases::M3 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M3", pos), - _ => Ok(()), - } - })? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Color>>>("vector_of_enums", Self::VT_VECTOR_OF_ENUMS, false)? - .visit_field::("signed_enum", Self::VT_SIGNED_ENUM, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)? - .visit_field::("native_inline", Self::VT_NATIVE_INLINE, false)? - .visit_field::("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)? - .visit_field::("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)? - .visit_field::("nan_default", Self::VT_NAN_DEFAULT, false)? - .visit_field::("inf_default", Self::VT_INF_DEFAULT, false)? - .visit_field::("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)? - .visit_field::("infinity_default", Self::VT_INFINITY_DEFAULT, false)? - .visit_field::("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)? - .visit_field::("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)? - .visit_field::("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)? - .visit_field::("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("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::<::flatbuffers::ForwardsUOffset>("Any::Monster", pos), + Any::TestSimpleTableWithEnum => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::TestSimpleTableWithEnum", pos), + Any::MyGame_Example2_Monster => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("Any::MyGame_Example2_Monster", pos), + _ => Ok(()), + } + })? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test4", Self::VT_TEST4, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring", Self::VT_TESTARRAYOFSTRING, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("testarrayoftables", Self::VT_TESTARRAYOFTABLES, false)? + .visit_field::<::flatbuffers::ForwardsUOffset>("enemy", Self::VT_ENEMY, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testnestedflatbuffer", Self::VT_TESTNESTEDFLATBUFFER, false)? + .visit_field::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, bool>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring2", Self::VT_TESTARRAYOFSTRING2, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Ability>>>("testarrayofsortedstruct", Self::VT_TESTARRAYOFSORTEDSTRUCT, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("flex", Self::VT_FLEX, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Test>>>("test5", Self::VT_TEST5, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i64>>>("vector_of_longs", Self::VT_VECTOR_OF_LONGS, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vector_of_doubles", Self::VT_VECTOR_OF_DOUBLES, false)? + .visit_field::<::flatbuffers::ForwardsUOffset>("parent_namespace_test", Self::VT_PARENT_NAMESPACE_TEST, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_referrables", Self::VT_VECTOR_OF_REFERRABLES, false)? + .visit_field::("single_weak_reference", Self::VT_SINGLE_WEAK_REFERENCE, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("vector_of_weak_references", Self::VT_VECTOR_OF_WEAK_REFERENCES, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("vector_of_strong_referrables", Self::VT_VECTOR_OF_STRONG_REFERRABLES, false)? + .visit_field::("co_owning_reference", Self::VT_CO_OWNING_REFERENCE, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u64>>>("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::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::M", pos), + AnyUniqueAliases::TS => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyUniqueAliases::TS", pos), + AnyUniqueAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("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::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M1", pos), + AnyAmbiguousAliases::M2 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M2", pos), + AnyAmbiguousAliases::M3 => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("AnyAmbiguousAliases::M3", pos), + _ => Ok(()), + } + })? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Color>>>("vector_of_enums", Self::VT_VECTOR_OF_ENUMS, false)? + .visit_field::("signed_enum", Self::VT_SIGNED_ENUM, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>("scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)? + .visit_field::("native_inline", Self::VT_NATIVE_INLINE, false)? + .visit_field::("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)? + .visit_field::("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)? + .visit_field::("nan_default", Self::VT_NAN_DEFAULT, false)? + .visit_field::("inf_default", Self::VT_INF_DEFAULT, false)? + .visit_field::("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)? + .visit_field::("infinity_default", Self::VT_INFINITY_DEFAULT, false)? + .visit_field::("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)? + .visit_field::("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)? + .visit_field::("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)? + .visit_field::("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)? + .finish(); + Ok(()) + } } pub struct MonsterArgs<'a> { @@ -1204,1082 +1204,1082 @@ pub struct MonsterArgs<'a> { } 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, - native_inline: None, - long_enum_non_enum_default: Default::default(), - long_enum_normal_default: LongEnum::LongOne, - nan_default: f32::NAN, - inf_default: f32::INFINITY, - positive_inf_default: f32::INFINITY, - infinity_default: f32::INFINITY, - positive_infinity_default: f32::INFINITY, - negative_inf_default: f32::NEG_INFINITY, - negative_infinity_default: f32::NEG_INFINITY, - double_inf_default: f64::INFINITY, + #[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, + native_inline: None, + long_enum_non_enum_default: Default::default(), + long_enum_normal_default: LongEnum::LongOne, + nan_default: f32::NAN, + inf_default: f32::INFINITY, + positive_inf_default: f32::INFINITY, + infinity_default: f32::INFINITY, + positive_infinity_default: f32::INFINITY, + negative_inf_default: f32::NEG_INFINITY, + negative_infinity_default: f32::NEG_INFINITY, + double_inf_default: f64::INFINITY, + } } - } } impl Serialize for Monster<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let mut s = serializer.serialize_struct("Monster", 62)?; - if let Some(f) = self.pos() { - s.serialize_field("pos", &f)?; - } else { - s.skip_field("pos")?; - } - s.serialize_field("mana", &self.mana())?; - s.serialize_field("hp", &self.hp())?; - s.serialize_field("name", &self.name())?; - if let Some(f) = self.inventory() { - s.serialize_field("inventory", &f)?; - } else { - s.skip_field("inventory")?; - } - s.serialize_field("color", &self.color())?; - s.serialize_field("test_type", &self.test_type())?; - match self.test_type() { - Any::NONE => (), - Any::Monster => { - let f = self.test_as_monster() - .expect("Invalid union table, expected `Any::Monster`."); - s.serialize_field("test", &f)?; - } - Any::TestSimpleTableWithEnum => { - let f = self.test_as_test_simple_table_with_enum() - .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`."); - s.serialize_field("test", &f)?; - } - Any::MyGame_Example2_Monster => { - let f = self.test_as_my_game_example_2_monster() - .expect("Invalid union table, expected `Any::MyGame_Example2_Monster`."); - s.serialize_field("test", &f)?; - } - _ => unimplemented!(), - } - if let Some(f) = self.test4() { - s.serialize_field("test4", &f)?; - } else { - s.skip_field("test4")?; - } - if let Some(f) = self.testarrayofstring() { - s.serialize_field("testarrayofstring", &f)?; - } else { - s.skip_field("testarrayofstring")?; - } - if let Some(f) = self.testarrayoftables() { - s.serialize_field("testarrayoftables", &f)?; - } else { - s.skip_field("testarrayoftables")?; - } - if let Some(f) = self.enemy() { - s.serialize_field("enemy", &f)?; - } else { - s.skip_field("enemy")?; - } - if let Some(f) = self.testnestedflatbuffer() { - s.serialize_field("testnestedflatbuffer", &f)?; - } else { - s.skip_field("testnestedflatbuffer")?; - } - if let Some(f) = self.testempty() { - s.serialize_field("testempty", &f)?; - } else { - s.skip_field("testempty")?; - } - s.serialize_field("testbool", &self.testbool())?; - s.serialize_field("testhashs32_fnv1", &self.testhashs32_fnv1())?; - s.serialize_field("testhashu32_fnv1", &self.testhashu32_fnv1())?; - s.serialize_field("testhashs64_fnv1", &self.testhashs64_fnv1())?; - s.serialize_field("testhashu64_fnv1", &self.testhashu64_fnv1())?; - s.serialize_field("testhashs32_fnv1a", &self.testhashs32_fnv1a())?; - s.serialize_field("testhashu32_fnv1a", &self.testhashu32_fnv1a())?; - s.serialize_field("testhashs64_fnv1a", &self.testhashs64_fnv1a())?; - s.serialize_field("testhashu64_fnv1a", &self.testhashu64_fnv1a())?; - if let Some(f) = self.testarrayofbools() { - s.serialize_field("testarrayofbools", &f)?; - } else { - s.skip_field("testarrayofbools")?; - } - s.serialize_field("testf", &self.testf())?; - s.serialize_field("testf2", &self.testf2())?; - s.serialize_field("testf3", &self.testf3())?; - if let Some(f) = self.testarrayofstring2() { - s.serialize_field("testarrayofstring2", &f)?; - } else { - s.skip_field("testarrayofstring2")?; - } - if let Some(f) = self.testarrayofsortedstruct() { - s.serialize_field("testarrayofsortedstruct", &f)?; - } else { - s.skip_field("testarrayofsortedstruct")?; - } - if let Some(f) = self.flex() { - s.serialize_field("flex", &f)?; - } else { - s.skip_field("flex")?; - } - if let Some(f) = self.test5() { - s.serialize_field("test5", &f)?; - } else { - s.skip_field("test5")?; - } - if let Some(f) = self.vector_of_longs() { - s.serialize_field("vector_of_longs", &f)?; - } else { - s.skip_field("vector_of_longs")?; - } - if let Some(f) = self.vector_of_doubles() { - s.serialize_field("vector_of_doubles", &f)?; - } else { - s.skip_field("vector_of_doubles")?; - } - if let Some(f) = self.parent_namespace_test() { - s.serialize_field("parent_namespace_test", &f)?; - } else { - s.skip_field("parent_namespace_test")?; - } - if let Some(f) = self.vector_of_referrables() { - s.serialize_field("vector_of_referrables", &f)?; - } else { - s.skip_field("vector_of_referrables")?; - } - s.serialize_field("single_weak_reference", &self.single_weak_reference())?; - if let Some(f) = self.vector_of_weak_references() { - s.serialize_field("vector_of_weak_references", &f)?; - } else { - s.skip_field("vector_of_weak_references")?; - } - if let Some(f) = self.vector_of_strong_referrables() { - s.serialize_field("vector_of_strong_referrables", &f)?; - } else { - s.skip_field("vector_of_strong_referrables")?; - } - s.serialize_field("co_owning_reference", &self.co_owning_reference())?; - if let Some(f) = self.vector_of_co_owning_references() { - s.serialize_field("vector_of_co_owning_references", &f)?; - } else { - s.skip_field("vector_of_co_owning_references")?; - } - s.serialize_field("non_owning_reference", &self.non_owning_reference())?; - if let Some(f) = self.vector_of_non_owning_references() { - s.serialize_field("vector_of_non_owning_references", &f)?; - } else { - s.skip_field("vector_of_non_owning_references")?; - } - s.serialize_field("any_unique_type", &self.any_unique_type())?; - match self.any_unique_type() { - AnyUniqueAliases::NONE => (), - AnyUniqueAliases::M => { - let f = self.any_unique_as_m() - .expect("Invalid union table, expected `AnyUniqueAliases::M`."); - s.serialize_field("any_unique", &f)?; - } - AnyUniqueAliases::TS => { - let f = self.any_unique_as_ts() - .expect("Invalid union table, expected `AnyUniqueAliases::TS`."); - s.serialize_field("any_unique", &f)?; - } - AnyUniqueAliases::M2 => { - let f = self.any_unique_as_m2() - .expect("Invalid union table, expected `AnyUniqueAliases::M2`."); - s.serialize_field("any_unique", &f)?; - } - _ => unimplemented!(), - } - s.serialize_field("any_ambiguous_type", &self.any_ambiguous_type())?; - match self.any_ambiguous_type() { - AnyAmbiguousAliases::NONE => (), - AnyAmbiguousAliases::M1 => { - let f = self.any_ambiguous_as_m1() - .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`."); - s.serialize_field("any_ambiguous", &f)?; - } - AnyAmbiguousAliases::M2 => { - let f = self.any_ambiguous_as_m2() - .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`."); - s.serialize_field("any_ambiguous", &f)?; - } - AnyAmbiguousAliases::M3 => { - let f = self.any_ambiguous_as_m3() - .expect("Invalid union table, expected `AnyAmbiguousAliases::M3`."); - s.serialize_field("any_ambiguous", &f)?; - } - _ => unimplemented!(), - } - if let Some(f) = self.vector_of_enums() { - s.serialize_field("vector_of_enums", &f)?; - } else { - s.skip_field("vector_of_enums")?; - } - s.serialize_field("signed_enum", &self.signed_enum())?; - if let Some(f) = self.testrequirednestedflatbuffer() { - s.serialize_field("testrequirednestedflatbuffer", &f)?; - } else { - s.skip_field("testrequirednestedflatbuffer")?; - } - if let Some(f) = self.scalar_key_sorted_tables() { - s.serialize_field("scalar_key_sorted_tables", &f)?; - } else { - s.skip_field("scalar_key_sorted_tables")?; - } - if let Some(f) = self.native_inline() { - s.serialize_field("native_inline", &f)?; - } else { - s.skip_field("native_inline")?; - } - s.serialize_field("long_enum_non_enum_default", &self.long_enum_non_enum_default())?; - s.serialize_field("long_enum_normal_default", &self.long_enum_normal_default())?; - s.serialize_field("nan_default", &self.nan_default())?; - s.serialize_field("inf_default", &self.inf_default())?; - s.serialize_field("positive_inf_default", &self.positive_inf_default())?; - s.serialize_field("infinity_default", &self.infinity_default())?; - s.serialize_field("positive_infinity_default", &self.positive_infinity_default())?; - s.serialize_field("negative_inf_default", &self.negative_inf_default())?; - s.serialize_field("negative_infinity_default", &self.negative_infinity_default())?; - s.serialize_field("double_inf_default", &self.double_inf_default())?; - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut s = serializer.serialize_struct("Monster", 62)?; + if let Some(f) = self.pos() { + s.serialize_field("pos", &f)?; + } else { + s.skip_field("pos")?; + } + s.serialize_field("mana", &self.mana())?; + s.serialize_field("hp", &self.hp())?; + s.serialize_field("name", &self.name())?; + if let Some(f) = self.inventory() { + s.serialize_field("inventory", &f)?; + } else { + s.skip_field("inventory")?; + } + s.serialize_field("color", &self.color())?; + s.serialize_field("test_type", &self.test_type())?; + match self.test_type() { + Any::NONE => (), + Any::Monster => { + let f = self.test_as_monster() + .expect("Invalid union table, expected `Any::Monster`."); + s.serialize_field("test", &f)?; + } + Any::TestSimpleTableWithEnum => { + let f = self.test_as_test_simple_table_with_enum() + .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`."); + s.serialize_field("test", &f)?; + } + Any::MyGame_Example2_Monster => { + let f = self.test_as_my_game_example_2_monster() + .expect("Invalid union table, expected `Any::MyGame_Example2_Monster`."); + s.serialize_field("test", &f)?; + } + _ => unimplemented!(), + } + if let Some(f) = self.test4() { + s.serialize_field("test4", &f)?; + } else { + s.skip_field("test4")?; + } + if let Some(f) = self.testarrayofstring() { + s.serialize_field("testarrayofstring", &f)?; + } else { + s.skip_field("testarrayofstring")?; + } + if let Some(f) = self.testarrayoftables() { + s.serialize_field("testarrayoftables", &f)?; + } else { + s.skip_field("testarrayoftables")?; + } + if let Some(f) = self.enemy() { + s.serialize_field("enemy", &f)?; + } else { + s.skip_field("enemy")?; + } + if let Some(f) = self.testnestedflatbuffer() { + s.serialize_field("testnestedflatbuffer", &f)?; + } else { + s.skip_field("testnestedflatbuffer")?; + } + if let Some(f) = self.testempty() { + s.serialize_field("testempty", &f)?; + } else { + s.skip_field("testempty")?; + } + s.serialize_field("testbool", &self.testbool())?; + s.serialize_field("testhashs32_fnv1", &self.testhashs32_fnv1())?; + s.serialize_field("testhashu32_fnv1", &self.testhashu32_fnv1())?; + s.serialize_field("testhashs64_fnv1", &self.testhashs64_fnv1())?; + s.serialize_field("testhashu64_fnv1", &self.testhashu64_fnv1())?; + s.serialize_field("testhashs32_fnv1a", &self.testhashs32_fnv1a())?; + s.serialize_field("testhashu32_fnv1a", &self.testhashu32_fnv1a())?; + s.serialize_field("testhashs64_fnv1a", &self.testhashs64_fnv1a())?; + s.serialize_field("testhashu64_fnv1a", &self.testhashu64_fnv1a())?; + if let Some(f) = self.testarrayofbools() { + s.serialize_field("testarrayofbools", &f)?; + } else { + s.skip_field("testarrayofbools")?; + } + s.serialize_field("testf", &self.testf())?; + s.serialize_field("testf2", &self.testf2())?; + s.serialize_field("testf3", &self.testf3())?; + if let Some(f) = self.testarrayofstring2() { + s.serialize_field("testarrayofstring2", &f)?; + } else { + s.skip_field("testarrayofstring2")?; + } + if let Some(f) = self.testarrayofsortedstruct() { + s.serialize_field("testarrayofsortedstruct", &f)?; + } else { + s.skip_field("testarrayofsortedstruct")?; + } + if let Some(f) = self.flex() { + s.serialize_field("flex", &f)?; + } else { + s.skip_field("flex")?; + } + if let Some(f) = self.test5() { + s.serialize_field("test5", &f)?; + } else { + s.skip_field("test5")?; + } + if let Some(f) = self.vector_of_longs() { + s.serialize_field("vector_of_longs", &f)?; + } else { + s.skip_field("vector_of_longs")?; + } + if let Some(f) = self.vector_of_doubles() { + s.serialize_field("vector_of_doubles", &f)?; + } else { + s.skip_field("vector_of_doubles")?; + } + if let Some(f) = self.parent_namespace_test() { + s.serialize_field("parent_namespace_test", &f)?; + } else { + s.skip_field("parent_namespace_test")?; + } + if let Some(f) = self.vector_of_referrables() { + s.serialize_field("vector_of_referrables", &f)?; + } else { + s.skip_field("vector_of_referrables")?; + } + s.serialize_field("single_weak_reference", &self.single_weak_reference())?; + if let Some(f) = self.vector_of_weak_references() { + s.serialize_field("vector_of_weak_references", &f)?; + } else { + s.skip_field("vector_of_weak_references")?; + } + if let Some(f) = self.vector_of_strong_referrables() { + s.serialize_field("vector_of_strong_referrables", &f)?; + } else { + s.skip_field("vector_of_strong_referrables")?; + } + s.serialize_field("co_owning_reference", &self.co_owning_reference())?; + if let Some(f) = self.vector_of_co_owning_references() { + s.serialize_field("vector_of_co_owning_references", &f)?; + } else { + s.skip_field("vector_of_co_owning_references")?; + } + s.serialize_field("non_owning_reference", &self.non_owning_reference())?; + if let Some(f) = self.vector_of_non_owning_references() { + s.serialize_field("vector_of_non_owning_references", &f)?; + } else { + s.skip_field("vector_of_non_owning_references")?; + } + s.serialize_field("any_unique_type", &self.any_unique_type())?; + match self.any_unique_type() { + AnyUniqueAliases::NONE => (), + AnyUniqueAliases::M => { + let f = self.any_unique_as_m() + .expect("Invalid union table, expected `AnyUniqueAliases::M`."); + s.serialize_field("any_unique", &f)?; + } + AnyUniqueAliases::TS => { + let f = self.any_unique_as_ts() + .expect("Invalid union table, expected `AnyUniqueAliases::TS`."); + s.serialize_field("any_unique", &f)?; + } + AnyUniqueAliases::M2 => { + let f = self.any_unique_as_m2() + .expect("Invalid union table, expected `AnyUniqueAliases::M2`."); + s.serialize_field("any_unique", &f)?; + } + _ => unimplemented!(), + } + s.serialize_field("any_ambiguous_type", &self.any_ambiguous_type())?; + match self.any_ambiguous_type() { + AnyAmbiguousAliases::NONE => (), + AnyAmbiguousAliases::M1 => { + let f = self.any_ambiguous_as_m1() + .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`."); + s.serialize_field("any_ambiguous", &f)?; + } + AnyAmbiguousAliases::M2 => { + let f = self.any_ambiguous_as_m2() + .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`."); + s.serialize_field("any_ambiguous", &f)?; + } + AnyAmbiguousAliases::M3 => { + let f = self.any_ambiguous_as_m3() + .expect("Invalid union table, expected `AnyAmbiguousAliases::M3`."); + s.serialize_field("any_ambiguous", &f)?; + } + _ => unimplemented!(), + } + if let Some(f) = self.vector_of_enums() { + s.serialize_field("vector_of_enums", &f)?; + } else { + s.skip_field("vector_of_enums")?; + } + s.serialize_field("signed_enum", &self.signed_enum())?; + if let Some(f) = self.testrequirednestedflatbuffer() { + s.serialize_field("testrequirednestedflatbuffer", &f)?; + } else { + s.skip_field("testrequirednestedflatbuffer")?; + } + if let Some(f) = self.scalar_key_sorted_tables() { + s.serialize_field("scalar_key_sorted_tables", &f)?; + } else { + s.skip_field("scalar_key_sorted_tables")?; + } + if let Some(f) = self.native_inline() { + s.serialize_field("native_inline", &f)?; + } else { + s.skip_field("native_inline")?; + } + s.serialize_field("long_enum_non_enum_default", &self.long_enum_non_enum_default())?; + s.serialize_field("long_enum_normal_default", &self.long_enum_normal_default())?; + s.serialize_field("nan_default", &self.nan_default())?; + s.serialize_field("inf_default", &self.inf_default())?; + s.serialize_field("positive_inf_default", &self.positive_inf_default())?; + s.serialize_field("infinity_default", &self.infinity_default())?; + s.serialize_field("positive_infinity_default", &self.positive_infinity_default())?; + s.serialize_field("negative_inf_default", &self.negative_inf_default())?; + s.serialize_field("negative_infinity_default", &self.negative_infinity_default())?; + s.serialize_field("double_inf_default", &self.double_inf_default())?; + s.end() + } } pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> { - #[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::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name); - } - - #[inline] - pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST, test); - } - - #[inline] - pub fn add_test4(&mut self, test4: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST4, test4); - } - - #[inline] - pub fn add_testarrayofstring(&mut self, testarrayofstring: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); - } - - #[inline] - pub fn add_testarrayoftables(&mut self, testarrayoftables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); - } - - #[inline] - pub fn add_enemy(&mut self, enemy: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(Monster::VT_ENEMY, enemy); - } - - #[inline] - pub fn add_testnestedflatbuffer(&mut self, testnestedflatbuffer: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); - } - - #[inline] - pub fn add_testempty(&mut self, testempty: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(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<::flatbuffers::Vector<'b , bool>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); - } - - #[inline] - pub fn add_testarrayofsortedstruct(&mut self, testarrayofsortedstruct: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Ability>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); - } - - #[inline] - pub fn add_flex(&mut self, flex: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_FLEX, flex); - } - - #[inline] - pub fn add_test5(&mut self, test5: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST5, test5); - } - - #[inline] - pub fn add_vector_of_longs(&mut self, vector_of_longs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , i64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); - } - - #[inline] - pub fn add_vector_of_doubles(&mut self, vector_of_doubles: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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::<::flatbuffers::WIPOffset>(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); - } - - #[inline] - pub fn add_vector_of_referrables(&mut self, vector_of_referrables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); - } - - #[inline] - pub fn add_vector_of_enums(&mut self, vector_of_enums: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Color>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); - } - - #[inline] - pub fn add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); - } - - #[inline] - pub fn add_native_inline(&mut self, native_inline: &Test) { - self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline); - } - - #[inline] - pub fn add_long_enum_non_enum_default(&mut self, long_enum_non_enum_default: LongEnum) { - self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, long_enum_non_enum_default, Default::default()); - } - - #[inline] - pub fn add_long_enum_normal_default(&mut self, long_enum_normal_default: LongEnum) { - self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne); - } - - #[inline] - pub fn add_nan_default(&mut self, nan_default: f32) { - self.fbb_.push_slot::(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN); - } - - #[inline] - pub fn add_inf_default(&mut self, inf_default: f32) { - self.fbb_.push_slot::(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY); - } - - #[inline] - pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) { - self.fbb_.push_slot::(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY); - } - - #[inline] - pub fn add_infinity_default(&mut self, infinity_default: f32) { - self.fbb_.push_slot::(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY); - } - - #[inline] - pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) { - self.fbb_.push_slot::(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY); - } - - #[inline] - pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) { - self.fbb_.push_slot::(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY); - } - - #[inline] - pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) { - self.fbb_.push_slot::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY); - } - - #[inline] - pub fn add_double_inf_default(&mut self, double_inf_default: f64) { - self.fbb_.push_slot::(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - MonsterBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_pos(&mut self, pos: &Vec3) { + self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos); } - } - #[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()) - } + #[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::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name); + } + + #[inline] + pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST, test); + } + + #[inline] + pub fn add_test4(&mut self, test4: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST4, test4); + } + + #[inline] + pub fn add_testarrayofstring(&mut self, testarrayofstring: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); + } + + #[inline] + pub fn add_testarrayoftables(&mut self, testarrayoftables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); + } + + #[inline] + pub fn add_enemy(&mut self, enemy: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(Monster::VT_ENEMY, enemy); + } + + #[inline] + pub fn add_testnestedflatbuffer(&mut self, testnestedflatbuffer: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); + } + + #[inline] + pub fn add_testempty(&mut self, testempty: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(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<::flatbuffers::Vector<'b , bool>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b str>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); + } + + #[inline] + pub fn add_testarrayofsortedstruct(&mut self, testarrayofsortedstruct: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Ability>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); + } + + #[inline] + pub fn add_flex(&mut self, flex: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_FLEX, flex); + } + + #[inline] + pub fn add_test5(&mut self, test5: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Test>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TEST5, test5); + } + + #[inline] + pub fn add_vector_of_longs(&mut self, vector_of_longs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , i64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); + } + + #[inline] + pub fn add_vector_of_doubles(&mut self, vector_of_doubles: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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::<::flatbuffers::WIPOffset>(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); + } + + #[inline] + pub fn add_vector_of_referrables(&mut self, vector_of_referrables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); + } + + #[inline] + pub fn add_vector_of_enums(&mut self, vector_of_enums: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Color>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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<::flatbuffers::Vector<'b , u8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); + } + + #[inline] + pub fn add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); + } + + #[inline] + pub fn add_native_inline(&mut self, native_inline: &Test) { + self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline); + } + + #[inline] + pub fn add_long_enum_non_enum_default(&mut self, long_enum_non_enum_default: LongEnum) { + self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, long_enum_non_enum_default, Default::default()); + } + + #[inline] + pub fn add_long_enum_normal_default(&mut self, long_enum_normal_default: LongEnum) { + self.fbb_.push_slot::(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne); + } + + #[inline] + pub fn add_nan_default(&mut self, nan_default: f32) { + self.fbb_.push_slot::(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN); + } + + #[inline] + pub fn add_inf_default(&mut self, inf_default: f32) { + self.fbb_.push_slot::(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY); + } + + #[inline] + pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) { + self.fbb_.push_slot::(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY); + } + + #[inline] + pub fn add_infinity_default(&mut self, infinity_default: f32) { + self.fbb_.push_slot::(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY); + } + + #[inline] + pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) { + self.fbb_.push_slot::(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY); + } + + #[inline] + pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) { + self.fbb_.push_slot::(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY); + } + + #[inline] + pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) { + self.fbb_.push_slot::(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY); + } + + #[inline] + pub fn add_double_inf_default(&mut self, double_inf_default: f64) { + self.fbb_.push_slot::(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for Monster<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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.field("native_inline", &self.native_inline()); - ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default()); - ds.field("long_enum_normal_default", &self.long_enum_normal_default()); - ds.field("nan_default", &self.nan_default()); - ds.field("inf_default", &self.inf_default()); - ds.field("positive_inf_default", &self.positive_inf_default()); - ds.field("infinity_default", &self.infinity_default()); - ds.field("positive_infinity_default", &self.positive_infinity_default()); - ds.field("negative_inf_default", &self.negative_inf_default()); - ds.field("negative_infinity_default", &self.negative_infinity_default()); - ds.field("double_inf_default", &self.double_inf_default()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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.field("native_inline", &self.native_inline()); + ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default()); + ds.field("long_enum_normal_default", &self.long_enum_normal_default()); + ds.field("nan_default", &self.nan_default()); + ds.field("inf_default", &self.inf_default()); + ds.field("positive_inf_default", &self.positive_inf_default()); + ds.field("infinity_default", &self.infinity_default()); + ds.field("positive_infinity_default", &self.positive_infinity_default()); + ds.field("negative_inf_default", &self.negative_inf_default()); + ds.field("negative_infinity_default", &self.negative_infinity_default()); + ds.field("double_inf_default", &self.double_inf_default()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct MonsterT { - pub pos: Option, - pub mana: i16, - pub hp: i16, - pub name: alloc::string::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>, - pub native_inline: Option, - pub long_enum_non_enum_default: LongEnum, - pub long_enum_normal_default: LongEnum, - pub nan_default: f32, - pub inf_default: f32, - pub positive_inf_default: f32, - pub infinity_default: f32, - pub positive_infinity_default: f32, - pub negative_inf_default: f32, - pub negative_infinity_default: f32, - pub double_inf_default: f64, + pub pos: Option, + pub mana: i16, + pub hp: i16, + pub name: alloc::string::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>, + pub native_inline: Option, + pub long_enum_non_enum_default: LongEnum, + pub long_enum_normal_default: LongEnum, + pub nan_default: f32, + pub inf_default: f32, + pub positive_inf_default: f32, + pub infinity_default: f32, + pub positive_infinity_default: f32, + pub negative_inf_default: f32, + pub negative_infinity_default: f32, + pub double_inf_default: f64, } impl Default for MonsterT { - fn default() -> Self { - Self { - pos: None, - mana: 150, - hp: 100, - name: alloc::string::ToString::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, - native_inline: None, - long_enum_non_enum_default: Default::default(), - long_enum_normal_default: LongEnum::LongOne, - nan_default: f32::NAN, - inf_default: f32::INFINITY, - positive_inf_default: f32::INFINITY, - infinity_default: f32::INFINITY, - positive_infinity_default: f32::INFINITY, - negative_inf_default: f32::NEG_INFINITY, - negative_infinity_default: f32::NEG_INFINITY, - double_inf_default: f64::INFINITY, + fn default() -> Self { + Self { + pos: None, + mana: 150, + hp: 100, + name: alloc::string::ToString::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, + native_inline: None, + long_enum_non_enum_default: Default::default(), + long_enum_normal_default: LongEnum::LongOne, + nan_default: f32::NAN, + inf_default: f32::INFINITY, + positive_inf_default: f32::INFINITY, + infinity_default: f32::INFINITY, + positive_infinity_default: f32::INFINITY, + negative_inf_default: f32::NEG_INFINITY, + negative_infinity_default: f32::NEG_INFINITY, + double_inf_default: f64::INFINITY, + } } - } } impl MonsterT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) - }); - let testarrayofstring = self.testarrayofstring.as_ref().map(|x|{ - let w: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) - }); - let testarrayoftables = self.testarrayoftables.as_ref().map(|x|{ - let w: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) - }); - let testarrayofsortedstruct = self.testarrayofsortedstruct.as_ref().map(|x|{ - let w: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) - }); - let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack()); - let native_inline = native_inline_tmp.as_ref(); - let long_enum_non_enum_default = self.long_enum_non_enum_default; - let long_enum_normal_default = self.long_enum_normal_default; - let nan_default = self.nan_default; - let inf_default = self.inf_default; - let positive_inf_default = self.positive_inf_default; - let infinity_default = self.infinity_default; - let positive_infinity_default = self.positive_infinity_default; - let negative_inf_default = self.negative_inf_default; - let negative_infinity_default = self.negative_infinity_default; - let double_inf_default = self.double_inf_default; - 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, - native_inline, - long_enum_non_enum_default, - long_enum_normal_default, - nan_default, - inf_default, - positive_inf_default, - infinity_default, - positive_infinity_default, - negative_inf_default, - negative_infinity_default, - double_inf_default, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w) + }); + let testarrayofstring = self.testarrayofstring.as_ref().map(|x|{ + let w: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) + }); + let testarrayoftables = self.testarrayoftables.as_ref().map(|x|{ + let w: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w) + }); + let testarrayofsortedstruct = self.testarrayofsortedstruct.as_ref().map(|x|{ + let w: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::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: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w) + }); + let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack()); + let native_inline = native_inline_tmp.as_ref(); + let long_enum_non_enum_default = self.long_enum_non_enum_default; + let long_enum_normal_default = self.long_enum_normal_default; + let nan_default = self.nan_default; + let inf_default = self.inf_default; + let positive_inf_default = self.positive_inf_default; + let infinity_default = self.infinity_default; + let positive_infinity_default = self.positive_infinity_default; + let negative_inf_default = self.negative_inf_default; + let negative_infinity_default = self.negative_infinity_default; + let double_inf_default = self.double_inf_default; + 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, + native_inline, + long_enum_non_enum_default, + long_enum_normal_default, + nan_default, + inf_default, + positive_inf_default, + infinity_default, + positive_infinity_default, + negative_inf_default, + negative_infinity_default, + double_inf_default, + }) + } } /// Verifies that a buffer of bytes contains a `Monster` @@ -2290,7 +2290,7 @@ impl MonsterT { /// `root_as_monster_unchecked`. #[inline] pub fn root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) + ::flatbuffers::root::(buf) } /// Verifies that a buffer of bytes contains a size prefixed @@ -2301,7 +2301,7 @@ pub fn root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::Invalid /// `size_prefixed_root_as_monster_unchecked`. #[inline] pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) + ::flatbuffers::size_prefixed_root::(buf) } /// Verifies, with the given options, that a buffer of bytes @@ -2312,10 +2312,10 @@ pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result, ::flatbu /// `root_as_monster_unchecked`. #[inline] pub fn root_as_monster_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) + ::flatbuffers::root_with_opts::>(opts, buf) } /// Verifies, with the given verifier options, that a buffer of @@ -2326,10 +2326,10 @@ pub fn root_as_monster_with_opts<'b, 'o>( /// `root_as_monster_unchecked`. #[inline] pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } /// Assumes, without verification, that a buffer of bytes contains a Monster and returns it. @@ -2337,7 +2337,7 @@ pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>( /// Callers must trust the given bytes do indeed contain a valid `Monster`. #[inline] pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } + unsafe { ::flatbuffers::root_unchecked::(buf) } } /// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it. @@ -2345,19 +2345,19 @@ pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { /// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`. #[inline] pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + unsafe { ::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) + ::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) + ::flatbuffers::buffer_has_identifier(buf, MONSTER_IDENTIFIER, true) } pub const MONSTER_EXTENSION: &str = "mon"; @@ -2365,11 +2365,15 @@ pub const MONSTER_EXTENSION: &str = "mon"; #[inline] pub fn finish_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>) { - fbb.finish(root, Some(MONSTER_IDENTIFIER)); + root: ::flatbuffers::WIPOffset> +) { + fbb.finish(root, Some(MONSTER_IDENTIFIER)); } #[inline] -pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset>) { - fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER)); +pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset> +) { + fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER)); } diff --git a/tests/monster_test_serialize/my_game/example/race_generated.rs b/tests/monster_test_serialize/my_game/example/race_generated.rs index 1f6de1d4e..b3e0e13d6 100644 --- a/tests/monster_test_serialize/my_game/example/race_generated.rs +++ b/tests/monster_test_serialize/my_game/example/race_generated.rs @@ -14,10 +14,10 @@ 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, + Race::None, + Race::Human, + Race::Dwarf, + Race::Elf, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -26,49 +26,49 @@ 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 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, - ]; + 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, + /// 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 ::core::fmt::Debug for Race { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } } - } } impl Serialize for Race { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_unit_variant("Race", self.0 as u32, self.variant_name().unwrap()) - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_unit_variant("Race", self.0 as u32, self.variant_name().unwrap()) + } } impl<'de> serde::Deserialize<'de> for Race { @@ -91,13 +91,13 @@ impl<'de> serde::Deserialize<'de> for Race { } impl<'a> ::flatbuffers::Follow<'a> for Race { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -110,28 +110,28 @@ impl ::flatbuffers::Push for Race { } impl ::flatbuffers::EndianScalar for Race { - type Scalar = i8; + type Scalar = i8; - #[inline] - fn to_little_endian(self) -> i8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i8) -> Self { - let b = i8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i8) -> Self { + let b = i8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for Race { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Race {} diff --git a/tests/monster_test_serialize/my_game/example/referrable_generated.rs b/tests/monster_test_serialize/my_game/example/referrable_generated.rs index c861df0d2..d7224c45d 100644 --- a/tests/monster_test_serialize/my_game/example/referrable_generated.rs +++ b/tests/monster_test_serialize/my_game/example/referrable_generated.rs @@ -9,77 +9,77 @@ pub enum ReferrableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Referrable<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Referrable<'a> { - type Inner = Referrable<'a>; + type Inner = Referrable<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Referrable<'a> { - pub const VT_ID: ::flatbuffers::VOffsetT = 4; + pub const VT_ID: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.Referrable" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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 fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Referrable" } - } - #[inline] - pub fn id(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Referrable::VT_ID, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Referrable { _tab: table } + } - #[inline] - pub fn key_compare_less_than(&self, o: &Referrable) -> bool { - self.id() < o.id() - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args ReferrableArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = ReferrableBuilder::new(_fbb); + builder.add_id(args.id); + builder.finish() + } - #[inline] - pub fn key_compare_with_value(&self, val: u64) -> ::core::cmp::Ordering { - let key = self.id(); - key.cmp(&val) - } + pub fn unpack(&self) -> ReferrableT { + let id = self.id(); + ReferrableT { + id, + } + } + + #[inline] + pub fn id(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { 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) -> ::core::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> { - v.visit_table(pos)? - .visit_field::("id", Self::VT_ID, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("id", Self::VT_ID, false)? + .finish(); + Ok(()) + } } pub struct ReferrableArgs { @@ -87,82 +87,82 @@ pub struct ReferrableArgs { } impl<'a> Default for ReferrableArgs { - #[inline] - fn default() -> Self { - ReferrableArgs { - id: 0, + #[inline] + fn default() -> Self { + ReferrableArgs { + id: 0, + } } - } } impl Serialize for Referrable<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let mut s = serializer.serialize_struct("Referrable", 1)?; - s.serialize_field("id", &self.id())?; - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut s = serializer.serialize_struct("Referrable", 1)?; + s.serialize_field("id", &self.id())?; + s.end() + } } pub struct ReferrableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ReferrableBuilder<'a, 'b, A> { - #[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, A>) -> ReferrableBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - ReferrableBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_id(&mut self, id: u64) { + self.fbb_.push_slot::(Referrable::VT_ID, id, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ReferrableBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for Referrable<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Referrable"); - ds.field("id", &self.id()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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, + pub id: u64, } impl Default for ReferrableT { - fn default() -> Self { - Self { - id: 0, + fn default() -> Self { + Self { + id: 0, + } } - } } impl ReferrableT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let id = self.id; - Referrable::create(_fbb, &ReferrableArgs{ - id, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let id = self.id; + Referrable::create(_fbb, &ReferrableArgs{ + id, + }) + } } diff --git a/tests/monster_test_serialize/my_game/example/stat_generated.rs b/tests/monster_test_serialize/my_game/example/stat_generated.rs index 1d4d43f73..eb81b1cdf 100644 --- a/tests/monster_test_serialize/my_game/example/stat_generated.rs +++ b/tests/monster_test_serialize/my_game/example/stat_generated.rs @@ -9,105 +9,105 @@ pub enum StatOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Stat<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Stat<'a> { - type Inner = Stat<'a>; + type Inner = Stat<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Stat<'a> { - pub const VT_ID: ::flatbuffers::VOffsetT = 4; - pub const VT_VAL: ::flatbuffers::VOffsetT = 6; - pub const VT_COUNT: ::flatbuffers::VOffsetT = 8; + pub const VT_ID: ::flatbuffers::VOffsetT = 4; + pub const VT_VAL: ::flatbuffers::VOffsetT = 6; + pub const VT_COUNT: ::flatbuffers::VOffsetT = 8; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.Stat" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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| { - alloc::string::ToString::to_string(x) - }); - let val = self.val(); - let count = self.count(); - StatT { - id, - val, - count, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Stat" } - } - #[inline] - pub fn id(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Stat::VT_ID, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Stat { _tab: table } + } - #[inline] - pub fn val(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Stat::VT_VAL, Some(0)).unwrap()} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + 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() + } - #[inline] - pub fn count(&self) -> u16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Stat::VT_COUNT, Some(0)).unwrap()} - } + pub fn unpack(&self) -> StatT { + let id = self.id().map(|x| { + alloc::string::ToString::to_string(x) + }); + let val = self.val(); + let count = self.count(); + StatT { + id, + val, + count, + } + } - #[inline] - pub fn key_compare_less_than(&self, o: &Stat) -> bool { - self.count() < o.count() - } + #[inline] + pub fn id(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Stat::VT_ID, None)} + } - #[inline] - pub fn key_compare_with_value(&self, val: u16) -> ::core::cmp::Ordering { - let key = self.count(); - key.cmp(&val) - } + #[inline] + pub fn val(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Stat::VT_VAL, Some(0)).unwrap()} + } + + #[inline] + pub fn count(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { 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) -> ::core::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> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)? - .visit_field::("val", Self::VT_VAL, false)? - .visit_field::("count", Self::VT_COUNT, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("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> { @@ -117,112 +117,112 @@ pub struct StatArgs<'a> { } impl<'a> Default for StatArgs<'a> { - #[inline] - fn default() -> Self { - StatArgs { - id: None, - val: 0, - count: 0, + #[inline] + fn default() -> Self { + StatArgs { + id: None, + val: 0, + count: 0, + } } - } } impl Serialize for Stat<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let mut s = serializer.serialize_struct("Stat", 3)?; - if let Some(f) = self.id() { - s.serialize_field("id", &f)?; - } else { - s.skip_field("id")?; - } - s.serialize_field("val", &self.val())?; - s.serialize_field("count", &self.count())?; - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut s = serializer.serialize_struct("Stat", 3)?; + if let Some(f) = self.id() { + s.serialize_field("id", &f)?; + } else { + s.skip_field("id")?; + } + s.serialize_field("val", &self.val())?; + s.serialize_field("count", &self.count())?; + s.end() + } } pub struct StatBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StatBuilder<'a, 'b, A> { - #[inline] - pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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, A>) -> StatBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - StatBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Stat::VT_ID, id); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[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, A>) -> StatBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for Stat<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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, + pub id: Option, + pub val: i64, + pub count: u16, } impl Default for StatT { - fn default() -> Self { - Self { - id: None, - val: 0, - count: 0, + fn default() -> Self { + Self { + id: None, + val: 0, + count: 0, + } } - } } impl StatT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::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 fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::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, + }) + } } diff --git a/tests/monster_test_serialize/my_game/example/struct_of_structs_generated.rs b/tests/monster_test_serialize/my_game/example/struct_of_structs_generated.rs index 870656243..053cb49e8 100644 --- a/tests/monster_test_serialize/my_game/example/struct_of_structs_generated.rs +++ b/tests/monster_test_serialize/my_game/example/struct_of_structs_generated.rs @@ -10,40 +10,40 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct StructOfStructs(pub [u8; 20]); -impl Default for StructOfStructs { - fn default() -> Self { - Self([0; 20]) - } +impl Default for StructOfStructs { + fn default() -> Self { + Self([0; 20]) + } } impl ::core::fmt::Debug for StructOfStructs { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("StructOfStructs") - .field("a", &self.a()) - .field("b", &self.b()) - .field("c", &self.c()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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<'a> ::flatbuffers::Follow<'a> for StructOfStructs { - type Inner = &'a StructOfStructs; + type Inner = &'a StructOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a StructOfStructs>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a StructOfStructs>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a StructOfStructs { - type Inner = &'a StructOfStructs; + type Inner = &'a StructOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for StructOfStructs { @@ -62,103 +62,103 @@ impl<'b> ::flatbuffers::Push for StructOfStructs { } impl<'a> ::flatbuffers::Verifiable for StructOfStructs { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl Serialize for StructOfStructs { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { let mut s = serializer.serialize_struct("StructOfStructs", 3)?; - s.serialize_field("a", &self.a())?; - s.serialize_field("b", &self.b())?; - s.serialize_field("c", &self.c())?; - s.end() - } + s.serialize_field("a", &self.a())?; + s.serialize_field("b", &self.b())?; + s.serialize_field("c", &self.c())?; + s.end() + } } 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 { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[0..].as_ptr() as *const Ability) } - } - - #[allow(clippy::identity_op)] - pub fn set_a(&mut self, x: &Ability) { - self.0[0..0 + 8].copy_from_slice(&x.0) - } - - pub fn b(&self) -> &Test { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[8..].as_ptr() as *const Test) } - } - - #[allow(clippy::identity_op)] - pub fn set_b(&mut self, x: &Test) { - self.0[8..8 + 4].copy_from_slice(&x.0) - } - - pub fn c(&self) -> &Ability { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[12..].as_ptr() as *const Ability) } - } - - #[allow(clippy::identity_op)] - 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(), + #[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 { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[0..].as_ptr() as *const Ability) } + } + + #[allow(clippy::identity_op)] + pub fn set_a(&mut self, x: &Ability) { + self.0[0..0 + 8].copy_from_slice(&x.0) + } + + pub fn b(&self) -> &Test { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[8..].as_ptr() as *const Test) } + } + + #[allow(clippy::identity_op)] + pub fn set_b(&mut self, x: &Test) { + self.0[8..8 + 4].copy_from_slice(&x.0) + } + + pub fn c(&self) -> &Ability { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[12..].as_ptr() as *const Ability) } + } + + #[allow(clippy::identity_op)] + 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, + 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 fn pack(&self) -> StructOfStructs { + StructOfStructs::new( + &self.a.pack(), + &self.b.pack(), + &self.c.pack(), + ) + } } diff --git a/tests/monster_test_serialize/my_game/example/struct_of_structs_of_structs_generated.rs b/tests/monster_test_serialize/my_game/example/struct_of_structs_of_structs_generated.rs index dae0180a6..9172c8c51 100644 --- a/tests/monster_test_serialize/my_game/example/struct_of_structs_of_structs_generated.rs +++ b/tests/monster_test_serialize/my_game/example/struct_of_structs_of_structs_generated.rs @@ -10,38 +10,38 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct StructOfStructsOfStructs(pub [u8; 20]); -impl Default for StructOfStructsOfStructs { - fn default() -> Self { - Self([0; 20]) - } +impl Default for StructOfStructsOfStructs { + fn default() -> Self { + Self([0; 20]) + } } impl ::core::fmt::Debug for StructOfStructsOfStructs { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("StructOfStructsOfStructs") - .field("a", &self.a()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("StructOfStructsOfStructs") + .field("a", &self.a()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for StructOfStructsOfStructs {} impl<'a> ::flatbuffers::Follow<'a> for StructOfStructsOfStructs { - type Inner = &'a StructOfStructsOfStructs; + type Inner = &'a StructOfStructsOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a StructOfStructsOfStructs>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a StructOfStructsOfStructs>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a StructOfStructsOfStructs { - type Inner = &'a StructOfStructsOfStructs; + type Inner = &'a StructOfStructsOfStructs; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for StructOfStructsOfStructs { @@ -60,67 +60,67 @@ impl<'b> ::flatbuffers::Push for StructOfStructsOfStructs { } impl<'a> ::flatbuffers::Verifiable for StructOfStructsOfStructs { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl Serialize for StructOfStructsOfStructs { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { let mut s = serializer.serialize_struct("StructOfStructsOfStructs", 1)?; - s.serialize_field("a", &self.a())?; - s.end() - } + s.serialize_field("a", &self.a())?; + s.end() + } } impl<'a> StructOfStructsOfStructs { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: &StructOfStructs, - ) -> Self { - let mut s = Self([0; 20]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.StructOfStructsOfStructs" - } - - pub fn a(&self) -> &StructOfStructs { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[0..].as_ptr() as *const StructOfStructs) } - } - - #[allow(clippy::identity_op)] - pub fn set_a(&mut self, x: &StructOfStructs) { - self.0[0..0 + 20].copy_from_slice(&x.0) - } - - pub fn unpack(&self) -> StructOfStructsOfStructsT { - StructOfStructsOfStructsT { - a: self.a().unpack(), + #[allow(clippy::too_many_arguments)] + pub fn new( + a: &StructOfStructs, + ) -> Self { + let mut s = Self([0; 20]); + s.set_a(a); + s + } + + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.StructOfStructsOfStructs" + } + + pub fn a(&self) -> &StructOfStructs { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[0..].as_ptr() as *const StructOfStructs) } + } + + #[allow(clippy::identity_op)] + pub fn set_a(&mut self, x: &StructOfStructs) { + self.0[0..0 + 20].copy_from_slice(&x.0) + } + + pub fn unpack(&self) -> StructOfStructsOfStructsT { + StructOfStructsOfStructsT { + a: self.a().unpack(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct StructOfStructsOfStructsT { - pub a: StructOfStructsT, + pub a: StructOfStructsT, } impl StructOfStructsOfStructsT { - pub fn pack(&self) -> StructOfStructsOfStructs { - StructOfStructsOfStructs::new( - &self.a.pack(), - ) - } + pub fn pack(&self) -> StructOfStructsOfStructs { + StructOfStructsOfStructs::new( + &self.a.pack(), + ) + } } diff --git a/tests/monster_test_serialize/my_game/example/test_generated.rs b/tests/monster_test_serialize/my_game/example/test_generated.rs index b1e4e2c92..f34509cd9 100644 --- a/tests/monster_test_serialize/my_game/example/test_generated.rs +++ b/tests/monster_test_serialize/my_game/example/test_generated.rs @@ -10,39 +10,39 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Test(pub [u8; 4]); -impl Default for Test { - fn default() -> Self { - Self([0; 4]) - } +impl Default for Test { + fn default() -> Self { + Self([0; 4]) + } } impl ::core::fmt::Debug for Test { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Test") - .field("a", &self.a()) - .field("b", &self.b()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Test") + .field("a", &self.a()) + .field("b", &self.b()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Test {} impl<'a> ::flatbuffers::Follow<'a> for Test { - type Inner = &'a Test; + type Inner = &'a Test; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Test>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Test>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Test { - type Inner = &'a Test; + type Inner = &'a Test; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Test { @@ -61,119 +61,119 @@ impl<'b> ::flatbuffers::Push for Test { } impl<'a> ::flatbuffers::Verifiable for Test { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl Serialize for Test { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { let mut s = serializer.serialize_struct("Test", 2)?; - s.serialize_field("a", &self.a())?; - s.serialize_field("b", &self.b())?; - s.end() - } + s.serialize_field("a", &self.a())?; + s.serialize_field("b", &self.b())?; + s.end() + } } 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::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i16) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[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 fn b(&self) -> i8 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[2..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_b(&mut self, x: i8) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[2..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Test" } - } - pub fn unpack(&self) -> TestT { - TestT { - a: self.a(), - b: self.b(), + pub fn a(&self) -> i16 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i16) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn b(&self) -> i8 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[2..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_b(&mut self, x: i8) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[2..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + 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, + pub a: i16, + pub b: i8, } impl TestT { - pub fn pack(&self) -> Test { - Test::new( - self.a, - self.b, - ) - } + pub fn pack(&self) -> Test { + Test::new( + self.a, + self.b, + ) + } } diff --git a/tests/monster_test_serialize/my_game/example/test_simple_table_with_enum_generated.rs b/tests/monster_test_serialize/my_game/example/test_simple_table_with_enum_generated.rs index c55e1cb1e..6cd14b1e7 100644 --- a/tests/monster_test_serialize/my_game/example/test_simple_table_with_enum_generated.rs +++ b/tests/monster_test_serialize/my_game/example/test_simple_table_with_enum_generated.rs @@ -9,66 +9,66 @@ pub enum TestSimpleTableWithEnumOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TestSimpleTableWithEnum<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TestSimpleTableWithEnum<'a> { - type Inner = TestSimpleTableWithEnum<'a>; + type Inner = TestSimpleTableWithEnum<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TestSimpleTableWithEnum<'a> { - pub const VT_COLOR: ::flatbuffers::VOffsetT = 4; + pub const VT_COLOR: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.TestSimpleTableWithEnum" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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 fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.TestSimpleTableWithEnum" } - } - #[inline] - pub fn color(&self) -> Color { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TestSimpleTableWithEnum::VT_COLOR, Some(Color::Green)).unwrap()} - } + #[inline] + pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + 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, + } + } + + #[inline] + pub fn color(&self) -> Color { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { 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> { - v.visit_table(pos)? - .visit_field::("color", Self::VT_COLOR, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("color", Self::VT_COLOR, false)? + .finish(); + Ok(()) + } } pub struct TestSimpleTableWithEnumArgs { @@ -76,82 +76,82 @@ pub struct TestSimpleTableWithEnumArgs { } impl<'a> Default for TestSimpleTableWithEnumArgs { - #[inline] - fn default() -> Self { - TestSimpleTableWithEnumArgs { - color: Color::Green, + #[inline] + fn default() -> Self { + TestSimpleTableWithEnumArgs { + color: Color::Green, + } } - } } impl Serialize for TestSimpleTableWithEnum<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let mut s = serializer.serialize_struct("TestSimpleTableWithEnum", 1)?; - s.serialize_field("color", &self.color())?; - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut s = serializer.serialize_struct("TestSimpleTableWithEnum", 1)?; + s.serialize_field("color", &self.color())?; + s.end() + } } pub struct TestSimpleTableWithEnumBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TestSimpleTableWithEnumBuilder<'a, 'b, A> { - #[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, A>) -> TestSimpleTableWithEnumBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TestSimpleTableWithEnumBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_color(&mut self, color: Color) { + self.fbb_.push_slot::(TestSimpleTableWithEnum::VT_COLOR, color, Color::Green); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TestSimpleTableWithEnumBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for TestSimpleTableWithEnum<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TestSimpleTableWithEnum"); - ds.field("color", &self.color()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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, + pub color: Color, } impl Default for TestSimpleTableWithEnumT { - fn default() -> Self { - Self { - color: Color::Green, + fn default() -> Self { + Self { + color: Color::Green, + } } - } } impl TestSimpleTableWithEnumT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let color = self.color; - TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{ - color, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let color = self.color; + TestSimpleTableWithEnum::create(_fbb, &TestSimpleTableWithEnumArgs{ + color, + }) + } } diff --git a/tests/monster_test_serialize/my_game/example/type_aliases_generated.rs b/tests/monster_test_serialize/my_game/example/type_aliases_generated.rs index 5c6393f15..698b5f729 100644 --- a/tests/monster_test_serialize/my_game/example/type_aliases_generated.rs +++ b/tests/monster_test_serialize/my_game/example/type_aliases_generated.rs @@ -9,213 +9,213 @@ pub enum TypeAliasesOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TypeAliases<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TypeAliases<'a> { - type Inner = TypeAliases<'a>; + type Inner = TypeAliases<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TypeAliases<'a> { - 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; + 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; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example.TypeAliases" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - 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.into_iter().collect() - }); - 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 fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.TypeAliases" } - } - #[inline] - pub fn i8_(&self) -> i8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I8_, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TypeAliases { _tab: table } + } - #[inline] - pub fn u8_(&self) -> u8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U8_, Some(0)).unwrap()} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + 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() + } - #[inline] - pub fn i16_(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I16_, Some(0)).unwrap()} - } + 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.into_iter().collect() + }); + let vf64 = self.vf64().map(|x| { + x.into_iter().collect() + }); + TypeAliasesT { + i8_, + u8_, + i16_, + u16_, + i32_, + u32_, + i64_, + u64_, + f32_, + f64_, + v8, + vf64, + } + } - #[inline] - pub fn u16_(&self) -> u16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U16_, Some(0)).unwrap()} - } + #[inline] + pub fn i8_(&self) -> i8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I8_, Some(0)).unwrap()} + } - #[inline] - pub fn i32_(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I32_, Some(0)).unwrap()} - } + #[inline] + pub fn u8_(&self) -> u8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U8_, Some(0)).unwrap()} + } - #[inline] - pub fn u32_(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U32_, Some(0)).unwrap()} - } + #[inline] + pub fn i16_(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I16_, Some(0)).unwrap()} + } - #[inline] - pub fn i64_(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_I64_, Some(0)).unwrap()} - } + #[inline] + pub fn u16_(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U16_, Some(0)).unwrap()} + } - #[inline] - pub fn u64_(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_U64_, Some(0)).unwrap()} - } + #[inline] + pub fn i32_(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I32_, Some(0)).unwrap()} + } - #[inline] - pub fn f32_(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_F32_, Some(0.0)).unwrap()} - } + #[inline] + pub fn u32_(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U32_, Some(0)).unwrap()} + } - #[inline] - pub fn f64_(&self) -> f64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TypeAliases::VT_F64_, Some(0.0)).unwrap()} - } + #[inline] + pub fn i64_(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_I64_, Some(0)).unwrap()} + } - #[inline] - pub fn v8(&self) -> Option<::flatbuffers::Vector<'a, i8>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i8>>>(TypeAliases::VT_V8, None)} - } + #[inline] + pub fn u64_(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_U64_, Some(0)).unwrap()} + } - #[inline] - pub fn vf64(&self) -> Option<::flatbuffers::Vector<'a, f64>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(TypeAliases::VT_VF64, None)} - } + #[inline] + pub fn f32_(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_F32_, Some(0.0)).unwrap()} + } + + #[inline] + pub fn f64_(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TypeAliases::VT_F64_, Some(0.0)).unwrap()} + } + + #[inline] + pub fn v8(&self) -> Option<::flatbuffers::Vector<'a, i8>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i8>>>(TypeAliases::VT_V8, None)} + } + + #[inline] + pub fn vf64(&self) -> Option<::flatbuffers::Vector<'a, f64>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f64>>>(TypeAliases::VT_VF64, None)} + } } impl ::flatbuffers::Verifiable for TypeAliases<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - 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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i8>>>("v8", Self::VT_V8, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vf64", Self::VT_VF64, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + 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::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i8>>>("v8", Self::VT_V8, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("vf64", Self::VT_VF64, false)? + .finish(); + Ok(()) + } } pub struct TypeAliasesArgs<'a> { @@ -234,226 +234,226 @@ pub struct TypeAliasesArgs<'a> { } 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, + #[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, + } } - } } impl Serialize for TypeAliases<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let mut s = serializer.serialize_struct("TypeAliases", 12)?; - s.serialize_field("i8_", &self.i8_())?; - s.serialize_field("u8_", &self.u8_())?; - s.serialize_field("i16_", &self.i16_())?; - s.serialize_field("u16_", &self.u16_())?; - s.serialize_field("i32_", &self.i32_())?; - s.serialize_field("u32_", &self.u32_())?; - s.serialize_field("i64_", &self.i64_())?; - s.serialize_field("u64_", &self.u64_())?; - s.serialize_field("f32_", &self.f32_())?; - s.serialize_field("f64_", &self.f64_())?; - if let Some(f) = self.v8() { - s.serialize_field("v8", &f)?; - } else { - s.skip_field("v8")?; - } - if let Some(f) = self.vf64() { - s.serialize_field("vf64", &f)?; - } else { - s.skip_field("vf64")?; - } - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut s = serializer.serialize_struct("TypeAliases", 12)?; + s.serialize_field("i8_", &self.i8_())?; + s.serialize_field("u8_", &self.u8_())?; + s.serialize_field("i16_", &self.i16_())?; + s.serialize_field("u16_", &self.u16_())?; + s.serialize_field("i32_", &self.i32_())?; + s.serialize_field("u32_", &self.u32_())?; + s.serialize_field("i64_", &self.i64_())?; + s.serialize_field("u64_", &self.u64_())?; + s.serialize_field("f32_", &self.f32_())?; + s.serialize_field("f64_", &self.f64_())?; + if let Some(f) = self.v8() { + s.serialize_field("v8", &f)?; + } else { + s.skip_field("v8")?; + } + if let Some(f) = self.vf64() { + s.serialize_field("vf64", &f)?; + } else { + s.skip_field("vf64")?; + } + s.end() + } } pub struct TypeAliasesBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TypeAliasesBuilder<'a, 'b, A> { - #[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<::flatbuffers::Vector<'b , i8>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_V8, v8); - } - - #[inline] - pub fn add_vf64(&mut self, vf64: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TypeAliasesBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TypeAliasesBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_i8_(&mut self, i8_: i8) { + self.fbb_.push_slot::(TypeAliases::VT_I8_, i8_, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[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<::flatbuffers::Vector<'b , i8>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_V8, v8); + } + + #[inline] + pub fn add_vf64(&mut self, vf64: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TypeAliases::VT_VF64, vf64); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TypeAliasesBuilder<'a, 'b, A> { + 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 ::core::fmt::Debug for TypeAliases<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::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>, + 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, + 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, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::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, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::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, + }) + } } diff --git a/tests/monster_test_serialize/my_game/example/vec_3_generated.rs b/tests/monster_test_serialize/my_game/example/vec_3_generated.rs index f92107d6d..193c4c48e 100644 --- a/tests/monster_test_serialize/my_game/example/vec_3_generated.rs +++ b/tests/monster_test_serialize/my_game/example/vec_3_generated.rs @@ -10,43 +10,43 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Vec3(pub [u8; 32]); -impl Default for Vec3 { - fn default() -> Self { - Self([0; 32]) - } +impl Default for Vec3 { + fn default() -> Self { + Self([0; 32]) + } } impl ::core::fmt::Debug for Vec3 { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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<'a> ::flatbuffers::Follow<'a> for Vec3 { - type Inner = &'a Vec3; + type Inner = &'a Vec3; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Vec3>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Vec3>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Vec3 { - type Inner = &'a Vec3; + type Inner = &'a Vec3; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Vec3 { @@ -65,242 +65,242 @@ impl<'b> ::flatbuffers::Push for Vec3 { } impl<'a> ::flatbuffers::Verifiable for Vec3 { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl Serialize for Vec3 { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { let mut s = serializer.serialize_struct("Vec3", 6)?; - s.serialize_field("x", &self.x())?; - s.serialize_field("y", &self.y())?; - s.serialize_field("z", &self.z())?; - s.serialize_field("test1", &self.test1())?; - s.serialize_field("test2", &self.test2())?; - s.serialize_field("test3", &self.test3())?; - s.end() - } + s.serialize_field("x", &self.x())?; + s.serialize_field("y", &self.y())?; + s.serialize_field("z", &self.z())?; + s.serialize_field("test1", &self.test1())?; + s.serialize_field("test2", &self.test2())?; + s.serialize_field("test3", &self.test3())?; + s.end() + } } 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::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_x(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[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 fn y(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[4..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_y(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[4..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example.Vec3" } - } - pub fn z(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[8..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_z(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[8..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn x(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) } - } - pub fn test1(&self) -> f64 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[16..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_test1(&mut self, x: f64) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[16..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn set_x(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } } - } - pub fn test2(&self) -> Color { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[24..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_test2(&mut self, x: Color) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[24..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn y(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[4..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) } - } - pub fn test3(&self) -> &Test { - // Safety: - // Created from a valid Table for this object - // Which contains a valid struct in this slot - unsafe { &*(self.0[26..].as_ptr() as *const Test) } - } - - #[allow(clippy::identity_op)] - 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(), + pub fn set_y(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[4..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn z(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[8..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_z(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[8..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn test1(&self) -> f64 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[16..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_test1(&mut self, x: f64) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[16..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn test2(&self) -> Color { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[24..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_test2(&mut self, x: Color) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[24..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn test3(&self) -> &Test { + // Safety: + // Created from a valid Table for this object + // Which contains a valid struct in this slot + unsafe { &*(self.0[26..].as_ptr() as *const Test) } + } + + #[allow(clippy::identity_op)] + 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, + 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(), - ) - } + pub fn pack(&self) -> Vec3 { + Vec3::new( + self.x, + self.y, + self.z, + self.test1, + self.test2, + &self.test3.pack(), + ) + } } diff --git a/tests/monster_test_serialize/my_game/example_2/monster_generated.rs b/tests/monster_test_serialize/my_game/example_2/monster_generated.rs index cef325de8..7c5856e6c 100644 --- a/tests/monster_test_serialize/my_game/example_2/monster_generated.rs +++ b/tests/monster_test_serialize/my_game/example_2/monster_generated.rs @@ -9,102 +9,102 @@ pub enum MonsterOffset {} #[derive(Copy, Clone, PartialEq)] pub struct Monster<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> { - type Inner = Monster<'a>; + type Inner = Monster<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Monster<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.Example2.Monster" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args MonsterArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = MonsterBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> MonsterT { - MonsterT { + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.Example2.Monster" + } + + #[inline] + pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _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> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct MonsterArgs { } impl<'a> Default for MonsterArgs { - #[inline] - fn default() -> Self { - MonsterArgs { + #[inline] + fn default() -> Self { + MonsterArgs { + } } - } } impl Serialize for Monster<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let s = serializer.serialize_struct("Monster", 0)?; - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let s = serializer.serialize_struct("Monster", 0)?; + s.end() + } } pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - MonsterBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> { + 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()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for Monster<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Monster"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Monster"); + ds.finish() + } } #[non_exhaustive] @@ -113,18 +113,18 @@ pub struct MonsterT { } impl Default for MonsterT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl MonsterT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - Monster::create(_fbb, &MonsterArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + Monster::create(_fbb, &MonsterArgs{ + }) + } } diff --git a/tests/monster_test_serialize/my_game/in_parent_namespace_generated.rs b/tests/monster_test_serialize/my_game/in_parent_namespace_generated.rs index 19d3fdf0b..2b4bcc169 100644 --- a/tests/monster_test_serialize/my_game/in_parent_namespace_generated.rs +++ b/tests/monster_test_serialize/my_game/in_parent_namespace_generated.rs @@ -9,102 +9,102 @@ pub enum InParentNamespaceOffset {} #[derive(Copy, Clone, PartialEq)] pub struct InParentNamespace<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for InParentNamespace<'a> { - type Inner = InParentNamespace<'a>; + type Inner = InParentNamespace<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> InParentNamespace<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.InParentNamespace" - } - - #[inline] - pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args InParentNamespaceArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = InParentNamespaceBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> InParentNamespaceT { - InParentNamespaceT { + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.InParentNamespace" + } + + #[inline] + pub unsafe 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, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _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> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct InParentNamespaceArgs { } impl<'a> Default for InParentNamespaceArgs { - #[inline] - fn default() -> Self { - InParentNamespaceArgs { + #[inline] + fn default() -> Self { + InParentNamespaceArgs { + } } - } } impl Serialize for InParentNamespace<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let s = serializer.serialize_struct("InParentNamespace", 0)?; - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let s = serializer.serialize_struct("InParentNamespace", 0)?; + s.end() + } } pub struct InParentNamespaceBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> InParentNamespaceBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> InParentNamespaceBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - InParentNamespaceBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> InParentNamespaceBuilder<'a, 'b, A> { + 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()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for InParentNamespace<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("InParentNamespace"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("InParentNamespace"); + ds.finish() + } } #[non_exhaustive] @@ -113,18 +113,18 @@ pub struct InParentNamespaceT { } impl Default for InParentNamespaceT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl InParentNamespaceT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - InParentNamespace::create(_fbb, &InParentNamespaceArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + InParentNamespace::create(_fbb, &InParentNamespaceArgs{ + }) + } } diff --git a/tests/monster_test_serialize/my_game/other_name_space/from_include_generated.rs b/tests/monster_test_serialize/my_game/other_name_space/from_include_generated.rs index fb89543c7..1ee5da78f 100644 --- a/tests/monster_test_serialize/my_game/other_name_space/from_include_generated.rs +++ b/tests/monster_test_serialize/my_game/other_name_space/from_include_generated.rs @@ -14,7 +14,7 @@ pub const ENUM_MAX_FROM_INCLUDE: i64 = 0; #[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_FROM_INCLUDE: [FromInclude; 1] = [ - FromInclude::IncludeVal, + FromInclude::IncludeVal, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,40 +23,40 @@ pub struct FromInclude(pub i64); #[allow(non_upper_case_globals)] impl FromInclude { - pub const IncludeVal: Self = Self(0); + pub const IncludeVal: Self = Self(0); - pub const ENUM_MIN: i64 = 0; - pub const ENUM_MAX: i64 = 0; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::IncludeVal, - ]; + pub const ENUM_MIN: i64 = 0; + pub const ENUM_MAX: i64 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::IncludeVal, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::IncludeVal => Some("IncludeVal"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::IncludeVal => Some("IncludeVal"), + _ => None, + } } - } } impl ::core::fmt::Debug for FromInclude { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } } - } } impl Serialize for FromInclude { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_unit_variant("FromInclude", self.0 as u32, self.variant_name().unwrap()) - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_unit_variant("FromInclude", self.0 as u32, self.variant_name().unwrap()) + } } impl<'de> serde::Deserialize<'de> for FromInclude { @@ -79,13 +79,13 @@ impl<'de> serde::Deserialize<'de> for FromInclude { } impl<'a> ::flatbuffers::Follow<'a> for FromInclude { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for FromInclude { @@ -98,28 +98,28 @@ impl ::flatbuffers::Push for FromInclude { } impl ::flatbuffers::EndianScalar for FromInclude { - type Scalar = i64; + type Scalar = i64; - #[inline] - fn to_little_endian(self) -> i64 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i64 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i64) -> Self { - let b = i64::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i64) -> Self { + let b = i64::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for FromInclude { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i64::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i64::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {} diff --git a/tests/monster_test_serialize/my_game/other_name_space/table_b_generated.rs b/tests/monster_test_serialize/my_game/other_name_space/table_b_generated.rs index 9a7eb8825..177cfeb48 100644 --- a/tests/monster_test_serialize/my_game/other_name_space/table_b_generated.rs +++ b/tests/monster_test_serialize/my_game/other_name_space/table_b_generated.rs @@ -9,68 +9,68 @@ pub enum TableBOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableB<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> { - type Inner = TableB<'a>; + type Inner = TableB<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableB<'a> { - pub const VT_A: ::flatbuffers::VOffsetT = 4; + pub const VT_A: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.TableB" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableB { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableBArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableBBuilder::new(_fbb); - if let Some(x) = args.a { builder.add_a(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableBT { - let a = self.a().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableBT { - a, + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.TableB" } - } - #[inline] - pub fn a(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableB { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableBArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableBBuilder::new(_fbb); + if let Some(x) = args.a { builder.add_a(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableBT { + let a = self.a().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableBT { + a, + } + } + + #[inline] + pub fn a(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableB::VT_A, None)} + } } impl ::flatbuffers::Verifiable for TableB<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("a", Self::VT_A, false)? + .finish(); + Ok(()) + } } pub struct TableBArgs<'a> { @@ -78,88 +78,88 @@ pub struct TableBArgs<'a> { } impl<'a> Default for TableBArgs<'a> { - #[inline] - fn default() -> Self { - TableBArgs { - a: None, + #[inline] + fn default() -> Self { + TableBArgs { + a: None, + } } - } } impl Serialize for TableB<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let mut s = serializer.serialize_struct("TableB", 1)?; - if let Some(f) = self.a() { - s.serialize_field("a", &f)?; - } else { - s.skip_field("a")?; - } - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut s = serializer.serialize_struct("TableB", 1)?; + if let Some(f) = self.a() { + s.serialize_field("a", &f)?; + } else { + s.skip_field("a")?; + } + s.end() + } } pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> { - #[inline] - pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableBBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableB::VT_A, a); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableBBuilder { + 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 ::core::fmt::Debug for TableB<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableB"); - ds.field("a", &self.a()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableB"); + ds.field("a", &self.a()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableBT { - pub a: Option>, + pub a: Option>, } impl Default for TableBT { - fn default() -> Self { - Self { - a: None, + fn default() -> Self { + Self { + a: None, + } } - } } impl TableBT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let a = self.a.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableB::create(_fbb, &TableBArgs{ - a, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let a = self.a.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableB::create(_fbb, &TableBArgs{ + a, + }) + } } diff --git a/tests/monster_test_serialize/my_game/other_name_space/unused_generated.rs b/tests/monster_test_serialize/my_game/other_name_space/unused_generated.rs index 03491e295..4d8a1b986 100644 --- a/tests/monster_test_serialize/my_game/other_name_space/unused_generated.rs +++ b/tests/monster_test_serialize/my_game/other_name_space/unused_generated.rs @@ -10,38 +10,38 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct Unused(pub [u8; 4]); -impl Default for Unused { - fn default() -> Self { - Self([0; 4]) - } +impl Default for Unused { + fn default() -> Self { + Self([0; 4]) + } } impl ::core::fmt::Debug for Unused { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Unused") - .field("a", &self.a()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Unused") + .field("a", &self.a()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Unused {} impl<'a> ::flatbuffers::Follow<'a> for Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Unused>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Unused>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Unused { - type Inner = &'a Unused; + type Inner = &'a Unused; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Unused { @@ -60,84 +60,84 @@ impl<'b> ::flatbuffers::Push for Unused { } impl<'a> ::flatbuffers::Verifiable for Unused { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl Serialize for Unused { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { let mut s = serializer.serialize_struct("Unused", 1)?; - s.serialize_field("a", &self.a())?; - s.end() - } + s.serialize_field("a", &self.a())?; + s.end() + } } impl<'a> Unused { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: i32, - ) -> Self { - let mut s = Self([0; 4]); - s.set_a(a); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "MyGame.OtherNameSpace.Unused" - } - - pub fn a(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + a: i32, + ) -> Self { + let mut s = Self([0; 4]); + s.set_a(a); + s } - } - pub fn unpack(&self) -> UnusedT { - UnusedT { - a: self.a(), + pub const fn get_fully_qualified_name() -> &'static str { + "MyGame.OtherNameSpace.Unused" + } + + pub fn a(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> UnusedT { + UnusedT { + a: self.a(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct UnusedT { - pub a: i32, + pub a: i32, } impl UnusedT { - pub fn pack(&self) -> Unused { - Unused::new( - self.a, - ) - } + pub fn pack(&self) -> Unused { + Unused::new( + self.a, + ) + } } diff --git a/tests/monster_test_serialize/table_a_generated.rs b/tests/monster_test_serialize/table_a_generated.rs index 1f8a7093d..d079d5f9b 100644 --- a/tests/monster_test_serialize/table_a_generated.rs +++ b/tests/monster_test_serialize/table_a_generated.rs @@ -9,68 +9,68 @@ pub enum TableAOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableA<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> { - type Inner = TableA<'a>; + type Inner = TableA<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableA<'a> { - pub const VT_B: ::flatbuffers::VOffsetT = 4; + pub const VT_B: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "TableA" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableA { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableAArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableABuilder::new(_fbb); - if let Some(x) = args.b { builder.add_b(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableAT { - let b = self.b().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableAT { - b, + pub const fn get_fully_qualified_name() -> &'static str { + "TableA" } - } - #[inline] - pub fn b(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableA { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableAArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableABuilder::new(_fbb); + if let Some(x) = args.b { builder.add_b(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableAT { + let b = self.b().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableAT { + b, + } + } + + #[inline] + pub fn b(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableA::VT_B, None)} + } } impl ::flatbuffers::Verifiable for TableA<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("b", Self::VT_B, false)? + .finish(); + Ok(()) + } } pub struct TableAArgs<'a> { @@ -78,88 +78,88 @@ pub struct TableAArgs<'a> { } impl<'a> Default for TableAArgs<'a> { - #[inline] - fn default() -> Self { - TableAArgs { - b: None, + #[inline] + fn default() -> Self { + TableAArgs { + b: None, + } } - } } impl Serialize for TableA<'_> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let mut s = serializer.serialize_struct("TableA", 1)?; - if let Some(f) = self.b() { - s.serialize_field("b", &f)?; - } else { - s.skip_field("b")?; - } - s.end() - } + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut s = serializer.serialize_struct("TableA", 1)?; + if let Some(f) = self.b() { + s.serialize_field("b", &f)?; + } else { + s.skip_field("b")?; + } + s.end() + } } pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> { - #[inline] - pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableABuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableA::VT_B, b); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableABuilder { + 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 ::core::fmt::Debug for TableA<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableA"); - ds.field("b", &self.b()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableA"); + ds.field("b", &self.b()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableAT { - pub b: Option>, + pub b: Option>, } impl Default for TableAT { - fn default() -> Self { - Self { - b: None, + fn default() -> Self { + Self { + b: None, + } } - } } impl TableAT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let b = self.b.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableA::create(_fbb, &TableAArgs{ - b, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let b = self.b.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableA::create(_fbb, &TableAArgs{ + b, + }) + } } diff --git a/tests/more_defaults/abc_generated.rs b/tests/more_defaults/abc_generated.rs index a3c54fb5d..5a87917b7 100644 --- a/tests/more_defaults/abc_generated.rs +++ b/tests/more_defaults/abc_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_ABC: i32 = 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_ABC: [ABC; 3] = [ - ABC::A, - ABC::B, - ABC::C, + ABC::A, + ABC::B, + ABC::C, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub struct ABC(pub i32); #[allow(non_upper_case_globals)] impl ABC { - pub const A: Self = Self(0); - pub const B: Self = Self(1); - pub const C: Self = Self(2); + pub const A: Self = Self(0); + pub const B: Self = Self(1); + pub const C: Self = Self(2); - pub const ENUM_MIN: i32 = 0; - pub const ENUM_MAX: i32 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::A, - Self::B, - Self::C, - ]; + pub const ENUM_MIN: i32 = 0; + pub const ENUM_MAX: i32 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::A, + Self::B, + Self::C, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::A => Some("A"), - Self::B => Some("B"), - Self::C => Some("C"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::A => Some("A"), + Self::B => Some("B"), + Self::C => Some("C"), + _ => None, + } } - } } impl ::core::fmt::Debug for ABC { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 ABC { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for ABC { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for ABC { } impl ::flatbuffers::EndianScalar for ABC { - type Scalar = i32; + type Scalar = i32; - #[inline] - fn to_little_endian(self) -> i32 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i32 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i32) -> Self { - let b = i32::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i32) -> Self { + let b = i32::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for ABC { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i32::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i32::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for ABC {} diff --git a/tests/more_defaults/more_defaults_generated.rs b/tests/more_defaults/more_defaults_generated.rs index 784297cf5..709987577 100644 --- a/tests/more_defaults/more_defaults_generated.rs +++ b/tests/more_defaults/more_defaults_generated.rs @@ -7,149 +7,149 @@ pub enum MoreDefaultsOffset {} #[derive(Copy, Clone, PartialEq)] pub struct MoreDefaults<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for MoreDefaults<'a> { - type Inner = MoreDefaults<'a>; + type Inner = MoreDefaults<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> MoreDefaults<'a> { - pub const VT_INTS: ::flatbuffers::VOffsetT = 4; - pub const VT_FLOATS: ::flatbuffers::VOffsetT = 6; - pub const VT_EMPTY_STRING: ::flatbuffers::VOffsetT = 8; - pub const VT_SOME_STRING: ::flatbuffers::VOffsetT = 10; - pub const VT_ABCS: ::flatbuffers::VOffsetT = 12; - pub const VT_BOOLS: ::flatbuffers::VOffsetT = 14; + pub const VT_INTS: ::flatbuffers::VOffsetT = 4; + pub const VT_FLOATS: ::flatbuffers::VOffsetT = 6; + pub const VT_EMPTY_STRING: ::flatbuffers::VOffsetT = 8; + pub const VT_SOME_STRING: ::flatbuffers::VOffsetT = 10; + pub const VT_ABCS: ::flatbuffers::VOffsetT = 12; + pub const VT_BOOLS: ::flatbuffers::VOffsetT = 14; - pub const fn get_fully_qualified_name() -> &'static str { - "MoreDefaults" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - MoreDefaults { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args MoreDefaultsArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = MoreDefaultsBuilder::new(_fbb); - if let Some(x) = args.bools { builder.add_bools(x); } - if let Some(x) = args.abcs { builder.add_abcs(x); } - if let Some(x) = args.some_string { builder.add_some_string(x); } - if let Some(x) = args.empty_string { builder.add_empty_string(x); } - if let Some(x) = args.floats { builder.add_floats(x); } - if let Some(x) = args.ints { builder.add_ints(x); } - builder.finish() - } - - pub fn unpack(&self) -> MoreDefaultsT { - let ints = { - let x = self.ints(); - x.into_iter().collect() - }; - let floats = { - let x = self.floats(); - x.into_iter().collect() - }; - let empty_string = { - let x = self.empty_string(); - alloc::string::ToString::to_string(x) - }; - let some_string = { - let x = self.some_string(); - alloc::string::ToString::to_string(x) - }; - let abcs = { - let x = self.abcs(); - x.into_iter().collect() - }; - let bools = { - let x = self.bools(); - x.into_iter().collect() - }; - MoreDefaultsT { - ints, - floats, - empty_string, - some_string, - abcs, - bools, + pub const fn get_fully_qualified_name() -> &'static str { + "MoreDefaults" } - } - #[inline] - pub fn ints(&self) -> ::flatbuffers::Vector<'a, i32> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i32>>>(MoreDefaults::VT_INTS, Some(Default::default())).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + MoreDefaults { _tab: table } + } - #[inline] - pub fn floats(&self) -> ::flatbuffers::Vector<'a, f32> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f32>>>(MoreDefaults::VT_FLOATS, Some(Default::default())).unwrap()} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args MoreDefaultsArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = MoreDefaultsBuilder::new(_fbb); + if let Some(x) = args.bools { builder.add_bools(x); } + if let Some(x) = args.abcs { builder.add_abcs(x); } + if let Some(x) = args.some_string { builder.add_some_string(x); } + if let Some(x) = args.empty_string { builder.add_empty_string(x); } + if let Some(x) = args.floats { builder.add_floats(x); } + if let Some(x) = args.ints { builder.add_ints(x); } + builder.finish() + } - #[inline] - pub fn empty_string(&self) -> &'a str { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(MoreDefaults::VT_EMPTY_STRING, Some(&"")).unwrap()} - } + pub fn unpack(&self) -> MoreDefaultsT { + let ints = { + let x = self.ints(); + x.into_iter().collect() + }; + let floats = { + let x = self.floats(); + x.into_iter().collect() + }; + let empty_string = { + let x = self.empty_string(); + alloc::string::ToString::to_string(x) + }; + let some_string = { + let x = self.some_string(); + alloc::string::ToString::to_string(x) + }; + let abcs = { + let x = self.abcs(); + x.into_iter().collect() + }; + let bools = { + let x = self.bools(); + x.into_iter().collect() + }; + MoreDefaultsT { + ints, + floats, + empty_string, + some_string, + abcs, + bools, + } + } - #[inline] - pub fn some_string(&self) -> &'a str { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(MoreDefaults::VT_SOME_STRING, Some(&"some")).unwrap()} - } + #[inline] + pub fn ints(&self) -> ::flatbuffers::Vector<'a, i32> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, i32>>>(MoreDefaults::VT_INTS, Some(Default::default())).unwrap()} + } - #[inline] - pub fn abcs(&self) -> ::flatbuffers::Vector<'a, ABC> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ABC>>>(MoreDefaults::VT_ABCS, Some(Default::default())).unwrap()} - } + #[inline] + pub fn floats(&self) -> ::flatbuffers::Vector<'a, f32> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, f32>>>(MoreDefaults::VT_FLOATS, Some(Default::default())).unwrap()} + } - #[inline] - pub fn bools(&self) -> ::flatbuffers::Vector<'a, bool> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, bool>>>(MoreDefaults::VT_BOOLS, Some(Default::default())).unwrap()} - } + #[inline] + pub fn empty_string(&self) -> &'a str { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(MoreDefaults::VT_EMPTY_STRING, Some(&"")).unwrap()} + } + + #[inline] + pub fn some_string(&self) -> &'a str { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(MoreDefaults::VT_SOME_STRING, Some(&"some")).unwrap()} + } + + #[inline] + pub fn abcs(&self) -> ::flatbuffers::Vector<'a, ABC> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ABC>>>(MoreDefaults::VT_ABCS, Some(Default::default())).unwrap()} + } + + #[inline] + pub fn bools(&self) -> ::flatbuffers::Vector<'a, bool> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, bool>>>(MoreDefaults::VT_BOOLS, Some(Default::default())).unwrap()} + } } impl ::flatbuffers::Verifiable for MoreDefaults<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i32>>>("ints", Self::VT_INTS, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f32>>>("floats", Self::VT_FLOATS, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("empty_string", Self::VT_EMPTY_STRING, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("some_string", Self::VT_SOME_STRING, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ABC>>>("abcs", Self::VT_ABCS, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, bool>>>("bools", Self::VT_BOOLS, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i32>>>("ints", Self::VT_INTS, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f32>>>("floats", Self::VT_FLOATS, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("empty_string", Self::VT_EMPTY_STRING, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("some_string", Self::VT_SOME_STRING, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ABC>>>("abcs", Self::VT_ABCS, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, bool>>>("bools", Self::VT_BOOLS, false)? + .finish(); + Ok(()) + } } pub struct MoreDefaultsArgs<'a> { @@ -162,144 +162,144 @@ pub struct MoreDefaultsArgs<'a> { } impl<'a> Default for MoreDefaultsArgs<'a> { - #[inline] - fn default() -> Self { - MoreDefaultsArgs { - ints: None, - floats: None, - empty_string: None, - some_string: None, - abcs: None, - bools: None, + #[inline] + fn default() -> Self { + MoreDefaultsArgs { + ints: None, + floats: None, + empty_string: None, + some_string: None, + abcs: None, + bools: None, + } } - } } pub struct MoreDefaultsBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MoreDefaultsBuilder<'a, 'b, A> { - #[inline] - pub fn add_ints(&mut self, ints: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , i32>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_INTS, ints); - } - - #[inline] - pub fn add_floats(&mut self, floats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f32>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_FLOATS, floats); - } - - #[inline] - pub fn add_empty_string(&mut self, empty_string: ::flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_EMPTY_STRING, empty_string); - } - - #[inline] - pub fn add_some_string(&mut self, some_string: ::flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_SOME_STRING, some_string); - } - - #[inline] - pub fn add_abcs(&mut self, abcs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ABC>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_ABCS, abcs); - } - - #[inline] - pub fn add_bools(&mut self, bools: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , bool>>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_BOOLS, bools); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MoreDefaultsBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - MoreDefaultsBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_ints(&mut self, ints: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , i32>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_INTS, ints); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_floats(&mut self, floats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f32>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_FLOATS, floats); + } + + #[inline] + pub fn add_empty_string(&mut self, empty_string: ::flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_EMPTY_STRING, empty_string); + } + + #[inline] + pub fn add_some_string(&mut self, some_string: ::flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_SOME_STRING, some_string); + } + + #[inline] + pub fn add_abcs(&mut self, abcs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ABC>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_ABCS, abcs); + } + + #[inline] + pub fn add_bools(&mut self, bools: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , bool>>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MoreDefaults::VT_BOOLS, bools); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MoreDefaultsBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + MoreDefaultsBuilder { + 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 ::core::fmt::Debug for MoreDefaults<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("MoreDefaults"); - ds.field("ints", &self.ints()); - ds.field("floats", &self.floats()); - ds.field("empty_string", &self.empty_string()); - ds.field("some_string", &self.some_string()); - ds.field("abcs", &self.abcs()); - ds.field("bools", &self.bools()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("MoreDefaults"); + ds.field("ints", &self.ints()); + ds.field("floats", &self.floats()); + ds.field("empty_string", &self.empty_string()); + ds.field("some_string", &self.some_string()); + ds.field("abcs", &self.abcs()); + ds.field("bools", &self.bools()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct MoreDefaultsT { - pub ints: alloc::vec::Vec, - pub floats: alloc::vec::Vec, - pub empty_string: alloc::string::String, - pub some_string: alloc::string::String, - pub abcs: alloc::vec::Vec, - pub bools: alloc::vec::Vec, + pub ints: alloc::vec::Vec, + pub floats: alloc::vec::Vec, + pub empty_string: alloc::string::String, + pub some_string: alloc::string::String, + pub abcs: alloc::vec::Vec, + pub bools: alloc::vec::Vec, } impl Default for MoreDefaultsT { - fn default() -> Self { - Self { - ints: Default::default(), - floats: Default::default(), - empty_string: alloc::string::ToString::to_string(""), - some_string: alloc::string::ToString::to_string("some"), - abcs: Default::default(), - bools: Default::default(), + fn default() -> Self { + Self { + ints: Default::default(), + floats: Default::default(), + empty_string: alloc::string::ToString::to_string(""), + some_string: alloc::string::ToString::to_string("some"), + abcs: Default::default(), + bools: Default::default(), + } } - } } impl MoreDefaultsT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let ints = Some({ - let x = &self.ints; - _fbb.create_vector(x) - }); - let floats = Some({ - let x = &self.floats; - _fbb.create_vector(x) - }); - let empty_string = Some({ - let x = &self.empty_string; - _fbb.create_string(x) - }); - let some_string = Some({ - let x = &self.some_string; - _fbb.create_string(x) - }); - let abcs = Some({ - let x = &self.abcs; - _fbb.create_vector(x) - }); - let bools = Some({ - let x = &self.bools; - _fbb.create_vector(x) - }); - MoreDefaults::create(_fbb, &MoreDefaultsArgs{ - ints, - floats, - empty_string, - some_string, - abcs, - bools, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let ints = Some({ + let x = &self.ints; + _fbb.create_vector(x) + }); + let floats = Some({ + let x = &self.floats; + _fbb.create_vector(x) + }); + let empty_string = Some({ + let x = &self.empty_string; + _fbb.create_string(x) + }); + let some_string = Some({ + let x = &self.some_string; + _fbb.create_string(x) + }); + let abcs = Some({ + let x = &self.abcs; + _fbb.create_vector(x) + }); + let bools = Some({ + let x = &self.bools; + _fbb.create_vector(x) + }); + MoreDefaults::create(_fbb, &MoreDefaultsArgs{ + ints, + floats, + empty_string, + some_string, + abcs, + bools, + }) + } } diff --git a/tests/namespace_test/mod.rs b/tests/namespace_test/mod.rs index 22c667e8b..1a0c58c5d 100644 --- a/tests/namespace_test/mod.rs +++ b/tests/namespace_test/mod.rs @@ -1,25 +1,25 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod namespace_a { - use super::*; - pub mod namespace_b { use super::*; - mod union_in_nested_ns_generated; - pub use self::union_in_nested_ns_generated::*; - mod enum_in_nested_ns_generated; - pub use self::enum_in_nested_ns_generated::*; - mod table_in_nested_ns_generated; - pub use self::table_in_nested_ns_generated::*; - mod struct_in_nested_ns_generated; - pub use self::struct_in_nested_ns_generated::*; - } // namespace_b - mod table_in_first_ns_generated; - pub use self::table_in_first_ns_generated::*; - mod second_table_in_a_generated; - pub use self::second_table_in_a_generated::*; + pub mod namespace_b { + use super::*; + mod union_in_nested_ns_generated; + pub use self::union_in_nested_ns_generated::*; + mod enum_in_nested_ns_generated; + pub use self::enum_in_nested_ns_generated::*; + mod table_in_nested_ns_generated; + pub use self::table_in_nested_ns_generated::*; + mod struct_in_nested_ns_generated; + pub use self::struct_in_nested_ns_generated::*; + } // namespace_b + mod table_in_first_ns_generated; + pub use self::table_in_first_ns_generated::*; + mod second_table_in_a_generated; + pub use self::second_table_in_a_generated::*; } // namespace_a pub mod namespace_c { - use super::*; - mod table_in_c_generated; - pub use self::table_in_c_generated::*; + use super::*; + mod table_in_c_generated; + pub use self::table_in_c_generated::*; } // namespace_c diff --git a/tests/namespace_test/namespace_a/namespace_b/enum_in_nested_ns_generated.rs b/tests/namespace_test/namespace_a/namespace_b/enum_in_nested_ns_generated.rs index 54b79c197..e466ac869 100644 --- a/tests/namespace_test/namespace_a/namespace_b/enum_in_nested_ns_generated.rs +++ b/tests/namespace_test/namespace_a/namespace_b/enum_in_nested_ns_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_ENUM_IN_NESTED_NS: 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_ENUM_IN_NESTED_NS: [EnumInNestedNS; 3] = [ - EnumInNestedNS::A, - EnumInNestedNS::B, - EnumInNestedNS::C, + EnumInNestedNS::A, + EnumInNestedNS::B, + EnumInNestedNS::C, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub struct EnumInNestedNS(pub i8); #[allow(non_upper_case_globals)] impl EnumInNestedNS { - pub const A: Self = Self(0); - pub const B: Self = Self(1); - pub const C: Self = Self(2); + pub const A: Self = Self(0); + pub const B: Self = Self(1); + pub const C: Self = Self(2); - pub const ENUM_MIN: i8 = 0; - pub const ENUM_MAX: i8 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::A, - Self::B, - Self::C, - ]; + pub const ENUM_MIN: i8 = 0; + pub const ENUM_MAX: i8 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::A, + Self::B, + Self::C, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::A => Some("A"), - Self::B => Some("B"), - Self::C => Some("C"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::A => Some("A"), + Self::B => Some("B"), + Self::C => Some("C"), + _ => None, + } } - } } impl ::core::fmt::Debug for EnumInNestedNS { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 EnumInNestedNS { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for EnumInNestedNS { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for EnumInNestedNS { } impl ::flatbuffers::EndianScalar for EnumInNestedNS { - type Scalar = i8; + type Scalar = i8; - #[inline] - fn to_little_endian(self) -> i8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i8) -> Self { - let b = i8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i8) -> Self { + let b = i8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for EnumInNestedNS { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for EnumInNestedNS {} diff --git a/tests/namespace_test/namespace_a/namespace_b/struct_in_nested_ns_generated.rs b/tests/namespace_test/namespace_a/namespace_b/struct_in_nested_ns_generated.rs index 75d1909ba..c3c627b0b 100644 --- a/tests/namespace_test/namespace_a/namespace_b/struct_in_nested_ns_generated.rs +++ b/tests/namespace_test/namespace_a/namespace_b/struct_in_nested_ns_generated.rs @@ -8,39 +8,39 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct StructInNestedNS(pub [u8; 8]); -impl Default for StructInNestedNS { - fn default() -> Self { - Self([0; 8]) - } +impl Default for StructInNestedNS { + fn default() -> Self { + Self([0; 8]) + } } impl ::core::fmt::Debug for StructInNestedNS { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("StructInNestedNS") - .field("a", &self.a()) - .field("b", &self.b()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("StructInNestedNS") + .field("a", &self.a()) + .field("b", &self.b()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for StructInNestedNS {} impl<'a> ::flatbuffers::Follow<'a> for StructInNestedNS { - type Inner = &'a StructInNestedNS; + type Inner = &'a StructInNestedNS; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a StructInNestedNS>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a StructInNestedNS>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a StructInNestedNS { - type Inner = &'a StructInNestedNS; + type Inner = &'a StructInNestedNS; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for StructInNestedNS { @@ -59,107 +59,107 @@ impl<'b> ::flatbuffers::Push for StructInNestedNS { } impl<'a> ::flatbuffers::Verifiable for StructInNestedNS { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> StructInNestedNS { - #[allow(clippy::too_many_arguments)] - pub fn new( - a: i32, - b: i32, - ) -> Self { - let mut s = Self([0; 8]); - s.set_a(a); - s.set_b(b); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "NamespaceA.NamespaceB.StructInNestedNS" - } - - pub fn a(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_a(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + a: i32, + b: i32, + ) -> Self { + let mut s = Self([0; 8]); + s.set_a(a); + s.set_b(b); + s } - } - pub fn b(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[4..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_b(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[4..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "NamespaceA.NamespaceB.StructInNestedNS" } - } - pub fn unpack(&self) -> StructInNestedNST { - StructInNestedNST { - a: self.a(), - b: self.b(), + pub fn a(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_a(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn b(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[4..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_b(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[4..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> StructInNestedNST { + StructInNestedNST { + a: self.a(), + b: self.b(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct StructInNestedNST { - pub a: i32, - pub b: i32, + pub a: i32, + pub b: i32, } impl StructInNestedNST { - pub fn pack(&self) -> StructInNestedNS { - StructInNestedNS::new( - self.a, - self.b, - ) - } + pub fn pack(&self) -> StructInNestedNS { + StructInNestedNS::new( + self.a, + self.b, + ) + } } diff --git a/tests/namespace_test/namespace_a/namespace_b/table_in_nested_ns_generated.rs b/tests/namespace_test/namespace_a/namespace_b/table_in_nested_ns_generated.rs index 856ae6e42..f85b0d231 100644 --- a/tests/namespace_test/namespace_a/namespace_b/table_in_nested_ns_generated.rs +++ b/tests/namespace_test/namespace_a/namespace_b/table_in_nested_ns_generated.rs @@ -7,66 +7,66 @@ pub enum TableInNestedNSOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableInNestedNS<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableInNestedNS<'a> { - type Inner = TableInNestedNS<'a>; + type Inner = TableInNestedNS<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableInNestedNS<'a> { - pub const VT_FOO: ::flatbuffers::VOffsetT = 4; + pub const VT_FOO: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "NamespaceA.NamespaceB.TableInNestedNS" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableInNestedNS { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableInNestedNSArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableInNestedNSBuilder::new(_fbb); - builder.add_foo(args.foo); - builder.finish() - } - - pub fn unpack(&self) -> TableInNestedNST { - let foo = self.foo(); - TableInNestedNST { - foo, + pub const fn get_fully_qualified_name() -> &'static str { + "NamespaceA.NamespaceB.TableInNestedNS" } - } - #[inline] - pub fn foo(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TableInNestedNS::VT_FOO, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableInNestedNS { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableInNestedNSArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableInNestedNSBuilder::new(_fbb); + builder.add_foo(args.foo); + builder.finish() + } + + pub fn unpack(&self) -> TableInNestedNST { + let foo = self.foo(); + TableInNestedNST { + foo, + } + } + + #[inline] + pub fn foo(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TableInNestedNS::VT_FOO, Some(0)).unwrap()} + } } impl ::flatbuffers::Verifiable for TableInNestedNS<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("foo", Self::VT_FOO, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("foo", Self::VT_FOO, false)? + .finish(); + Ok(()) + } } pub struct TableInNestedNSArgs { @@ -74,71 +74,71 @@ pub struct TableInNestedNSArgs { } impl<'a> Default for TableInNestedNSArgs { - #[inline] - fn default() -> Self { - TableInNestedNSArgs { - foo: 0, + #[inline] + fn default() -> Self { + TableInNestedNSArgs { + foo: 0, + } } - } } pub struct TableInNestedNSBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableInNestedNSBuilder<'a, 'b, A> { - #[inline] - pub fn add_foo(&mut self, foo: i32) { - self.fbb_.push_slot::(TableInNestedNS::VT_FOO, foo, 0); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableInNestedNSBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableInNestedNSBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_foo(&mut self, foo: i32) { + self.fbb_.push_slot::(TableInNestedNS::VT_FOO, foo, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableInNestedNSBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableInNestedNSBuilder { + 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 ::core::fmt::Debug for TableInNestedNS<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableInNestedNS"); - ds.field("foo", &self.foo()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableInNestedNS"); + ds.field("foo", &self.foo()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableInNestedNST { - pub foo: i32, + pub foo: i32, } impl Default for TableInNestedNST { - fn default() -> Self { - Self { - foo: 0, + fn default() -> Self { + Self { + foo: 0, + } } - } } impl TableInNestedNST { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let foo = self.foo; - TableInNestedNS::create(_fbb, &TableInNestedNSArgs{ - foo, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let foo = self.foo; + TableInNestedNS::create(_fbb, &TableInNestedNSArgs{ + foo, + }) + } } diff --git a/tests/namespace_test/namespace_a/namespace_b/union_in_nested_ns_generated.rs b/tests/namespace_test/namespace_a/namespace_b/union_in_nested_ns_generated.rs index 87ea03afc..0ac41c032 100644 --- a/tests/namespace_test/namespace_a/namespace_b/union_in_nested_ns_generated.rs +++ b/tests/namespace_test/namespace_a/namespace_b/union_in_nested_ns_generated.rs @@ -12,8 +12,8 @@ pub const ENUM_MAX_UNION_IN_NESTED_NS: u8 = 1; #[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_UNION_IN_NESTED_NS: [UnionInNestedNS; 2] = [ - UnionInNestedNS::NONE, - UnionInNestedNS::TableInNestedNS, + UnionInNestedNS::NONE, + UnionInNestedNS::TableInNestedNS, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -22,44 +22,44 @@ pub struct UnionInNestedNS(pub u8); #[allow(non_upper_case_globals)] impl UnionInNestedNS { - pub const NONE: Self = Self(0); - pub const TableInNestedNS: Self = Self(1); + pub const NONE: Self = Self(0); + pub const TableInNestedNS: Self = Self(1); - pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 1; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::TableInNestedNS, - ]; + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 1; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + Self::TableInNestedNS, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - Self::TableInNestedNS => Some("TableInNestedNS"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + Self::TableInNestedNS => Some("TableInNestedNS"), + _ => None, + } } - } } impl ::core::fmt::Debug for UnionInNestedNS { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 UnionInNestedNS { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for UnionInNestedNS { @@ -72,28 +72,28 @@ impl ::flatbuffers::Push for UnionInNestedNS { } impl ::flatbuffers::EndianScalar for UnionInNestedNS { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for UnionInNestedNS { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for UnionInNestedNS {} @@ -104,53 +104,53 @@ pub struct UnionInNestedNSUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum UnionInNestedNST { - NONE, - TableInNestedNS(alloc::boxed::Box), + NONE, + TableInNestedNS(alloc::boxed::Box), } impl Default for UnionInNestedNST { - fn default() -> Self { - Self::NONE - } + fn default() -> Self { + Self::NONE + } } impl UnionInNestedNST { - pub fn union_in_nested_ns_type(&self) -> UnionInNestedNS { - match self { - Self::NONE => UnionInNestedNS::NONE, - Self::TableInNestedNS(_) => UnionInNestedNS::TableInNestedNS, + pub fn union_in_nested_ns_type(&self) -> UnionInNestedNS { + match self { + Self::NONE => UnionInNestedNS::NONE, + Self::TableInNestedNS(_) => UnionInNestedNS::TableInNestedNS, + } } - } - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - match self { - Self::NONE => None, - Self::TableInNestedNS(v) => Some(v.pack(fbb).as_union_value()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + match self { + Self::NONE => None, + Self::TableInNestedNS(v) => Some(v.pack(fbb).as_union_value()), + } } - } - /// If the union variant matches, return the owned TableInNestedNST, setting the union to NONE. - pub fn take_table_in_nested_ns(&mut self) -> Option> { - if let Self::TableInNestedNS(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::TableInNestedNS(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return the owned TableInNestedNST, setting the union to NONE. + pub fn take_table_in_nested_ns(&mut self) -> Option> { + if let Self::TableInNestedNS(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::TableInNestedNS(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } } - } - /// If the union variant matches, return a reference to the TableInNestedNST. - pub fn as_table_in_nested_ns(&self) -> Option<&TableInNestedNST> { - if let Self::TableInNestedNS(v) = self { Some(v.as_ref()) } else { None } - } + /// If the union variant matches, return a reference to the TableInNestedNST. + pub fn as_table_in_nested_ns(&self) -> Option<&TableInNestedNST> { + if let Self::TableInNestedNS(v) = self { Some(v.as_ref()) } else { None } + } - /// If the union variant matches, return a mutable reference to the TableInNestedNST. - pub fn as_table_in_nested_ns_mut(&mut self) -> Option<&mut TableInNestedNST> { - if let Self::TableInNestedNS(v) = self { Some(v.as_mut()) } else { None } - } + /// If the union variant matches, return a mutable reference to the TableInNestedNST. + pub fn as_table_in_nested_ns_mut(&mut self) -> Option<&mut TableInNestedNST> { + if let Self::TableInNestedNS(v) = self { Some(v.as_mut()) } else { None } + } } diff --git a/tests/namespace_test/namespace_a/second_table_in_a_generated.rs b/tests/namespace_test/namespace_a/second_table_in_a_generated.rs index 2e3004523..0c0a754e1 100644 --- a/tests/namespace_test/namespace_a/second_table_in_a_generated.rs +++ b/tests/namespace_test/namespace_a/second_table_in_a_generated.rs @@ -7,68 +7,68 @@ pub enum SecondTableInAOffset {} #[derive(Copy, Clone, PartialEq)] pub struct SecondTableInA<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for SecondTableInA<'a> { - type Inner = SecondTableInA<'a>; + type Inner = SecondTableInA<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> SecondTableInA<'a> { - pub const VT_REFER_TO_C: ::flatbuffers::VOffsetT = 4; + pub const VT_REFER_TO_C: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "NamespaceA.SecondTableInA" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - SecondTableInA { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args SecondTableInAArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = SecondTableInABuilder::new(_fbb); - if let Some(x) = args.refer_to_c { builder.add_refer_to_c(x); } - builder.finish() - } - - pub fn unpack(&self) -> SecondTableInAT { - let refer_to_c = self.refer_to_c().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - SecondTableInAT { - refer_to_c, + pub const fn get_fully_qualified_name() -> &'static str { + "NamespaceA.SecondTableInA" } - } - #[inline] - pub fn refer_to_c(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(SecondTableInA::VT_REFER_TO_C, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + SecondTableInA { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args SecondTableInAArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = SecondTableInABuilder::new(_fbb); + if let Some(x) = args.refer_to_c { builder.add_refer_to_c(x); } + builder.finish() + } + + pub fn unpack(&self) -> SecondTableInAT { + let refer_to_c = self.refer_to_c().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + SecondTableInAT { + refer_to_c, + } + } + + #[inline] + pub fn refer_to_c(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(SecondTableInA::VT_REFER_TO_C, None)} + } } impl ::flatbuffers::Verifiable for SecondTableInA<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("refer_to_c", Self::VT_REFER_TO_C, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("refer_to_c", Self::VT_REFER_TO_C, false)? + .finish(); + Ok(()) + } } pub struct SecondTableInAArgs<'a> { @@ -76,73 +76,73 @@ pub struct SecondTableInAArgs<'a> { } impl<'a> Default for SecondTableInAArgs<'a> { - #[inline] - fn default() -> Self { - SecondTableInAArgs { - refer_to_c: None, + #[inline] + fn default() -> Self { + SecondTableInAArgs { + refer_to_c: None, + } } - } } pub struct SecondTableInABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SecondTableInABuilder<'a, 'b, A> { - #[inline] - pub fn add_refer_to_c(&mut self, refer_to_c: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(SecondTableInA::VT_REFER_TO_C, refer_to_c); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SecondTableInABuilder<'a, 'b, A> { - let start = _fbb.start_table(); - SecondTableInABuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_refer_to_c(&mut self, refer_to_c: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(SecondTableInA::VT_REFER_TO_C, refer_to_c); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SecondTableInABuilder<'a, 'b, A> { + let start = _fbb.start_table(); + SecondTableInABuilder { + 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 ::core::fmt::Debug for SecondTableInA<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("SecondTableInA"); - ds.field("refer_to_c", &self.refer_to_c()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("SecondTableInA"); + ds.field("refer_to_c", &self.refer_to_c()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct SecondTableInAT { - pub refer_to_c: Option>, + pub refer_to_c: Option>, } impl Default for SecondTableInAT { - fn default() -> Self { - Self { - refer_to_c: None, + fn default() -> Self { + Self { + refer_to_c: None, + } } - } } impl SecondTableInAT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let refer_to_c = self.refer_to_c.as_ref().map(|x|{ - x.pack(_fbb) - }); - SecondTableInA::create(_fbb, &SecondTableInAArgs{ - refer_to_c, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let refer_to_c = self.refer_to_c.as_ref().map(|x|{ + x.pack(_fbb) + }); + SecondTableInA::create(_fbb, &SecondTableInAArgs{ + refer_to_c, + }) + } } diff --git a/tests/namespace_test/namespace_a/table_in_first_ns_generated.rs b/tests/namespace_test/namespace_a/table_in_first_ns_generated.rs index 3ff5ee2ac..10b14c4af 100644 --- a/tests/namespace_test/namespace_a/table_in_first_ns_generated.rs +++ b/tests/namespace_test/namespace_a/table_in_first_ns_generated.rs @@ -7,147 +7,147 @@ pub enum TableInFirstNSOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableInFirstNS<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableInFirstNS<'a> { - type Inner = TableInFirstNS<'a>; + type Inner = TableInFirstNS<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableInFirstNS<'a> { - pub const VT_FOO_TABLE: ::flatbuffers::VOffsetT = 4; - pub const VT_FOO_ENUM: ::flatbuffers::VOffsetT = 6; - pub const VT_FOO_UNION_TYPE: ::flatbuffers::VOffsetT = 8; - pub const VT_FOO_UNION: ::flatbuffers::VOffsetT = 10; - pub const VT_FOO_STRUCT: ::flatbuffers::VOffsetT = 12; + pub const VT_FOO_TABLE: ::flatbuffers::VOffsetT = 4; + pub const VT_FOO_ENUM: ::flatbuffers::VOffsetT = 6; + pub const VT_FOO_UNION_TYPE: ::flatbuffers::VOffsetT = 8; + pub const VT_FOO_UNION: ::flatbuffers::VOffsetT = 10; + pub const VT_FOO_STRUCT: ::flatbuffers::VOffsetT = 12; - pub const fn get_fully_qualified_name() -> &'static str { - "NamespaceA.TableInFirstNS" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableInFirstNS { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableInFirstNSArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableInFirstNSBuilder::new(_fbb); - if let Some(x) = args.foo_struct { builder.add_foo_struct(x); } - if let Some(x) = args.foo_union { builder.add_foo_union(x); } - if let Some(x) = args.foo_table { builder.add_foo_table(x); } - builder.add_foo_union_type(args.foo_union_type); - builder.add_foo_enum(args.foo_enum); - builder.finish() - } - - pub fn unpack(&self) -> TableInFirstNST { - let foo_table = self.foo_table().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - let foo_enum = self.foo_enum(); - let foo_union = match self.foo_union_type() { - namespace_b::UnionInNestedNS::NONE => namespace_b::UnionInNestedNST::NONE, - namespace_b::UnionInNestedNS::TableInNestedNS => namespace_b::UnionInNestedNST::TableInNestedNS(alloc::boxed::Box::new( - self.foo_union_as_table_in_nested_ns() - .expect("Invalid union table, expected `namespace_b::UnionInNestedNS::TableInNestedNS`.") - .unpack() - )), - _ => namespace_b::UnionInNestedNST::NONE, - }; - let foo_struct = self.foo_struct().map(|x| { - x.unpack() - }); - TableInFirstNST { - foo_table, - foo_enum, - foo_union, - foo_struct, + pub const fn get_fully_qualified_name() -> &'static str { + "NamespaceA.TableInFirstNS" } - } - #[inline] - pub fn foo_table(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableInFirstNS::VT_FOO_TABLE, None)} - } - - #[inline] - pub fn foo_enum(&self) -> namespace_b::EnumInNestedNS { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TableInFirstNS::VT_FOO_ENUM, Some(namespace_b::EnumInNestedNS::A)).unwrap()} - } - - #[inline] - pub fn foo_union_type(&self) -> namespace_b::UnionInNestedNS { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TableInFirstNS::VT_FOO_UNION_TYPE, Some(namespace_b::UnionInNestedNS::NONE)).unwrap()} - } - - #[inline] - pub fn foo_union(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(TableInFirstNS::VT_FOO_UNION, None)} - } - - #[inline] - pub fn foo_struct(&self) -> Option<&'a namespace_b::StructInNestedNS> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TableInFirstNS::VT_FOO_STRUCT, None)} - } - - #[inline] - #[allow(non_snake_case)] - pub fn foo_union_as_table_in_nested_ns(&self) -> Option> { - if self.foo_union_type() == namespace_b::UnionInNestedNS::TableInNestedNS { - self.foo_union().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { namespace_b::TableInNestedNS::init_from_table(t) } - }) - } else { - None + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableInFirstNS { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableInFirstNSArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableInFirstNSBuilder::new(_fbb); + if let Some(x) = args.foo_struct { builder.add_foo_struct(x); } + if let Some(x) = args.foo_union { builder.add_foo_union(x); } + if let Some(x) = args.foo_table { builder.add_foo_table(x); } + builder.add_foo_union_type(args.foo_union_type); + builder.add_foo_enum(args.foo_enum); + builder.finish() + } + + pub fn unpack(&self) -> TableInFirstNST { + let foo_table = self.foo_table().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + let foo_enum = self.foo_enum(); + let foo_union = match self.foo_union_type() { + namespace_b::UnionInNestedNS::NONE => namespace_b::UnionInNestedNST::NONE, + namespace_b::UnionInNestedNS::TableInNestedNS => namespace_b::UnionInNestedNST::TableInNestedNS(alloc::boxed::Box::new( + self.foo_union_as_table_in_nested_ns() + .expect("Invalid union table, expected `namespace_b::UnionInNestedNS::TableInNestedNS`.") + .unpack() + )), + _ => namespace_b::UnionInNestedNST::NONE, + }; + let foo_struct = self.foo_struct().map(|x| { + x.unpack() + }); + TableInFirstNST { + foo_table, + foo_enum, + foo_union, + foo_struct, + } + } + + #[inline] + pub fn foo_table(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableInFirstNS::VT_FOO_TABLE, None)} + } + + #[inline] + pub fn foo_enum(&self) -> namespace_b::EnumInNestedNS { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TableInFirstNS::VT_FOO_ENUM, Some(namespace_b::EnumInNestedNS::A)).unwrap()} + } + + #[inline] + pub fn foo_union_type(&self) -> namespace_b::UnionInNestedNS { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TableInFirstNS::VT_FOO_UNION_TYPE, Some(namespace_b::UnionInNestedNS::NONE)).unwrap()} + } + + #[inline] + pub fn foo_union(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(TableInFirstNS::VT_FOO_UNION, None)} + } + + #[inline] + pub fn foo_struct(&self) -> Option<&'a namespace_b::StructInNestedNS> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TableInFirstNS::VT_FOO_STRUCT, None)} + } + + #[inline] + #[allow(non_snake_case)] + pub fn foo_union_as_table_in_nested_ns(&self) -> Option> { + if self.foo_union_type() == namespace_b::UnionInNestedNS::TableInNestedNS { + self.foo_union().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { namespace_b::TableInNestedNS::init_from_table(t) } + }) + } else { + None + } } - } } impl ::flatbuffers::Verifiable for TableInFirstNS<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("foo_table", Self::VT_FOO_TABLE, false)? - .visit_field::("foo_enum", Self::VT_FOO_ENUM, false)? - .visit_union::("foo_union_type", Self::VT_FOO_UNION_TYPE, "foo_union", Self::VT_FOO_UNION, false, |key, v, pos| { - match key { - namespace_b::UnionInNestedNS::TableInNestedNS => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("namespace_b::UnionInNestedNS::TableInNestedNS", pos), - _ => Ok(()), - } - })? - .visit_field::("foo_struct", Self::VT_FOO_STRUCT, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("foo_table", Self::VT_FOO_TABLE, false)? + .visit_field::("foo_enum", Self::VT_FOO_ENUM, false)? + .visit_union::("foo_union_type", Self::VT_FOO_UNION_TYPE, "foo_union", Self::VT_FOO_UNION, false, |key, v, pos| { + match key { + namespace_b::UnionInNestedNS::TableInNestedNS => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("namespace_b::UnionInNestedNS::TableInNestedNS", pos), + _ => Ok(()), + } + })? + .visit_field::("foo_struct", Self::VT_FOO_STRUCT, false)? + .finish(); + Ok(()) + } } pub struct TableInFirstNSArgs<'a> { @@ -159,128 +159,128 @@ pub struct TableInFirstNSArgs<'a> { } impl<'a> Default for TableInFirstNSArgs<'a> { - #[inline] - fn default() -> Self { - TableInFirstNSArgs { - foo_table: None, - foo_enum: namespace_b::EnumInNestedNS::A, - foo_union_type: namespace_b::UnionInNestedNS::NONE, - foo_union: None, - foo_struct: None, + #[inline] + fn default() -> Self { + TableInFirstNSArgs { + foo_table: None, + foo_enum: namespace_b::EnumInNestedNS::A, + foo_union_type: namespace_b::UnionInNestedNS::NONE, + foo_union: None, + foo_struct: None, + } } - } } pub struct TableInFirstNSBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableInFirstNSBuilder<'a, 'b, A> { - #[inline] - pub fn add_foo_table(&mut self, foo_table: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableInFirstNS::VT_FOO_TABLE, foo_table); - } - - #[inline] - pub fn add_foo_enum(&mut self, foo_enum: namespace_b::EnumInNestedNS) { - self.fbb_.push_slot::(TableInFirstNS::VT_FOO_ENUM, foo_enum, namespace_b::EnumInNestedNS::A); - } - - #[inline] - pub fn add_foo_union_type(&mut self, foo_union_type: namespace_b::UnionInNestedNS) { - self.fbb_.push_slot::(TableInFirstNS::VT_FOO_UNION_TYPE, foo_union_type, namespace_b::UnionInNestedNS::NONE); - } - - #[inline] - pub fn add_foo_union(&mut self, foo_union: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TableInFirstNS::VT_FOO_UNION, foo_union); - } - - #[inline] - pub fn add_foo_struct(&mut self, foo_struct: &namespace_b::StructInNestedNS) { - self.fbb_.push_slot_always::<&namespace_b::StructInNestedNS>(TableInFirstNS::VT_FOO_STRUCT, foo_struct); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableInFirstNSBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableInFirstNSBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_foo_table(&mut self, foo_table: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableInFirstNS::VT_FOO_TABLE, foo_table); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_foo_enum(&mut self, foo_enum: namespace_b::EnumInNestedNS) { + self.fbb_.push_slot::(TableInFirstNS::VT_FOO_ENUM, foo_enum, namespace_b::EnumInNestedNS::A); + } + + #[inline] + pub fn add_foo_union_type(&mut self, foo_union_type: namespace_b::UnionInNestedNS) { + self.fbb_.push_slot::(TableInFirstNS::VT_FOO_UNION_TYPE, foo_union_type, namespace_b::UnionInNestedNS::NONE); + } + + #[inline] + pub fn add_foo_union(&mut self, foo_union: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TableInFirstNS::VT_FOO_UNION, foo_union); + } + + #[inline] + pub fn add_foo_struct(&mut self, foo_struct: &namespace_b::StructInNestedNS) { + self.fbb_.push_slot_always::<&namespace_b::StructInNestedNS>(TableInFirstNS::VT_FOO_STRUCT, foo_struct); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableInFirstNSBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableInFirstNSBuilder { + 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 ::core::fmt::Debug for TableInFirstNS<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableInFirstNS"); - ds.field("foo_table", &self.foo_table()); - ds.field("foo_enum", &self.foo_enum()); - ds.field("foo_union_type", &self.foo_union_type()); - match self.foo_union_type() { - namespace_b::UnionInNestedNS::TableInNestedNS => { - if let Some(x) = self.foo_union_as_table_in_nested_ns() { - ds.field("foo_union", &x) - } else { - ds.field("foo_union", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("foo_union", &x) - }, - }; - ds.field("foo_struct", &self.foo_struct()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableInFirstNS"); + ds.field("foo_table", &self.foo_table()); + ds.field("foo_enum", &self.foo_enum()); + ds.field("foo_union_type", &self.foo_union_type()); + match self.foo_union_type() { + namespace_b::UnionInNestedNS::TableInNestedNS => { + if let Some(x) = self.foo_union_as_table_in_nested_ns() { + ds.field("foo_union", &x) + } else { + ds.field("foo_union", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + _ => { + let x: Option<()> = None; + ds.field("foo_union", &x) + }, + }; + ds.field("foo_struct", &self.foo_struct()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableInFirstNST { - pub foo_table: Option>, - pub foo_enum: namespace_b::EnumInNestedNS, - pub foo_union: namespace_b::UnionInNestedNST, - pub foo_struct: Option, + pub foo_table: Option>, + pub foo_enum: namespace_b::EnumInNestedNS, + pub foo_union: namespace_b::UnionInNestedNST, + pub foo_struct: Option, } impl Default for TableInFirstNST { - fn default() -> Self { - Self { - foo_table: None, - foo_enum: namespace_b::EnumInNestedNS::A, - foo_union: namespace_b::UnionInNestedNST::NONE, - foo_struct: None, + fn default() -> Self { + Self { + foo_table: None, + foo_enum: namespace_b::EnumInNestedNS::A, + foo_union: namespace_b::UnionInNestedNST::NONE, + foo_struct: None, + } } - } } impl TableInFirstNST { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let foo_table = self.foo_table.as_ref().map(|x|{ - x.pack(_fbb) - }); - let foo_enum = self.foo_enum; - let foo_union_type = self.foo_union.union_in_nested_ns_type(); - let foo_union = self.foo_union.pack(_fbb); - let foo_struct_tmp = self.foo_struct.as_ref().map(|x| x.pack()); - let foo_struct = foo_struct_tmp.as_ref(); - TableInFirstNS::create(_fbb, &TableInFirstNSArgs{ - foo_table, - foo_enum, - foo_union_type, - foo_union, - foo_struct, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let foo_table = self.foo_table.as_ref().map(|x|{ + x.pack(_fbb) + }); + let foo_enum = self.foo_enum; + let foo_union_type = self.foo_union.union_in_nested_ns_type(); + let foo_union = self.foo_union.pack(_fbb); + let foo_struct_tmp = self.foo_struct.as_ref().map(|x| x.pack()); + let foo_struct = foo_struct_tmp.as_ref(); + TableInFirstNS::create(_fbb, &TableInFirstNSArgs{ + foo_table, + foo_enum, + foo_union_type, + foo_union, + foo_struct, + }) + } } diff --git a/tests/namespace_test/namespace_c/table_in_c_generated.rs b/tests/namespace_test/namespace_c/table_in_c_generated.rs index df3c80e95..99886869c 100644 --- a/tests/namespace_test/namespace_c/table_in_c_generated.rs +++ b/tests/namespace_test/namespace_c/table_in_c_generated.rs @@ -7,83 +7,83 @@ pub enum TableInCOffset {} #[derive(Copy, Clone, PartialEq)] pub struct TableInC<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for TableInC<'a> { - type Inner = TableInC<'a>; + type Inner = TableInC<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> TableInC<'a> { - pub const VT_REFER_TO_A1: ::flatbuffers::VOffsetT = 4; - pub const VT_REFER_TO_A2: ::flatbuffers::VOffsetT = 6; + pub const VT_REFER_TO_A1: ::flatbuffers::VOffsetT = 4; + pub const VT_REFER_TO_A2: ::flatbuffers::VOffsetT = 6; - pub const fn get_fully_qualified_name() -> &'static str { - "NamespaceC.TableInC" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - TableInC { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args TableInCArgs<'args> - ) -> ::flatbuffers::WIPOffset> { - let mut builder = TableInCBuilder::new(_fbb); - if let Some(x) = args.refer_to_a2 { builder.add_refer_to_a2(x); } - if let Some(x) = args.refer_to_a1 { builder.add_refer_to_a1(x); } - builder.finish() - } - - pub fn unpack(&self) -> TableInCT { - let refer_to_a1 = self.refer_to_a1().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - let refer_to_a2 = self.refer_to_a2().map(|x| { - alloc::boxed::Box::new(x.unpack()) - }); - TableInCT { - refer_to_a1, - refer_to_a2, + pub const fn get_fully_qualified_name() -> &'static str { + "NamespaceC.TableInC" } - } - #[inline] - pub fn refer_to_a1(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableInC::VT_REFER_TO_A1, None)} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + TableInC { _tab: table } + } - #[inline] - pub fn refer_to_a2(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableInC::VT_REFER_TO_A2, None)} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args TableInCArgs<'args> + ) -> ::flatbuffers::WIPOffset> { + let mut builder = TableInCBuilder::new(_fbb); + if let Some(x) = args.refer_to_a2 { builder.add_refer_to_a2(x); } + if let Some(x) = args.refer_to_a1 { builder.add_refer_to_a1(x); } + builder.finish() + } + + pub fn unpack(&self) -> TableInCT { + let refer_to_a1 = self.refer_to_a1().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + let refer_to_a2 = self.refer_to_a2().map(|x| { + alloc::boxed::Box::new(x.unpack()) + }); + TableInCT { + refer_to_a1, + refer_to_a2, + } + } + + #[inline] + pub fn refer_to_a1(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableInC::VT_REFER_TO_A1, None)} + } + + #[inline] + pub fn refer_to_a2(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset>(TableInC::VT_REFER_TO_A2, None)} + } } impl ::flatbuffers::Verifiable for TableInC<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>("refer_to_a1", Self::VT_REFER_TO_A1, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>("refer_to_a2", Self::VT_REFER_TO_A2, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::<::flatbuffers::ForwardsUOffset>("refer_to_a1", Self::VT_REFER_TO_A1, false)? + .visit_field::<::flatbuffers::ForwardsUOffset>("refer_to_a2", Self::VT_REFER_TO_A2, false)? + .finish(); + Ok(()) + } } pub struct TableInCArgs<'a> { @@ -92,86 +92,86 @@ pub struct TableInCArgs<'a> { } impl<'a> Default for TableInCArgs<'a> { - #[inline] - fn default() -> Self { - TableInCArgs { - refer_to_a1: None, - refer_to_a2: None, + #[inline] + fn default() -> Self { + TableInCArgs { + refer_to_a1: None, + refer_to_a2: None, + } } - } } pub struct TableInCBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableInCBuilder<'a, 'b, A> { - #[inline] - pub fn add_refer_to_a1(&mut self, refer_to_a1: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableInC::VT_REFER_TO_A1, refer_to_a1); - } - - #[inline] - pub fn add_refer_to_a2(&mut self, refer_to_a2: ::flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableInC::VT_REFER_TO_A2, refer_to_a2); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableInCBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - TableInCBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_refer_to_a1(&mut self, refer_to_a1: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableInC::VT_REFER_TO_A1, refer_to_a1); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_refer_to_a2(&mut self, refer_to_a2: ::flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset>(TableInC::VT_REFER_TO_A2, refer_to_a2); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableInCBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + TableInCBuilder { + 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 ::core::fmt::Debug for TableInC<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("TableInC"); - ds.field("refer_to_a1", &self.refer_to_a1()); - ds.field("refer_to_a2", &self.refer_to_a2()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("TableInC"); + ds.field("refer_to_a1", &self.refer_to_a1()); + ds.field("refer_to_a2", &self.refer_to_a2()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct TableInCT { - pub refer_to_a1: Option>, - pub refer_to_a2: Option>, + pub refer_to_a1: Option>, + pub refer_to_a2: Option>, } impl Default for TableInCT { - fn default() -> Self { - Self { - refer_to_a1: None, - refer_to_a2: None, + fn default() -> Self { + Self { + refer_to_a1: None, + refer_to_a2: None, + } } - } } impl TableInCT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let refer_to_a1 = self.refer_to_a1.as_ref().map(|x|{ - x.pack(_fbb) - }); - let refer_to_a2 = self.refer_to_a2.as_ref().map(|x|{ - x.pack(_fbb) - }); - TableInC::create(_fbb, &TableInCArgs{ - refer_to_a1, - refer_to_a2, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let refer_to_a1 = self.refer_to_a1.as_ref().map(|x|{ + x.pack(_fbb) + }); + let refer_to_a2 = self.refer_to_a2.as_ref().map(|x|{ + x.pack(_fbb) + }); + TableInC::create(_fbb, &TableInCArgs{ + refer_to_a1, + refer_to_a2, + }) + } } diff --git a/tests/optional_scalars/mod.rs b/tests/optional_scalars/mod.rs index 84291e3ef..cbd72e360 100644 --- a/tests/optional_scalars/mod.rs +++ b/tests/optional_scalars/mod.rs @@ -1,9 +1,9 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod optional_scalars { - use super::*; - mod optional_byte_generated; - pub use self::optional_byte_generated::*; - mod scalar_stuff_generated; - pub use self::scalar_stuff_generated::*; + use super::*; + mod optional_byte_generated; + pub use self::optional_byte_generated::*; + mod scalar_stuff_generated; + pub use self::scalar_stuff_generated::*; } // optional_scalars diff --git a/tests/optional_scalars/optional_scalars/optional_byte_generated.rs b/tests/optional_scalars/optional_scalars/optional_byte_generated.rs index 72026c407..4da704ef7 100644 --- a/tests/optional_scalars/optional_scalars/optional_byte_generated.rs +++ b/tests/optional_scalars/optional_scalars/optional_byte_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_OPTIONAL_BYTE: 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_OPTIONAL_BYTE: [OptionalByte; 3] = [ - OptionalByte::None, - OptionalByte::One, - OptionalByte::Two, + OptionalByte::None, + OptionalByte::One, + OptionalByte::Two, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub struct OptionalByte(pub i8); #[allow(non_upper_case_globals)] impl OptionalByte { - pub const None: Self = Self(0); - pub const One: Self = Self(1); - pub const Two: Self = Self(2); + pub const None: Self = Self(0); + pub const One: Self = Self(1); + pub const Two: Self = Self(2); - pub const ENUM_MIN: i8 = 0; - pub const ENUM_MAX: i8 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::None, - Self::One, - Self::Two, - ]; + pub const ENUM_MIN: i8 = 0; + pub const ENUM_MAX: i8 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::None, + Self::One, + Self::Two, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::None => Some("None"), - Self::One => Some("One"), - Self::Two => Some("Two"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::None => Some("None"), + Self::One => Some("One"), + Self::Two => Some("Two"), + _ => None, + } } - } } impl ::core::fmt::Debug for OptionalByte { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 OptionalByte { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for OptionalByte { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for OptionalByte { } impl ::flatbuffers::EndianScalar for OptionalByte { - type Scalar = i8; + type Scalar = i8; - #[inline] - fn to_little_endian(self) -> i8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i8) -> Self { - let b = i8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i8) -> Self { + let b = i8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for OptionalByte { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for OptionalByte {} diff --git a/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs b/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs index fe3d8fe69..4524bec28 100644 --- a/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs +++ b/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs @@ -7,521 +7,521 @@ pub enum ScalarStuffOffset {} #[derive(Copy, Clone, PartialEq)] pub struct ScalarStuff<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for ScalarStuff<'a> { - type Inner = ScalarStuff<'a>; + type Inner = ScalarStuff<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> ScalarStuff<'a> { - pub const VT_JUST_I8: ::flatbuffers::VOffsetT = 4; - pub const VT_MAYBE_I8: ::flatbuffers::VOffsetT = 6; - pub const VT_DEFAULT_I8: ::flatbuffers::VOffsetT = 8; - pub const VT_JUST_U8: ::flatbuffers::VOffsetT = 10; - pub const VT_MAYBE_U8: ::flatbuffers::VOffsetT = 12; - pub const VT_DEFAULT_U8: ::flatbuffers::VOffsetT = 14; - pub const VT_JUST_I16: ::flatbuffers::VOffsetT = 16; - pub const VT_MAYBE_I16: ::flatbuffers::VOffsetT = 18; - pub const VT_DEFAULT_I16: ::flatbuffers::VOffsetT = 20; - pub const VT_JUST_U16: ::flatbuffers::VOffsetT = 22; - pub const VT_MAYBE_U16: ::flatbuffers::VOffsetT = 24; - pub const VT_DEFAULT_U16: ::flatbuffers::VOffsetT = 26; - pub const VT_JUST_I32: ::flatbuffers::VOffsetT = 28; - pub const VT_MAYBE_I32: ::flatbuffers::VOffsetT = 30; - pub const VT_DEFAULT_I32: ::flatbuffers::VOffsetT = 32; - pub const VT_JUST_U32: ::flatbuffers::VOffsetT = 34; - pub const VT_MAYBE_U32: ::flatbuffers::VOffsetT = 36; - pub const VT_DEFAULT_U32: ::flatbuffers::VOffsetT = 38; - pub const VT_JUST_I64: ::flatbuffers::VOffsetT = 40; - pub const VT_MAYBE_I64: ::flatbuffers::VOffsetT = 42; - pub const VT_DEFAULT_I64: ::flatbuffers::VOffsetT = 44; - pub const VT_JUST_U64: ::flatbuffers::VOffsetT = 46; - pub const VT_MAYBE_U64: ::flatbuffers::VOffsetT = 48; - pub const VT_DEFAULT_U64: ::flatbuffers::VOffsetT = 50; - pub const VT_JUST_F32: ::flatbuffers::VOffsetT = 52; - pub const VT_MAYBE_F32: ::flatbuffers::VOffsetT = 54; - pub const VT_DEFAULT_F32: ::flatbuffers::VOffsetT = 56; - pub const VT_JUST_F64: ::flatbuffers::VOffsetT = 58; - pub const VT_MAYBE_F64: ::flatbuffers::VOffsetT = 60; - pub const VT_DEFAULT_F64: ::flatbuffers::VOffsetT = 62; - pub const VT_JUST_BOOL: ::flatbuffers::VOffsetT = 64; - pub const VT_MAYBE_BOOL: ::flatbuffers::VOffsetT = 66; - pub const VT_DEFAULT_BOOL: ::flatbuffers::VOffsetT = 68; - pub const VT_JUST_ENUM: ::flatbuffers::VOffsetT = 70; - pub const VT_MAYBE_ENUM: ::flatbuffers::VOffsetT = 72; - pub const VT_DEFAULT_ENUM: ::flatbuffers::VOffsetT = 74; + pub const VT_JUST_I8: ::flatbuffers::VOffsetT = 4; + pub const VT_MAYBE_I8: ::flatbuffers::VOffsetT = 6; + pub const VT_DEFAULT_I8: ::flatbuffers::VOffsetT = 8; + pub const VT_JUST_U8: ::flatbuffers::VOffsetT = 10; + pub const VT_MAYBE_U8: ::flatbuffers::VOffsetT = 12; + pub const VT_DEFAULT_U8: ::flatbuffers::VOffsetT = 14; + pub const VT_JUST_I16: ::flatbuffers::VOffsetT = 16; + pub const VT_MAYBE_I16: ::flatbuffers::VOffsetT = 18; + pub const VT_DEFAULT_I16: ::flatbuffers::VOffsetT = 20; + pub const VT_JUST_U16: ::flatbuffers::VOffsetT = 22; + pub const VT_MAYBE_U16: ::flatbuffers::VOffsetT = 24; + pub const VT_DEFAULT_U16: ::flatbuffers::VOffsetT = 26; + pub const VT_JUST_I32: ::flatbuffers::VOffsetT = 28; + pub const VT_MAYBE_I32: ::flatbuffers::VOffsetT = 30; + pub const VT_DEFAULT_I32: ::flatbuffers::VOffsetT = 32; + pub const VT_JUST_U32: ::flatbuffers::VOffsetT = 34; + pub const VT_MAYBE_U32: ::flatbuffers::VOffsetT = 36; + pub const VT_DEFAULT_U32: ::flatbuffers::VOffsetT = 38; + pub const VT_JUST_I64: ::flatbuffers::VOffsetT = 40; + pub const VT_MAYBE_I64: ::flatbuffers::VOffsetT = 42; + pub const VT_DEFAULT_I64: ::flatbuffers::VOffsetT = 44; + pub const VT_JUST_U64: ::flatbuffers::VOffsetT = 46; + pub const VT_MAYBE_U64: ::flatbuffers::VOffsetT = 48; + pub const VT_DEFAULT_U64: ::flatbuffers::VOffsetT = 50; + pub const VT_JUST_F32: ::flatbuffers::VOffsetT = 52; + pub const VT_MAYBE_F32: ::flatbuffers::VOffsetT = 54; + pub const VT_DEFAULT_F32: ::flatbuffers::VOffsetT = 56; + pub const VT_JUST_F64: ::flatbuffers::VOffsetT = 58; + pub const VT_MAYBE_F64: ::flatbuffers::VOffsetT = 60; + pub const VT_DEFAULT_F64: ::flatbuffers::VOffsetT = 62; + pub const VT_JUST_BOOL: ::flatbuffers::VOffsetT = 64; + pub const VT_MAYBE_BOOL: ::flatbuffers::VOffsetT = 66; + pub const VT_DEFAULT_BOOL: ::flatbuffers::VOffsetT = 68; + pub const VT_JUST_ENUM: ::flatbuffers::VOffsetT = 70; + pub const VT_MAYBE_ENUM: ::flatbuffers::VOffsetT = 72; + pub const VT_DEFAULT_ENUM: ::flatbuffers::VOffsetT = 74; - pub const fn get_fully_qualified_name() -> &'static str { - "optional_scalars.ScalarStuff" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - ScalarStuff { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args ScalarStuffArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = ScalarStuffBuilder::new(_fbb); - builder.add_default_f64(args.default_f64); - if let Some(x) = args.maybe_f64 { builder.add_maybe_f64(x); } - builder.add_just_f64(args.just_f64); - builder.add_default_u64(args.default_u64); - if let Some(x) = args.maybe_u64 { builder.add_maybe_u64(x); } - builder.add_just_u64(args.just_u64); - builder.add_default_i64(args.default_i64); - if let Some(x) = args.maybe_i64 { builder.add_maybe_i64(x); } - builder.add_just_i64(args.just_i64); - builder.add_default_f32(args.default_f32); - if let Some(x) = args.maybe_f32 { builder.add_maybe_f32(x); } - builder.add_just_f32(args.just_f32); - builder.add_default_u32(args.default_u32); - if let Some(x) = args.maybe_u32 { builder.add_maybe_u32(x); } - builder.add_just_u32(args.just_u32); - builder.add_default_i32(args.default_i32); - if let Some(x) = args.maybe_i32 { builder.add_maybe_i32(x); } - builder.add_just_i32(args.just_i32); - builder.add_default_u16(args.default_u16); - if let Some(x) = args.maybe_u16 { builder.add_maybe_u16(x); } - builder.add_just_u16(args.just_u16); - builder.add_default_i16(args.default_i16); - if let Some(x) = args.maybe_i16 { builder.add_maybe_i16(x); } - builder.add_just_i16(args.just_i16); - builder.add_default_enum(args.default_enum); - if let Some(x) = args.maybe_enum { builder.add_maybe_enum(x); } - builder.add_just_enum(args.just_enum); - builder.add_default_bool(args.default_bool); - if let Some(x) = args.maybe_bool { builder.add_maybe_bool(x); } - builder.add_just_bool(args.just_bool); - builder.add_default_u8(args.default_u8); - if let Some(x) = args.maybe_u8 { builder.add_maybe_u8(x); } - builder.add_just_u8(args.just_u8); - builder.add_default_i8(args.default_i8); - if let Some(x) = args.maybe_i8 { builder.add_maybe_i8(x); } - builder.add_just_i8(args.just_i8); - builder.finish() - } - - pub fn unpack(&self) -> ScalarStuffT { - let just_i8 = self.just_i8(); - let maybe_i8 = self.maybe_i8(); - let default_i8 = self.default_i8(); - let just_u8 = self.just_u8(); - let maybe_u8 = self.maybe_u8(); - let default_u8 = self.default_u8(); - let just_i16 = self.just_i16(); - let maybe_i16 = self.maybe_i16(); - let default_i16 = self.default_i16(); - let just_u16 = self.just_u16(); - let maybe_u16 = self.maybe_u16(); - let default_u16 = self.default_u16(); - let just_i32 = self.just_i32(); - let maybe_i32 = self.maybe_i32(); - let default_i32 = self.default_i32(); - let just_u32 = self.just_u32(); - let maybe_u32 = self.maybe_u32(); - let default_u32 = self.default_u32(); - let just_i64 = self.just_i64(); - let maybe_i64 = self.maybe_i64(); - let default_i64 = self.default_i64(); - let just_u64 = self.just_u64(); - let maybe_u64 = self.maybe_u64(); - let default_u64 = self.default_u64(); - let just_f32 = self.just_f32(); - let maybe_f32 = self.maybe_f32(); - let default_f32 = self.default_f32(); - let just_f64 = self.just_f64(); - let maybe_f64 = self.maybe_f64(); - let default_f64 = self.default_f64(); - let just_bool = self.just_bool(); - let maybe_bool = self.maybe_bool(); - let default_bool = self.default_bool(); - let just_enum = self.just_enum(); - let maybe_enum = self.maybe_enum(); - let default_enum = self.default_enum(); - ScalarStuffT { - just_i8, - maybe_i8, - default_i8, - just_u8, - maybe_u8, - default_u8, - just_i16, - maybe_i16, - default_i16, - just_u16, - maybe_u16, - default_u16, - just_i32, - maybe_i32, - default_i32, - just_u32, - maybe_u32, - default_u32, - just_i64, - maybe_i64, - default_i64, - just_u64, - maybe_u64, - default_u64, - just_f32, - maybe_f32, - default_f32, - just_f64, - maybe_f64, - default_f64, - just_bool, - maybe_bool, - default_bool, - just_enum, - maybe_enum, - default_enum, + pub const fn get_fully_qualified_name() -> &'static str { + "optional_scalars.ScalarStuff" } - } - #[inline] - pub fn just_i8(&self) -> i8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_I8, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + ScalarStuff { _tab: table } + } - #[inline] - pub fn maybe_i8(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I8, None)} - } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args ScalarStuffArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = ScalarStuffBuilder::new(_fbb); + builder.add_default_f64(args.default_f64); + if let Some(x) = args.maybe_f64 { builder.add_maybe_f64(x); } + builder.add_just_f64(args.just_f64); + builder.add_default_u64(args.default_u64); + if let Some(x) = args.maybe_u64 { builder.add_maybe_u64(x); } + builder.add_just_u64(args.just_u64); + builder.add_default_i64(args.default_i64); + if let Some(x) = args.maybe_i64 { builder.add_maybe_i64(x); } + builder.add_just_i64(args.just_i64); + builder.add_default_f32(args.default_f32); + if let Some(x) = args.maybe_f32 { builder.add_maybe_f32(x); } + builder.add_just_f32(args.just_f32); + builder.add_default_u32(args.default_u32); + if let Some(x) = args.maybe_u32 { builder.add_maybe_u32(x); } + builder.add_just_u32(args.just_u32); + builder.add_default_i32(args.default_i32); + if let Some(x) = args.maybe_i32 { builder.add_maybe_i32(x); } + builder.add_just_i32(args.just_i32); + builder.add_default_u16(args.default_u16); + if let Some(x) = args.maybe_u16 { builder.add_maybe_u16(x); } + builder.add_just_u16(args.just_u16); + builder.add_default_i16(args.default_i16); + if let Some(x) = args.maybe_i16 { builder.add_maybe_i16(x); } + builder.add_just_i16(args.just_i16); + builder.add_default_enum(args.default_enum); + if let Some(x) = args.maybe_enum { builder.add_maybe_enum(x); } + builder.add_just_enum(args.just_enum); + builder.add_default_bool(args.default_bool); + if let Some(x) = args.maybe_bool { builder.add_maybe_bool(x); } + builder.add_just_bool(args.just_bool); + builder.add_default_u8(args.default_u8); + if let Some(x) = args.maybe_u8 { builder.add_maybe_u8(x); } + builder.add_just_u8(args.just_u8); + builder.add_default_i8(args.default_i8); + if let Some(x) = args.maybe_i8 { builder.add_maybe_i8(x); } + builder.add_just_i8(args.just_i8); + builder.finish() + } - #[inline] - pub fn default_i8(&self) -> i8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I8, Some(42)).unwrap()} - } + pub fn unpack(&self) -> ScalarStuffT { + let just_i8 = self.just_i8(); + let maybe_i8 = self.maybe_i8(); + let default_i8 = self.default_i8(); + let just_u8 = self.just_u8(); + let maybe_u8 = self.maybe_u8(); + let default_u8 = self.default_u8(); + let just_i16 = self.just_i16(); + let maybe_i16 = self.maybe_i16(); + let default_i16 = self.default_i16(); + let just_u16 = self.just_u16(); + let maybe_u16 = self.maybe_u16(); + let default_u16 = self.default_u16(); + let just_i32 = self.just_i32(); + let maybe_i32 = self.maybe_i32(); + let default_i32 = self.default_i32(); + let just_u32 = self.just_u32(); + let maybe_u32 = self.maybe_u32(); + let default_u32 = self.default_u32(); + let just_i64 = self.just_i64(); + let maybe_i64 = self.maybe_i64(); + let default_i64 = self.default_i64(); + let just_u64 = self.just_u64(); + let maybe_u64 = self.maybe_u64(); + let default_u64 = self.default_u64(); + let just_f32 = self.just_f32(); + let maybe_f32 = self.maybe_f32(); + let default_f32 = self.default_f32(); + let just_f64 = self.just_f64(); + let maybe_f64 = self.maybe_f64(); + let default_f64 = self.default_f64(); + let just_bool = self.just_bool(); + let maybe_bool = self.maybe_bool(); + let default_bool = self.default_bool(); + let just_enum = self.just_enum(); + let maybe_enum = self.maybe_enum(); + let default_enum = self.default_enum(); + ScalarStuffT { + just_i8, + maybe_i8, + default_i8, + just_u8, + maybe_u8, + default_u8, + just_i16, + maybe_i16, + default_i16, + just_u16, + maybe_u16, + default_u16, + just_i32, + maybe_i32, + default_i32, + just_u32, + maybe_u32, + default_u32, + just_i64, + maybe_i64, + default_i64, + just_u64, + maybe_u64, + default_u64, + just_f32, + maybe_f32, + default_f32, + just_f64, + maybe_f64, + default_f64, + just_bool, + maybe_bool, + default_bool, + just_enum, + maybe_enum, + default_enum, + } + } - #[inline] - pub fn just_u8(&self) -> u8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_U8, Some(0)).unwrap()} - } + #[inline] + pub fn just_i8(&self) -> i8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_I8, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_u8(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U8, None)} - } + #[inline] + pub fn maybe_i8(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I8, None)} + } - #[inline] - pub fn default_u8(&self) -> u8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U8, Some(42)).unwrap()} - } + #[inline] + pub fn default_i8(&self) -> i8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I8, Some(42)).unwrap()} + } - #[inline] - pub fn just_i16(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_I16, Some(0)).unwrap()} - } + #[inline] + pub fn just_u8(&self) -> u8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_U8, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_i16(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I16, None)} - } + #[inline] + pub fn maybe_u8(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U8, None)} + } - #[inline] - pub fn default_i16(&self) -> i16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I16, Some(42)).unwrap()} - } + #[inline] + pub fn default_u8(&self) -> u8 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U8, Some(42)).unwrap()} + } - #[inline] - pub fn just_u16(&self) -> u16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_U16, Some(0)).unwrap()} - } + #[inline] + pub fn just_i16(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_I16, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_u16(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U16, None)} - } + #[inline] + pub fn maybe_i16(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I16, None)} + } - #[inline] - pub fn default_u16(&self) -> u16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U16, Some(42)).unwrap()} - } + #[inline] + pub fn default_i16(&self) -> i16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I16, Some(42)).unwrap()} + } - #[inline] - pub fn just_i32(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_I32, Some(0)).unwrap()} - } + #[inline] + pub fn just_u16(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_U16, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_i32(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I32, None)} - } + #[inline] + pub fn maybe_u16(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U16, None)} + } - #[inline] - pub fn default_i32(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I32, Some(42)).unwrap()} - } + #[inline] + pub fn default_u16(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U16, Some(42)).unwrap()} + } - #[inline] - pub fn just_u32(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_U32, Some(0)).unwrap()} - } + #[inline] + pub fn just_i32(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_I32, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_u32(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U32, None)} - } + #[inline] + pub fn maybe_i32(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I32, None)} + } - #[inline] - pub fn default_u32(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U32, Some(42)).unwrap()} - } + #[inline] + pub fn default_i32(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I32, Some(42)).unwrap()} + } - #[inline] - pub fn just_i64(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_I64, Some(0)).unwrap()} - } + #[inline] + pub fn just_u32(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_U32, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_i64(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I64, None)} - } + #[inline] + pub fn maybe_u32(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U32, None)} + } - #[inline] - pub fn default_i64(&self) -> i64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I64, Some(42)).unwrap()} - } + #[inline] + pub fn default_u32(&self) -> u32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U32, Some(42)).unwrap()} + } - #[inline] - pub fn just_u64(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_U64, Some(0)).unwrap()} - } + #[inline] + pub fn just_i64(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_I64, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_u64(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U64, None)} - } + #[inline] + pub fn maybe_i64(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_I64, None)} + } - #[inline] - pub fn default_u64(&self) -> u64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U64, Some(42)).unwrap()} - } + #[inline] + pub fn default_i64(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_I64, Some(42)).unwrap()} + } - #[inline] - pub fn just_f32(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_F32, Some(0.0)).unwrap()} - } + #[inline] + pub fn just_u64(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_U64, Some(0)).unwrap()} + } - #[inline] - pub fn maybe_f32(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_F32, None)} - } + #[inline] + pub fn maybe_u64(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_U64, None)} + } - #[inline] - pub fn default_f32(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_F32, Some(42.0)).unwrap()} - } + #[inline] + pub fn default_u64(&self) -> u64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_U64, Some(42)).unwrap()} + } - #[inline] - pub fn just_f64(&self) -> f64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_F64, Some(0.0)).unwrap()} - } + #[inline] + pub fn just_f32(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_F32, Some(0.0)).unwrap()} + } - #[inline] - pub fn maybe_f64(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_F64, None)} - } + #[inline] + pub fn maybe_f32(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_F32, None)} + } - #[inline] - pub fn default_f64(&self) -> f64 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_F64, Some(42.0)).unwrap()} - } + #[inline] + pub fn default_f32(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_F32, Some(42.0)).unwrap()} + } - #[inline] - pub fn just_bool(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_BOOL, Some(false)).unwrap()} - } + #[inline] + pub fn just_f64(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_F64, Some(0.0)).unwrap()} + } - #[inline] - pub fn maybe_bool(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_BOOL, None)} - } + #[inline] + pub fn maybe_f64(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_F64, None)} + } - #[inline] - pub fn default_bool(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_BOOL, Some(true)).unwrap()} - } + #[inline] + pub fn default_f64(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_F64, Some(42.0)).unwrap()} + } - #[inline] - pub fn just_enum(&self) -> OptionalByte { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_JUST_ENUM, Some(OptionalByte::None)).unwrap()} - } + #[inline] + pub fn just_bool(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_BOOL, Some(false)).unwrap()} + } - #[inline] - pub fn maybe_enum(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_ENUM, None)} - } + #[inline] + pub fn maybe_bool(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_BOOL, None)} + } - #[inline] - pub fn default_enum(&self) -> OptionalByte { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_ENUM, Some(OptionalByte::One)).unwrap()} - } + #[inline] + pub fn default_bool(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_BOOL, Some(true)).unwrap()} + } + + #[inline] + pub fn just_enum(&self) -> OptionalByte { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_JUST_ENUM, Some(OptionalByte::None)).unwrap()} + } + + #[inline] + pub fn maybe_enum(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_MAYBE_ENUM, None)} + } + + #[inline] + pub fn default_enum(&self) -> OptionalByte { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ScalarStuff::VT_DEFAULT_ENUM, Some(OptionalByte::One)).unwrap()} + } } impl ::flatbuffers::Verifiable for ScalarStuff<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("just_i8", Self::VT_JUST_I8, false)? - .visit_field::("maybe_i8", Self::VT_MAYBE_I8, false)? - .visit_field::("default_i8", Self::VT_DEFAULT_I8, false)? - .visit_field::("just_u8", Self::VT_JUST_U8, false)? - .visit_field::("maybe_u8", Self::VT_MAYBE_U8, false)? - .visit_field::("default_u8", Self::VT_DEFAULT_U8, false)? - .visit_field::("just_i16", Self::VT_JUST_I16, false)? - .visit_field::("maybe_i16", Self::VT_MAYBE_I16, false)? - .visit_field::("default_i16", Self::VT_DEFAULT_I16, false)? - .visit_field::("just_u16", Self::VT_JUST_U16, false)? - .visit_field::("maybe_u16", Self::VT_MAYBE_U16, false)? - .visit_field::("default_u16", Self::VT_DEFAULT_U16, false)? - .visit_field::("just_i32", Self::VT_JUST_I32, false)? - .visit_field::("maybe_i32", Self::VT_MAYBE_I32, false)? - .visit_field::("default_i32", Self::VT_DEFAULT_I32, false)? - .visit_field::("just_u32", Self::VT_JUST_U32, false)? - .visit_field::("maybe_u32", Self::VT_MAYBE_U32, false)? - .visit_field::("default_u32", Self::VT_DEFAULT_U32, false)? - .visit_field::("just_i64", Self::VT_JUST_I64, false)? - .visit_field::("maybe_i64", Self::VT_MAYBE_I64, false)? - .visit_field::("default_i64", Self::VT_DEFAULT_I64, false)? - .visit_field::("just_u64", Self::VT_JUST_U64, false)? - .visit_field::("maybe_u64", Self::VT_MAYBE_U64, false)? - .visit_field::("default_u64", Self::VT_DEFAULT_U64, false)? - .visit_field::("just_f32", Self::VT_JUST_F32, false)? - .visit_field::("maybe_f32", Self::VT_MAYBE_F32, false)? - .visit_field::("default_f32", Self::VT_DEFAULT_F32, false)? - .visit_field::("just_f64", Self::VT_JUST_F64, false)? - .visit_field::("maybe_f64", Self::VT_MAYBE_F64, false)? - .visit_field::("default_f64", Self::VT_DEFAULT_F64, false)? - .visit_field::("just_bool", Self::VT_JUST_BOOL, false)? - .visit_field::("maybe_bool", Self::VT_MAYBE_BOOL, false)? - .visit_field::("default_bool", Self::VT_DEFAULT_BOOL, false)? - .visit_field::("just_enum", Self::VT_JUST_ENUM, false)? - .visit_field::("maybe_enum", Self::VT_MAYBE_ENUM, false)? - .visit_field::("default_enum", Self::VT_DEFAULT_ENUM, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("just_i8", Self::VT_JUST_I8, false)? + .visit_field::("maybe_i8", Self::VT_MAYBE_I8, false)? + .visit_field::("default_i8", Self::VT_DEFAULT_I8, false)? + .visit_field::("just_u8", Self::VT_JUST_U8, false)? + .visit_field::("maybe_u8", Self::VT_MAYBE_U8, false)? + .visit_field::("default_u8", Self::VT_DEFAULT_U8, false)? + .visit_field::("just_i16", Self::VT_JUST_I16, false)? + .visit_field::("maybe_i16", Self::VT_MAYBE_I16, false)? + .visit_field::("default_i16", Self::VT_DEFAULT_I16, false)? + .visit_field::("just_u16", Self::VT_JUST_U16, false)? + .visit_field::("maybe_u16", Self::VT_MAYBE_U16, false)? + .visit_field::("default_u16", Self::VT_DEFAULT_U16, false)? + .visit_field::("just_i32", Self::VT_JUST_I32, false)? + .visit_field::("maybe_i32", Self::VT_MAYBE_I32, false)? + .visit_field::("default_i32", Self::VT_DEFAULT_I32, false)? + .visit_field::("just_u32", Self::VT_JUST_U32, false)? + .visit_field::("maybe_u32", Self::VT_MAYBE_U32, false)? + .visit_field::("default_u32", Self::VT_DEFAULT_U32, false)? + .visit_field::("just_i64", Self::VT_JUST_I64, false)? + .visit_field::("maybe_i64", Self::VT_MAYBE_I64, false)? + .visit_field::("default_i64", Self::VT_DEFAULT_I64, false)? + .visit_field::("just_u64", Self::VT_JUST_U64, false)? + .visit_field::("maybe_u64", Self::VT_MAYBE_U64, false)? + .visit_field::("default_u64", Self::VT_DEFAULT_U64, false)? + .visit_field::("just_f32", Self::VT_JUST_F32, false)? + .visit_field::("maybe_f32", Self::VT_MAYBE_F32, false)? + .visit_field::("default_f32", Self::VT_DEFAULT_F32, false)? + .visit_field::("just_f64", Self::VT_JUST_F64, false)? + .visit_field::("maybe_f64", Self::VT_MAYBE_F64, false)? + .visit_field::("default_f64", Self::VT_DEFAULT_F64, false)? + .visit_field::("just_bool", Self::VT_JUST_BOOL, false)? + .visit_field::("maybe_bool", Self::VT_MAYBE_BOOL, false)? + .visit_field::("default_bool", Self::VT_DEFAULT_BOOL, false)? + .visit_field::("just_enum", Self::VT_JUST_ENUM, false)? + .visit_field::("maybe_enum", Self::VT_MAYBE_ENUM, false)? + .visit_field::("default_enum", Self::VT_DEFAULT_ENUM, false)? + .finish(); + Ok(()) + } } pub struct ScalarStuffArgs { @@ -564,458 +564,458 @@ pub struct ScalarStuffArgs { } impl<'a> Default for ScalarStuffArgs { - #[inline] - fn default() -> Self { - ScalarStuffArgs { - just_i8: 0, - maybe_i8: None, - default_i8: 42, - just_u8: 0, - maybe_u8: None, - default_u8: 42, - just_i16: 0, - maybe_i16: None, - default_i16: 42, - just_u16: 0, - maybe_u16: None, - default_u16: 42, - just_i32: 0, - maybe_i32: None, - default_i32: 42, - just_u32: 0, - maybe_u32: None, - default_u32: 42, - just_i64: 0, - maybe_i64: None, - default_i64: 42, - just_u64: 0, - maybe_u64: None, - default_u64: 42, - just_f32: 0.0, - maybe_f32: None, - default_f32: 42.0, - just_f64: 0.0, - maybe_f64: None, - default_f64: 42.0, - just_bool: false, - maybe_bool: None, - default_bool: true, - just_enum: OptionalByte::None, - maybe_enum: None, - default_enum: OptionalByte::One, + #[inline] + fn default() -> Self { + ScalarStuffArgs { + just_i8: 0, + maybe_i8: None, + default_i8: 42, + just_u8: 0, + maybe_u8: None, + default_u8: 42, + just_i16: 0, + maybe_i16: None, + default_i16: 42, + just_u16: 0, + maybe_u16: None, + default_u16: 42, + just_i32: 0, + maybe_i32: None, + default_i32: 42, + just_u32: 0, + maybe_u32: None, + default_u32: 42, + just_i64: 0, + maybe_i64: None, + default_i64: 42, + just_u64: 0, + maybe_u64: None, + default_u64: 42, + just_f32: 0.0, + maybe_f32: None, + default_f32: 42.0, + just_f64: 0.0, + maybe_f64: None, + default_f64: 42.0, + just_bool: false, + maybe_bool: None, + default_bool: true, + just_enum: OptionalByte::None, + maybe_enum: None, + default_enum: OptionalByte::One, + } } - } } pub struct ScalarStuffBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ScalarStuffBuilder<'a, 'b, A> { - #[inline] - pub fn add_just_i8(&mut self, just_i8: i8) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_I8, just_i8, 0); - } - - #[inline] - pub fn add_maybe_i8(&mut self, maybe_i8: i8) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I8, maybe_i8); - } - - #[inline] - pub fn add_default_i8(&mut self, default_i8: i8) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I8, default_i8, 42); - } - - #[inline] - pub fn add_just_u8(&mut self, just_u8: u8) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_U8, just_u8, 0); - } - - #[inline] - pub fn add_maybe_u8(&mut self, maybe_u8: u8) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U8, maybe_u8); - } - - #[inline] - pub fn add_default_u8(&mut self, default_u8: u8) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U8, default_u8, 42); - } - - #[inline] - pub fn add_just_i16(&mut self, just_i16: i16) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_I16, just_i16, 0); - } - - #[inline] - pub fn add_maybe_i16(&mut self, maybe_i16: i16) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I16, maybe_i16); - } - - #[inline] - pub fn add_default_i16(&mut self, default_i16: i16) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I16, default_i16, 42); - } - - #[inline] - pub fn add_just_u16(&mut self, just_u16: u16) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_U16, just_u16, 0); - } - - #[inline] - pub fn add_maybe_u16(&mut self, maybe_u16: u16) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U16, maybe_u16); - } - - #[inline] - pub fn add_default_u16(&mut self, default_u16: u16) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U16, default_u16, 42); - } - - #[inline] - pub fn add_just_i32(&mut self, just_i32: i32) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_I32, just_i32, 0); - } - - #[inline] - pub fn add_maybe_i32(&mut self, maybe_i32: i32) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I32, maybe_i32); - } - - #[inline] - pub fn add_default_i32(&mut self, default_i32: i32) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I32, default_i32, 42); - } - - #[inline] - pub fn add_just_u32(&mut self, just_u32: u32) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_U32, just_u32, 0); - } - - #[inline] - pub fn add_maybe_u32(&mut self, maybe_u32: u32) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U32, maybe_u32); - } - - #[inline] - pub fn add_default_u32(&mut self, default_u32: u32) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U32, default_u32, 42); - } - - #[inline] - pub fn add_just_i64(&mut self, just_i64: i64) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_I64, just_i64, 0); - } - - #[inline] - pub fn add_maybe_i64(&mut self, maybe_i64: i64) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I64, maybe_i64); - } - - #[inline] - pub fn add_default_i64(&mut self, default_i64: i64) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I64, default_i64, 42); - } - - #[inline] - pub fn add_just_u64(&mut self, just_u64: u64) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_U64, just_u64, 0); - } - - #[inline] - pub fn add_maybe_u64(&mut self, maybe_u64: u64) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U64, maybe_u64); - } - - #[inline] - pub fn add_default_u64(&mut self, default_u64: u64) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U64, default_u64, 42); - } - - #[inline] - pub fn add_just_f32(&mut self, just_f32: f32) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_F32, just_f32, 0.0); - } - - #[inline] - pub fn add_maybe_f32(&mut self, maybe_f32: f32) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_F32, maybe_f32); - } - - #[inline] - pub fn add_default_f32(&mut self, default_f32: f32) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_F32, default_f32, 42.0); - } - - #[inline] - pub fn add_just_f64(&mut self, just_f64: f64) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_F64, just_f64, 0.0); - } - - #[inline] - pub fn add_maybe_f64(&mut self, maybe_f64: f64) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_F64, maybe_f64); - } - - #[inline] - pub fn add_default_f64(&mut self, default_f64: f64) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_F64, default_f64, 42.0); - } - - #[inline] - pub fn add_just_bool(&mut self, just_bool: bool) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_BOOL, just_bool, false); - } - - #[inline] - pub fn add_maybe_bool(&mut self, maybe_bool: bool) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_BOOL, maybe_bool); - } - - #[inline] - pub fn add_default_bool(&mut self, default_bool: bool) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_BOOL, default_bool, true); - } - - #[inline] - pub fn add_just_enum(&mut self, just_enum: OptionalByte) { - self.fbb_.push_slot::(ScalarStuff::VT_JUST_ENUM, just_enum, OptionalByte::None); - } - - #[inline] - pub fn add_maybe_enum(&mut self, maybe_enum: OptionalByte) { - self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_ENUM, maybe_enum); - } - - #[inline] - pub fn add_default_enum(&mut self, default_enum: OptionalByte) { - self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_ENUM, default_enum, OptionalByte::One); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ScalarStuffBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - ScalarStuffBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_just_i8(&mut self, just_i8: i8) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_I8, just_i8, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_maybe_i8(&mut self, maybe_i8: i8) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I8, maybe_i8); + } + + #[inline] + pub fn add_default_i8(&mut self, default_i8: i8) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I8, default_i8, 42); + } + + #[inline] + pub fn add_just_u8(&mut self, just_u8: u8) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_U8, just_u8, 0); + } + + #[inline] + pub fn add_maybe_u8(&mut self, maybe_u8: u8) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U8, maybe_u8); + } + + #[inline] + pub fn add_default_u8(&mut self, default_u8: u8) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U8, default_u8, 42); + } + + #[inline] + pub fn add_just_i16(&mut self, just_i16: i16) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_I16, just_i16, 0); + } + + #[inline] + pub fn add_maybe_i16(&mut self, maybe_i16: i16) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I16, maybe_i16); + } + + #[inline] + pub fn add_default_i16(&mut self, default_i16: i16) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I16, default_i16, 42); + } + + #[inline] + pub fn add_just_u16(&mut self, just_u16: u16) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_U16, just_u16, 0); + } + + #[inline] + pub fn add_maybe_u16(&mut self, maybe_u16: u16) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U16, maybe_u16); + } + + #[inline] + pub fn add_default_u16(&mut self, default_u16: u16) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U16, default_u16, 42); + } + + #[inline] + pub fn add_just_i32(&mut self, just_i32: i32) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_I32, just_i32, 0); + } + + #[inline] + pub fn add_maybe_i32(&mut self, maybe_i32: i32) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I32, maybe_i32); + } + + #[inline] + pub fn add_default_i32(&mut self, default_i32: i32) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I32, default_i32, 42); + } + + #[inline] + pub fn add_just_u32(&mut self, just_u32: u32) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_U32, just_u32, 0); + } + + #[inline] + pub fn add_maybe_u32(&mut self, maybe_u32: u32) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U32, maybe_u32); + } + + #[inline] + pub fn add_default_u32(&mut self, default_u32: u32) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U32, default_u32, 42); + } + + #[inline] + pub fn add_just_i64(&mut self, just_i64: i64) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_I64, just_i64, 0); + } + + #[inline] + pub fn add_maybe_i64(&mut self, maybe_i64: i64) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_I64, maybe_i64); + } + + #[inline] + pub fn add_default_i64(&mut self, default_i64: i64) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_I64, default_i64, 42); + } + + #[inline] + pub fn add_just_u64(&mut self, just_u64: u64) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_U64, just_u64, 0); + } + + #[inline] + pub fn add_maybe_u64(&mut self, maybe_u64: u64) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_U64, maybe_u64); + } + + #[inline] + pub fn add_default_u64(&mut self, default_u64: u64) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_U64, default_u64, 42); + } + + #[inline] + pub fn add_just_f32(&mut self, just_f32: f32) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_F32, just_f32, 0.0); + } + + #[inline] + pub fn add_maybe_f32(&mut self, maybe_f32: f32) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_F32, maybe_f32); + } + + #[inline] + pub fn add_default_f32(&mut self, default_f32: f32) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_F32, default_f32, 42.0); + } + + #[inline] + pub fn add_just_f64(&mut self, just_f64: f64) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_F64, just_f64, 0.0); + } + + #[inline] + pub fn add_maybe_f64(&mut self, maybe_f64: f64) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_F64, maybe_f64); + } + + #[inline] + pub fn add_default_f64(&mut self, default_f64: f64) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_F64, default_f64, 42.0); + } + + #[inline] + pub fn add_just_bool(&mut self, just_bool: bool) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_BOOL, just_bool, false); + } + + #[inline] + pub fn add_maybe_bool(&mut self, maybe_bool: bool) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_BOOL, maybe_bool); + } + + #[inline] + pub fn add_default_bool(&mut self, default_bool: bool) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_BOOL, default_bool, true); + } + + #[inline] + pub fn add_just_enum(&mut self, just_enum: OptionalByte) { + self.fbb_.push_slot::(ScalarStuff::VT_JUST_ENUM, just_enum, OptionalByte::None); + } + + #[inline] + pub fn add_maybe_enum(&mut self, maybe_enum: OptionalByte) { + self.fbb_.push_slot_always::(ScalarStuff::VT_MAYBE_ENUM, maybe_enum); + } + + #[inline] + pub fn add_default_enum(&mut self, default_enum: OptionalByte) { + self.fbb_.push_slot::(ScalarStuff::VT_DEFAULT_ENUM, default_enum, OptionalByte::One); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ScalarStuffBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + ScalarStuffBuilder { + 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 ::core::fmt::Debug for ScalarStuff<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("ScalarStuff"); - ds.field("just_i8", &self.just_i8()); - ds.field("maybe_i8", &self.maybe_i8()); - ds.field("default_i8", &self.default_i8()); - ds.field("just_u8", &self.just_u8()); - ds.field("maybe_u8", &self.maybe_u8()); - ds.field("default_u8", &self.default_u8()); - ds.field("just_i16", &self.just_i16()); - ds.field("maybe_i16", &self.maybe_i16()); - ds.field("default_i16", &self.default_i16()); - ds.field("just_u16", &self.just_u16()); - ds.field("maybe_u16", &self.maybe_u16()); - ds.field("default_u16", &self.default_u16()); - ds.field("just_i32", &self.just_i32()); - ds.field("maybe_i32", &self.maybe_i32()); - ds.field("default_i32", &self.default_i32()); - ds.field("just_u32", &self.just_u32()); - ds.field("maybe_u32", &self.maybe_u32()); - ds.field("default_u32", &self.default_u32()); - ds.field("just_i64", &self.just_i64()); - ds.field("maybe_i64", &self.maybe_i64()); - ds.field("default_i64", &self.default_i64()); - ds.field("just_u64", &self.just_u64()); - ds.field("maybe_u64", &self.maybe_u64()); - ds.field("default_u64", &self.default_u64()); - ds.field("just_f32", &self.just_f32()); - ds.field("maybe_f32", &self.maybe_f32()); - ds.field("default_f32", &self.default_f32()); - ds.field("just_f64", &self.just_f64()); - ds.field("maybe_f64", &self.maybe_f64()); - ds.field("default_f64", &self.default_f64()); - ds.field("just_bool", &self.just_bool()); - ds.field("maybe_bool", &self.maybe_bool()); - ds.field("default_bool", &self.default_bool()); - ds.field("just_enum", &self.just_enum()); - ds.field("maybe_enum", &self.maybe_enum()); - ds.field("default_enum", &self.default_enum()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("ScalarStuff"); + ds.field("just_i8", &self.just_i8()); + ds.field("maybe_i8", &self.maybe_i8()); + ds.field("default_i8", &self.default_i8()); + ds.field("just_u8", &self.just_u8()); + ds.field("maybe_u8", &self.maybe_u8()); + ds.field("default_u8", &self.default_u8()); + ds.field("just_i16", &self.just_i16()); + ds.field("maybe_i16", &self.maybe_i16()); + ds.field("default_i16", &self.default_i16()); + ds.field("just_u16", &self.just_u16()); + ds.field("maybe_u16", &self.maybe_u16()); + ds.field("default_u16", &self.default_u16()); + ds.field("just_i32", &self.just_i32()); + ds.field("maybe_i32", &self.maybe_i32()); + ds.field("default_i32", &self.default_i32()); + ds.field("just_u32", &self.just_u32()); + ds.field("maybe_u32", &self.maybe_u32()); + ds.field("default_u32", &self.default_u32()); + ds.field("just_i64", &self.just_i64()); + ds.field("maybe_i64", &self.maybe_i64()); + ds.field("default_i64", &self.default_i64()); + ds.field("just_u64", &self.just_u64()); + ds.field("maybe_u64", &self.maybe_u64()); + ds.field("default_u64", &self.default_u64()); + ds.field("just_f32", &self.just_f32()); + ds.field("maybe_f32", &self.maybe_f32()); + ds.field("default_f32", &self.default_f32()); + ds.field("just_f64", &self.just_f64()); + ds.field("maybe_f64", &self.maybe_f64()); + ds.field("default_f64", &self.default_f64()); + ds.field("just_bool", &self.just_bool()); + ds.field("maybe_bool", &self.maybe_bool()); + ds.field("default_bool", &self.default_bool()); + ds.field("just_enum", &self.just_enum()); + ds.field("maybe_enum", &self.maybe_enum()); + ds.field("default_enum", &self.default_enum()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct ScalarStuffT { - pub just_i8: i8, - pub maybe_i8: Option, - pub default_i8: i8, - pub just_u8: u8, - pub maybe_u8: Option, - pub default_u8: u8, - pub just_i16: i16, - pub maybe_i16: Option, - pub default_i16: i16, - pub just_u16: u16, - pub maybe_u16: Option, - pub default_u16: u16, - pub just_i32: i32, - pub maybe_i32: Option, - pub default_i32: i32, - pub just_u32: u32, - pub maybe_u32: Option, - pub default_u32: u32, - pub just_i64: i64, - pub maybe_i64: Option, - pub default_i64: i64, - pub just_u64: u64, - pub maybe_u64: Option, - pub default_u64: u64, - pub just_f32: f32, - pub maybe_f32: Option, - pub default_f32: f32, - pub just_f64: f64, - pub maybe_f64: Option, - pub default_f64: f64, - pub just_bool: bool, - pub maybe_bool: Option, - pub default_bool: bool, - pub just_enum: OptionalByte, - pub maybe_enum: Option, - pub default_enum: OptionalByte, + pub just_i8: i8, + pub maybe_i8: Option, + pub default_i8: i8, + pub just_u8: u8, + pub maybe_u8: Option, + pub default_u8: u8, + pub just_i16: i16, + pub maybe_i16: Option, + pub default_i16: i16, + pub just_u16: u16, + pub maybe_u16: Option, + pub default_u16: u16, + pub just_i32: i32, + pub maybe_i32: Option, + pub default_i32: i32, + pub just_u32: u32, + pub maybe_u32: Option, + pub default_u32: u32, + pub just_i64: i64, + pub maybe_i64: Option, + pub default_i64: i64, + pub just_u64: u64, + pub maybe_u64: Option, + pub default_u64: u64, + pub just_f32: f32, + pub maybe_f32: Option, + pub default_f32: f32, + pub just_f64: f64, + pub maybe_f64: Option, + pub default_f64: f64, + pub just_bool: bool, + pub maybe_bool: Option, + pub default_bool: bool, + pub just_enum: OptionalByte, + pub maybe_enum: Option, + pub default_enum: OptionalByte, } impl Default for ScalarStuffT { - fn default() -> Self { - Self { - just_i8: 0, - maybe_i8: None, - default_i8: 42, - just_u8: 0, - maybe_u8: None, - default_u8: 42, - just_i16: 0, - maybe_i16: None, - default_i16: 42, - just_u16: 0, - maybe_u16: None, - default_u16: 42, - just_i32: 0, - maybe_i32: None, - default_i32: 42, - just_u32: 0, - maybe_u32: None, - default_u32: 42, - just_i64: 0, - maybe_i64: None, - default_i64: 42, - just_u64: 0, - maybe_u64: None, - default_u64: 42, - just_f32: 0.0, - maybe_f32: None, - default_f32: 42.0, - just_f64: 0.0, - maybe_f64: None, - default_f64: 42.0, - just_bool: false, - maybe_bool: None, - default_bool: true, - just_enum: OptionalByte::None, - maybe_enum: None, - default_enum: OptionalByte::One, + fn default() -> Self { + Self { + just_i8: 0, + maybe_i8: None, + default_i8: 42, + just_u8: 0, + maybe_u8: None, + default_u8: 42, + just_i16: 0, + maybe_i16: None, + default_i16: 42, + just_u16: 0, + maybe_u16: None, + default_u16: 42, + just_i32: 0, + maybe_i32: None, + default_i32: 42, + just_u32: 0, + maybe_u32: None, + default_u32: 42, + just_i64: 0, + maybe_i64: None, + default_i64: 42, + just_u64: 0, + maybe_u64: None, + default_u64: 42, + just_f32: 0.0, + maybe_f32: None, + default_f32: 42.0, + just_f64: 0.0, + maybe_f64: None, + default_f64: 42.0, + just_bool: false, + maybe_bool: None, + default_bool: true, + just_enum: OptionalByte::None, + maybe_enum: None, + default_enum: OptionalByte::One, + } } - } } impl ScalarStuffT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let just_i8 = self.just_i8; - let maybe_i8 = self.maybe_i8; - let default_i8 = self.default_i8; - let just_u8 = self.just_u8; - let maybe_u8 = self.maybe_u8; - let default_u8 = self.default_u8; - let just_i16 = self.just_i16; - let maybe_i16 = self.maybe_i16; - let default_i16 = self.default_i16; - let just_u16 = self.just_u16; - let maybe_u16 = self.maybe_u16; - let default_u16 = self.default_u16; - let just_i32 = self.just_i32; - let maybe_i32 = self.maybe_i32; - let default_i32 = self.default_i32; - let just_u32 = self.just_u32; - let maybe_u32 = self.maybe_u32; - let default_u32 = self.default_u32; - let just_i64 = self.just_i64; - let maybe_i64 = self.maybe_i64; - let default_i64 = self.default_i64; - let just_u64 = self.just_u64; - let maybe_u64 = self.maybe_u64; - let default_u64 = self.default_u64; - let just_f32 = self.just_f32; - let maybe_f32 = self.maybe_f32; - let default_f32 = self.default_f32; - let just_f64 = self.just_f64; - let maybe_f64 = self.maybe_f64; - let default_f64 = self.default_f64; - let just_bool = self.just_bool; - let maybe_bool = self.maybe_bool; - let default_bool = self.default_bool; - let just_enum = self.just_enum; - let maybe_enum = self.maybe_enum; - let default_enum = self.default_enum; - ScalarStuff::create(_fbb, &ScalarStuffArgs{ - just_i8, - maybe_i8, - default_i8, - just_u8, - maybe_u8, - default_u8, - just_i16, - maybe_i16, - default_i16, - just_u16, - maybe_u16, - default_u16, - just_i32, - maybe_i32, - default_i32, - just_u32, - maybe_u32, - default_u32, - just_i64, - maybe_i64, - default_i64, - just_u64, - maybe_u64, - default_u64, - just_f32, - maybe_f32, - default_f32, - just_f64, - maybe_f64, - default_f64, - just_bool, - maybe_bool, - default_bool, - just_enum, - maybe_enum, - default_enum, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let just_i8 = self.just_i8; + let maybe_i8 = self.maybe_i8; + let default_i8 = self.default_i8; + let just_u8 = self.just_u8; + let maybe_u8 = self.maybe_u8; + let default_u8 = self.default_u8; + let just_i16 = self.just_i16; + let maybe_i16 = self.maybe_i16; + let default_i16 = self.default_i16; + let just_u16 = self.just_u16; + let maybe_u16 = self.maybe_u16; + let default_u16 = self.default_u16; + let just_i32 = self.just_i32; + let maybe_i32 = self.maybe_i32; + let default_i32 = self.default_i32; + let just_u32 = self.just_u32; + let maybe_u32 = self.maybe_u32; + let default_u32 = self.default_u32; + let just_i64 = self.just_i64; + let maybe_i64 = self.maybe_i64; + let default_i64 = self.default_i64; + let just_u64 = self.just_u64; + let maybe_u64 = self.maybe_u64; + let default_u64 = self.default_u64; + let just_f32 = self.just_f32; + let maybe_f32 = self.maybe_f32; + let default_f32 = self.default_f32; + let just_f64 = self.just_f64; + let maybe_f64 = self.maybe_f64; + let default_f64 = self.default_f64; + let just_bool = self.just_bool; + let maybe_bool = self.maybe_bool; + let default_bool = self.default_bool; + let just_enum = self.just_enum; + let maybe_enum = self.maybe_enum; + let default_enum = self.default_enum; + ScalarStuff::create(_fbb, &ScalarStuffArgs{ + just_i8, + maybe_i8, + default_i8, + just_u8, + maybe_u8, + default_u8, + just_i16, + maybe_i16, + default_i16, + just_u16, + maybe_u16, + default_u16, + just_i32, + maybe_i32, + default_i32, + just_u32, + maybe_u32, + default_u32, + just_i64, + maybe_i64, + default_i64, + just_u64, + maybe_u64, + default_u64, + just_f32, + maybe_f32, + default_f32, + just_f64, + maybe_f64, + default_f64, + just_bool, + maybe_bool, + default_bool, + just_enum, + maybe_enum, + default_enum, + }) + } } /// Verifies that a buffer of bytes contains a `ScalarStuff` @@ -1026,7 +1026,7 @@ impl ScalarStuffT { /// `root_as_scalar_stuff_unchecked`. #[inline] pub fn root_as_scalar_stuff(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) + ::flatbuffers::root::(buf) } /// Verifies that a buffer of bytes contains a size prefixed @@ -1037,7 +1037,7 @@ pub fn root_as_scalar_stuff(buf: &[u8]) -> Result, ::flatbuffers /// `size_prefixed_root_as_scalar_stuff_unchecked`. #[inline] pub fn size_prefixed_root_as_scalar_stuff(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) + ::flatbuffers::size_prefixed_root::(buf) } /// Verifies, with the given options, that a buffer of bytes @@ -1048,10 +1048,10 @@ pub fn size_prefixed_root_as_scalar_stuff(buf: &[u8]) -> Result, /// `root_as_scalar_stuff_unchecked`. #[inline] pub fn root_as_scalar_stuff_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) + ::flatbuffers::root_with_opts::>(opts, buf) } /// Verifies, with the given verifier options, that a buffer of @@ -1062,10 +1062,10 @@ pub fn root_as_scalar_stuff_with_opts<'b, 'o>( /// `root_as_scalar_stuff_unchecked`. #[inline] pub fn size_prefixed_root_as_scalar_stuff_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, - buf: &'b [u8], + opts: &'o ::flatbuffers::VerifierOptions, + buf: &'b [u8], ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } /// Assumes, without verification, that a buffer of bytes contains a ScalarStuff and returns it. @@ -1073,7 +1073,7 @@ pub fn size_prefixed_root_as_scalar_stuff_with_opts<'b, 'o>( /// Callers must trust the given bytes do indeed contain a valid `ScalarStuff`. #[inline] pub unsafe fn root_as_scalar_stuff_unchecked(buf: &[u8]) -> ScalarStuff<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } + unsafe { ::flatbuffers::root_unchecked::(buf) } } /// Assumes, without verification, that a buffer of bytes contains a size prefixed ScalarStuff and returns it. @@ -1081,19 +1081,19 @@ pub unsafe fn root_as_scalar_stuff_unchecked(buf: &[u8]) -> ScalarStuff<'_> { /// Callers must trust the given bytes do indeed contain a valid size prefixed `ScalarStuff`. #[inline] pub unsafe fn size_prefixed_root_as_scalar_stuff_unchecked(buf: &[u8]) -> ScalarStuff<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } } pub const SCALAR_STUFF_IDENTIFIER: &str = "NULL"; #[inline] pub fn scalar_stuff_buffer_has_identifier(buf: &[u8]) -> bool { - ::flatbuffers::buffer_has_identifier(buf, SCALAR_STUFF_IDENTIFIER, false) + ::flatbuffers::buffer_has_identifier(buf, SCALAR_STUFF_IDENTIFIER, false) } #[inline] pub fn scalar_stuff_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool { - ::flatbuffers::buffer_has_identifier(buf, SCALAR_STUFF_IDENTIFIER, true) + ::flatbuffers::buffer_has_identifier(buf, SCALAR_STUFF_IDENTIFIER, true) } pub const SCALAR_STUFF_EXTENSION: &str = "mon"; @@ -1101,11 +1101,15 @@ pub const SCALAR_STUFF_EXTENSION: &str = "mon"; #[inline] pub fn finish_scalar_stuff_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>) { - fbb.finish(root, Some(SCALAR_STUFF_IDENTIFIER)); + root: ::flatbuffers::WIPOffset> +) { + fbb.finish(root, Some(SCALAR_STUFF_IDENTIFIER)); } #[inline] -pub fn finish_size_prefixed_scalar_stuff_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset>) { - fbb.finish_size_prefixed(root, Some(SCALAR_STUFF_IDENTIFIER)); +pub fn finish_size_prefixed_scalar_stuff_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset> +) { + fbb.finish_size_prefixed(root, Some(SCALAR_STUFF_IDENTIFIER)); } diff --git a/tests/private_annotation_test/ab_generated.rs b/tests/private_annotation_test/ab_generated.rs index 91310b1db..099893f50 100644 --- a/tests/private_annotation_test/ab_generated.rs +++ b/tests/private_annotation_test/ab_generated.rs @@ -12,8 +12,8 @@ pub const ENUM_MAX_AB: i8 = 1; #[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_AB: [AB; 2] = [ - AB::A, - AB::B, + AB::A, + AB::B, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -22,44 +22,44 @@ pub(crate) struct AB(pub i8); #[allow(non_upper_case_globals)] impl AB { - pub const A: Self = Self(0); - pub const B: Self = Self(1); + pub const A: Self = Self(0); + pub const B: Self = Self(1); - pub const ENUM_MIN: i8 = 0; - pub const ENUM_MAX: i8 = 1; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::A, - Self::B, - ]; + pub const ENUM_MIN: i8 = 0; + pub const ENUM_MAX: i8 = 1; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::A, + Self::B, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::A => Some("A"), - Self::B => Some("B"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::A => Some("A"), + Self::B => Some("B"), + _ => None, + } } - } } impl ::core::fmt::Debug for AB { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 AB { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for AB { @@ -72,28 +72,28 @@ impl ::flatbuffers::Push for AB { } impl ::flatbuffers::EndianScalar for AB { - type Scalar = i8; + type Scalar = i8; - #[inline] - fn to_little_endian(self) -> i8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> i8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: i8) -> Self { - let b = i8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: i8) -> Self { + let b = i8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for AB { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - i8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + i8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for AB {} diff --git a/tests/private_annotation_test/annotations_generated.rs b/tests/private_annotation_test/annotations_generated.rs index ab2039392..3c6a7a758 100644 --- a/tests/private_annotation_test/annotations_generated.rs +++ b/tests/private_annotation_test/annotations_generated.rs @@ -7,66 +7,66 @@ pub(crate) enum AnnotationsOffset {} #[derive(Copy, Clone, PartialEq)] pub(crate) struct Annotations<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Annotations<'a> { - type Inner = Annotations<'a>; + type Inner = Annotations<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Annotations<'a> { - pub const VT_VALUE: ::flatbuffers::VOffsetT = 4; + pub const VT_VALUE: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "Annotations" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - Annotations { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args AnnotationsArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = AnnotationsBuilder::new(_fbb); - builder.add_value(args.value); - builder.finish() - } - - pub fn unpack(&self) -> AnnotationsT { - let value = self.value(); - AnnotationsT { - value, + pub const fn get_fully_qualified_name() -> &'static str { + "Annotations" } - } - #[inline] - pub fn value(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Annotations::VT_VALUE, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Annotations { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args AnnotationsArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = AnnotationsBuilder::new(_fbb); + builder.add_value(args.value); + builder.finish() + } + + pub fn unpack(&self) -> AnnotationsT { + let value = self.value(); + AnnotationsT { + value, + } + } + + #[inline] + pub fn value(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Annotations::VT_VALUE, Some(0)).unwrap()} + } } impl ::flatbuffers::Verifiable for Annotations<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("value", Self::VT_VALUE, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("value", Self::VT_VALUE, false)? + .finish(); + Ok(()) + } } pub(crate) struct AnnotationsArgs { @@ -74,71 +74,71 @@ pub(crate) struct AnnotationsArgs { } impl<'a> Default for AnnotationsArgs { - #[inline] - fn default() -> Self { - AnnotationsArgs { - value: 0, + #[inline] + fn default() -> Self { + AnnotationsArgs { + value: 0, + } } - } } pub(crate) struct AnnotationsBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> AnnotationsBuilder<'a, 'b, A> { - #[inline] - pub fn add_value(&mut self, value: i32) { - self.fbb_.push_slot::(Annotations::VT_VALUE, value, 0); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AnnotationsBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - AnnotationsBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_value(&mut self, value: i32) { + self.fbb_.push_slot::(Annotations::VT_VALUE, value, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AnnotationsBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + AnnotationsBuilder { + 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 ::core::fmt::Debug for Annotations<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Annotations"); - ds.field("value", &self.value()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Annotations"); + ds.field("value", &self.value()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub(crate) struct AnnotationsT { - pub value: i32, + pub value: i32, } impl Default for AnnotationsT { - fn default() -> Self { - Self { - value: 0, + fn default() -> Self { + Self { + value: 0, + } } - } } impl AnnotationsT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let value = self.value; - Annotations::create(_fbb, &AnnotationsArgs{ - value, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let value = self.value; + Annotations::create(_fbb, &AnnotationsArgs{ + value, + }) + } } diff --git a/tests/private_annotation_test/any_generated.rs b/tests/private_annotation_test/any_generated.rs index be353bf47..33f6764ad 100644 --- a/tests/private_annotation_test/any_generated.rs +++ b/tests/private_annotation_test/any_generated.rs @@ -12,9 +12,9 @@ pub const ENUM_MAX_ANY: u8 = 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_ANY: [Any; 3] = [ - Any::NONE, - Any::Game, - Any::Annotations, + Any::NONE, + Any::Game, + Any::Annotations, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -23,47 +23,47 @@ pub(crate) struct Any(pub u8); #[allow(non_upper_case_globals)] impl Any { - pub const NONE: Self = Self(0); - pub const Game: Self = Self(1); - pub const Annotations: Self = Self(2); + pub const NONE: Self = Self(0); + pub const Game: Self = Self(1); + pub const Annotations: Self = Self(2); - pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 2; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::Game, - Self::Annotations, - ]; + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + Self::Game, + Self::Annotations, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - Self::Game => Some("Game"), - Self::Annotations => Some("Annotations"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + Self::Game => Some("Game"), + Self::Annotations => Some("Annotations"), + _ => None, + } } - } } impl ::core::fmt::Debug for Any { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe 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 { @@ -76,28 +76,28 @@ impl ::flatbuffers::Push for Any { } impl ::flatbuffers::EndianScalar for Any { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for Any { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for Any {} @@ -108,80 +108,80 @@ pub(crate) struct AnyUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub(crate) enum AnyT { - NONE, - Game(alloc::boxed::Box), - Annotations(alloc::boxed::Box), + NONE, + Game(alloc::boxed::Box), + Annotations(alloc::boxed::Box), } impl Default for AnyT { - fn default() -> Self { - Self::NONE - } + fn default() -> Self { + Self::NONE + } } impl AnyT { - pub fn any_type(&self) -> Any { - match self { - Self::NONE => Any::NONE, - Self::Game(_) => Any::Game, - Self::Annotations(_) => Any::Annotations, + pub fn any_type(&self) -> Any { + match self { + Self::NONE => Any::NONE, + Self::Game(_) => Any::Game, + Self::Annotations(_) => Any::Annotations, + } } - } - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - match self { - Self::NONE => None, - Self::Game(v) => Some(v.pack(fbb).as_union_value()), - Self::Annotations(v) => Some(v.pack(fbb).as_union_value()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + match self { + Self::NONE => None, + Self::Game(v) => Some(v.pack(fbb).as_union_value()), + Self::Annotations(v) => Some(v.pack(fbb).as_union_value()), + } } - } - /// If the union variant matches, return the owned GameT, setting the union to NONE. - pub fn take_game(&mut self) -> Option> { - if let Self::Game(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::Game(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return the owned GameT, setting the union to NONE. + pub fn take_game(&mut self) -> Option> { + if let Self::Game(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::Game(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } } - } - /// If the union variant matches, return a reference to the GameT. - pub fn as_game(&self) -> Option<&GameT> { - if let Self::Game(v) = self { Some(v.as_ref()) } else { None } - } - - /// If the union variant matches, return a mutable reference to the GameT. - pub fn as_game_mut(&mut self) -> Option<&mut GameT> { - if let Self::Game(v) = self { Some(v.as_mut()) } else { None } - } - - /// If the union variant matches, return the owned AnnotationsT, setting the union to NONE. - pub fn take_annotations(&mut self) -> Option> { - if let Self::Annotations(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::Annotations(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return a reference to the GameT. + pub fn as_game(&self) -> Option<&GameT> { + if let Self::Game(v) = self { Some(v.as_ref()) } else { None } } - } - /// If the union variant matches, return a reference to the AnnotationsT. - pub fn as_annotations(&self) -> Option<&AnnotationsT> { - if let Self::Annotations(v) = self { Some(v.as_ref()) } else { None } - } + /// If the union variant matches, return a mutable reference to the GameT. + pub fn as_game_mut(&mut self) -> Option<&mut GameT> { + if let Self::Game(v) = self { Some(v.as_mut()) } else { None } + } - /// If the union variant matches, return a mutable reference to the AnnotationsT. - pub fn as_annotations_mut(&mut self) -> Option<&mut AnnotationsT> { - if let Self::Annotations(v) = self { Some(v.as_mut()) } else { None } - } + /// If the union variant matches, return the owned AnnotationsT, setting the union to NONE. + pub fn take_annotations(&mut self) -> Option> { + if let Self::Annotations(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::Annotations(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } + } + + /// If the union variant matches, return a reference to the AnnotationsT. + pub fn as_annotations(&self) -> Option<&AnnotationsT> { + if let Self::Annotations(v) = self { Some(v.as_ref()) } else { None } + } + + /// If the union variant matches, return a mutable reference to the AnnotationsT. + pub fn as_annotations_mut(&mut self) -> Option<&mut AnnotationsT> { + if let Self::Annotations(v) = self { Some(v.as_mut()) } else { None } + } } diff --git a/tests/private_annotation_test/game_generated.rs b/tests/private_annotation_test/game_generated.rs index 7fa953b0c..c15574d6a 100644 --- a/tests/private_annotation_test/game_generated.rs +++ b/tests/private_annotation_test/game_generated.rs @@ -7,66 +7,66 @@ pub(crate) enum GameOffset {} #[derive(Copy, Clone, PartialEq)] pub(crate) struct Game<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for Game<'a> { - type Inner = Game<'a>; + type Inner = Game<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> Game<'a> { - pub const VT_VALUE: ::flatbuffers::VOffsetT = 4; + pub const VT_VALUE: ::flatbuffers::VOffsetT = 4; - pub const fn get_fully_qualified_name() -> &'static str { - "Game" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - Game { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args GameArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = GameBuilder::new(_fbb); - builder.add_value(args.value); - builder.finish() - } - - pub fn unpack(&self) -> GameT { - let value = self.value(); - GameT { - value, + pub const fn get_fully_qualified_name() -> &'static str { + "Game" } - } - #[inline] - pub fn value(&self) -> i32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Game::VT_VALUE, Some(0)).unwrap()} - } + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + Game { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args GameArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = GameBuilder::new(_fbb); + builder.add_value(args.value); + builder.finish() + } + + pub fn unpack(&self) -> GameT { + let value = self.value(); + GameT { + value, + } + } + + #[inline] + pub fn value(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Game::VT_VALUE, Some(0)).unwrap()} + } } impl ::flatbuffers::Verifiable for Game<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_field::("value", Self::VT_VALUE, false)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_field::("value", Self::VT_VALUE, false)? + .finish(); + Ok(()) + } } pub(crate) struct GameArgs { @@ -74,71 +74,71 @@ pub(crate) struct GameArgs { } impl<'a> Default for GameArgs { - #[inline] - fn default() -> Self { - GameArgs { - value: 0, + #[inline] + fn default() -> Self { + GameArgs { + value: 0, + } } - } } pub(crate) struct GameBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GameBuilder<'a, 'b, A> { - #[inline] - pub fn add_value(&mut self, value: i32) { - self.fbb_.push_slot::(Game::VT_VALUE, value, 0); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GameBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - GameBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_value(&mut self, value: i32) { + self.fbb_.push_slot::(Game::VT_VALUE, value, 0); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GameBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + GameBuilder { + 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 ::core::fmt::Debug for Game<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("Game"); - ds.field("value", &self.value()); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("Game"); + ds.field("value", &self.value()); + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub(crate) struct GameT { - pub value: i32, + pub value: i32, } impl Default for GameT { - fn default() -> Self { - Self { - value: 0, + fn default() -> Self { + Self { + value: 0, + } } - } } impl GameT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let value = self.value; - Game::create(_fbb, &GameArgs{ - value, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let value = self.value; + Game::create(_fbb, &GameArgs{ + value, + }) + } } diff --git a/tests/private_annotation_test/object_generated.rs b/tests/private_annotation_test/object_generated.rs index 3d5106ddb..07d44cfde 100644 --- a/tests/private_annotation_test/object_generated.rs +++ b/tests/private_annotation_test/object_generated.rs @@ -8,38 +8,38 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub(crate) struct Object(pub [u8; 4]); -impl Default for Object { - fn default() -> Self { - Self([0; 4]) - } +impl Default for Object { + fn default() -> Self { + Self([0; 4]) + } } impl ::core::fmt::Debug for Object { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("Object") - .field("value", &self.value()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("Object") + .field("value", &self.value()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for Object {} impl<'a> ::flatbuffers::Follow<'a> for Object { - type Inner = &'a Object; + type Inner = &'a Object; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a Object>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a Object>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a Object { - type Inner = &'a Object; + type Inner = &'a Object; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for Object { @@ -58,73 +58,73 @@ impl<'b> ::flatbuffers::Push for Object { } impl<'a> ::flatbuffers::Verifiable for Object { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> Object { - #[allow(clippy::too_many_arguments)] - pub fn new( - value: i32, - ) -> Self { - let mut s = Self([0; 4]); - s.set_value(value); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "Object" - } - - pub fn value(&self) -> i32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_value(&mut self, x: i32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + value: i32, + ) -> Self { + let mut s = Self([0; 4]); + s.set_value(value); + s } - } - pub fn unpack(&self) -> ObjectT { - ObjectT { - value: self.value(), + pub const fn get_fully_qualified_name() -> &'static str { + "Object" + } + + pub fn value(&self) -> i32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_value(&mut self, x: i32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> ObjectT { + ObjectT { + value: self.value(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub(crate) struct ObjectT { - pub value: i32, + pub value: i32, } impl ObjectT { - pub fn pack(&self) -> Object { - Object::new( - self.value, - ) - } + pub fn pack(&self) -> Object { + Object::new( + self.value, + ) + } } diff --git a/tests/rust_namer_test/mod.rs b/tests/rust_namer_test/mod.rs index f395a5003..81c761650 100644 --- a/tests/rust_namer_test/mod.rs +++ b/tests/rust_namer_test/mod.rs @@ -1,23 +1,23 @@ // Automatically generated by the Flatbuffers compiler. Do not modify. // @generated pub mod rust_namer_test { - use super::*; - mod field_union_generated; - pub use self::field_union_generated::*; - mod game_message_generated; - pub use self::game_message_generated::*; - mod field_table_generated; - pub use self::field_table_generated::*; - mod root_table_generated; - pub use self::root_table_generated::*; - mod player_stat_event_generated; - pub use self::player_stat_event_generated::*; - mod player_spectate_generated; - pub use self::player_spectate_generated::*; - mod player_input_change_generated; - pub use self::player_input_change_generated::*; - mod game_message_wrapper_generated; - pub use self::game_message_wrapper_generated::*; - mod possibly_reserved_words_generated; - pub use self::possibly_reserved_words_generated::*; + use super::*; + mod field_union_generated; + pub use self::field_union_generated::*; + mod game_message_generated; + pub use self::game_message_generated::*; + mod field_table_generated; + pub use self::field_table_generated::*; + mod root_table_generated; + pub use self::root_table_generated::*; + mod player_stat_event_generated; + pub use self::player_stat_event_generated::*; + mod player_spectate_generated; + pub use self::player_spectate_generated::*; + mod player_input_change_generated; + pub use self::player_input_change_generated::*; + mod game_message_wrapper_generated; + pub use self::game_message_wrapper_generated::*; + mod possibly_reserved_words_generated; + pub use self::possibly_reserved_words_generated::*; } // rust_namer_test diff --git a/tests/rust_namer_test/rust_namer_test/field_table_generated.rs b/tests/rust_namer_test/rust_namer_test/field_table_generated.rs index 88e0da134..5b21b2eb3 100644 --- a/tests/rust_namer_test/rust_namer_test/field_table_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/field_table_generated.rs @@ -7,92 +7,92 @@ pub enum FieldTableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct FieldTable<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for FieldTable<'a> { - type Inner = FieldTable<'a>; + type Inner = FieldTable<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> FieldTable<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "RustNamerTest.FieldTable" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - FieldTable { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args FieldTableArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = FieldTableBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> FieldTableT { - FieldTableT { + pub const fn get_fully_qualified_name() -> &'static str { + "RustNamerTest.FieldTable" + } + + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + FieldTable { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _args: &'args FieldTableArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = FieldTableBuilder::new(_fbb); + builder.finish() + } + + pub fn unpack(&self) -> FieldTableT { + FieldTableT { + } } - } } impl ::flatbuffers::Verifiable for FieldTable<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct FieldTableArgs { } impl<'a> Default for FieldTableArgs { - #[inline] - fn default() -> Self { - FieldTableArgs { + #[inline] + fn default() -> Self { + FieldTableArgs { + } } - } } pub struct FieldTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> FieldTableBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> FieldTableBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - FieldTableBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> FieldTableBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + FieldTableBuilder { + fbb_: _fbb, + start_: start, + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for FieldTable<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("FieldTable"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("FieldTable"); + ds.finish() + } } #[non_exhaustive] @@ -101,18 +101,18 @@ pub struct FieldTableT { } impl Default for FieldTableT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl FieldTableT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - FieldTable::create(_fbb, &FieldTableArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + FieldTable::create(_fbb, &FieldTableArgs{ + }) + } } diff --git a/tests/rust_namer_test/rust_namer_test/field_union_generated.rs b/tests/rust_namer_test/rust_namer_test/field_union_generated.rs index 7bedafe0f..22fa546df 100644 --- a/tests/rust_namer_test/rust_namer_test/field_union_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/field_union_generated.rs @@ -12,8 +12,8 @@ pub const ENUM_MAX_FIELD_UNION: u8 = 1; #[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_FIELD_UNION: [FieldUnion; 2] = [ - FieldUnion::NONE, - FieldUnion::f, + FieldUnion::NONE, + FieldUnion::f, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -22,44 +22,44 @@ pub struct FieldUnion(pub u8); #[allow(non_upper_case_globals)] impl FieldUnion { - pub const NONE: Self = Self(0); - pub const f: Self = Self(1); + pub const NONE: Self = Self(0); + pub const f: Self = Self(1); - pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 1; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::f, - ]; + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 1; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + Self::f, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - Self::f => Some("f"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + Self::f => Some("f"), + _ => None, + } } - } } impl ::core::fmt::Debug for FieldUnion { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 FieldUnion { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for FieldUnion { @@ -72,28 +72,28 @@ impl ::flatbuffers::Push for FieldUnion { } impl ::flatbuffers::EndianScalar for FieldUnion { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for FieldUnion { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for FieldUnion {} @@ -104,53 +104,53 @@ pub struct FieldUnionUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum FieldUnionT { - NONE, - F(alloc::boxed::Box), + NONE, + F(alloc::boxed::Box), } impl Default for FieldUnionT { - fn default() -> Self { - Self::NONE - } + fn default() -> Self { + Self::NONE + } } impl FieldUnionT { - pub fn field_union_type(&self) -> FieldUnion { - match self { - Self::NONE => FieldUnion::NONE, - Self::F(_) => FieldUnion::f, + pub fn field_union_type(&self) -> FieldUnion { + match self { + Self::NONE => FieldUnion::NONE, + Self::F(_) => FieldUnion::f, + } } - } - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - match self { - Self::NONE => None, - Self::F(v) => Some(v.pack(fbb).as_union_value()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + match self { + Self::NONE => None, + Self::F(v) => Some(v.pack(fbb).as_union_value()), + } } - } - /// If the union variant matches, return the owned FieldTableT, setting the union to NONE. - pub fn take_f(&mut self) -> Option> { - if let Self::F(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::F(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return the owned FieldTableT, setting the union to NONE. + pub fn take_f(&mut self) -> Option> { + if let Self::F(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::F(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } } - } - /// If the union variant matches, return a reference to the FieldTableT. - pub fn as_f(&self) -> Option<&FieldTableT> { - if let Self::F(v) = self { Some(v.as_ref()) } else { None } - } + /// If the union variant matches, return a reference to the FieldTableT. + pub fn as_f(&self) -> Option<&FieldTableT> { + if let Self::F(v) = self { Some(v.as_ref()) } else { None } + } - /// If the union variant matches, return a mutable reference to the FieldTableT. - pub fn as_f_mut(&mut self) -> Option<&mut FieldTableT> { - if let Self::F(v) = self { Some(v.as_mut()) } else { None } - } + /// If the union variant matches, return a mutable reference to the FieldTableT. + pub fn as_f_mut(&mut self) -> Option<&mut FieldTableT> { + if let Self::F(v) = self { Some(v.as_mut()) } else { None } + } } diff --git a/tests/rust_namer_test/rust_namer_test/game_message_generated.rs b/tests/rust_namer_test/rust_namer_test/game_message_generated.rs index 5d4dc4810..563cdcd87 100644 --- a/tests/rust_namer_test/rust_namer_test/game_message_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/game_message_generated.rs @@ -12,10 +12,10 @@ pub const ENUM_MAX_GAME_MESSAGE: 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_GAME_MESSAGE: [GameMessage; 4] = [ - GameMessage::NONE, - GameMessage::PlayerStatEvent, - GameMessage::PlayerSpectate, - GameMessage::PlayerInputChange, + GameMessage::NONE, + GameMessage::PlayerStatEvent, + GameMessage::PlayerSpectate, + GameMessage::PlayerInputChange, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -24,50 +24,50 @@ pub struct GameMessage(pub u8); #[allow(non_upper_case_globals)] impl GameMessage { - pub const NONE: Self = Self(0); - pub const PlayerStatEvent: Self = Self(1); - pub const PlayerSpectate: Self = Self(2); - pub const PlayerInputChange: Self = Self(3); + pub const NONE: Self = Self(0); + pub const PlayerStatEvent: Self = Self(1); + pub const PlayerSpectate: Self = Self(2); + pub const PlayerInputChange: Self = Self(3); - pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 3; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::PlayerStatEvent, - Self::PlayerSpectate, - Self::PlayerInputChange, - ]; + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 3; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + Self::PlayerStatEvent, + Self::PlayerSpectate, + Self::PlayerInputChange, + ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - Self::PlayerStatEvent => Some("PlayerStatEvent"), - Self::PlayerSpectate => Some("PlayerSpectate"), - Self::PlayerInputChange => Some("PlayerInputChange"), - _ => None, + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + Self::PlayerStatEvent => Some("PlayerStatEvent"), + Self::PlayerSpectate => Some("PlayerSpectate"), + Self::PlayerInputChange => Some("PlayerInputChange"), + _ => None, + } } - } } impl ::core::fmt::Debug for GameMessage { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::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 GameMessage { - type Inner = Self; + type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; - Self(b) - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + Self(b) + } } impl ::flatbuffers::Push for GameMessage { @@ -80,28 +80,28 @@ impl ::flatbuffers::Push for GameMessage { } impl ::flatbuffers::EndianScalar for GameMessage { - type Scalar = u8; + type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } } impl<'a> ::flatbuffers::Verifiable for GameMessage { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - u8::run_verifier(v, pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + u8::run_verifier(v, pos) + } } impl ::flatbuffers::SimpleToVerifyInSlice for GameMessage {} @@ -112,107 +112,107 @@ pub struct GameMessageUnionTableOffset {} #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum GameMessageT { - NONE, - PlayerStatEvent(alloc::boxed::Box), - PlayerSpectate(alloc::boxed::Box), - PlayerInputChange(alloc::boxed::Box), + NONE, + PlayerStatEvent(alloc::boxed::Box), + PlayerSpectate(alloc::boxed::Box), + PlayerInputChange(alloc::boxed::Box), } impl Default for GameMessageT { - fn default() -> Self { - Self::NONE - } + fn default() -> Self { + Self::NONE + } } impl GameMessageT { - pub fn game_message_type(&self) -> GameMessage { - match self { - Self::NONE => GameMessage::NONE, - Self::PlayerStatEvent(_) => GameMessage::PlayerStatEvent, - Self::PlayerSpectate(_) => GameMessage::PlayerSpectate, - Self::PlayerInputChange(_) => GameMessage::PlayerInputChange, + pub fn game_message_type(&self) -> GameMessage { + match self { + Self::NONE => GameMessage::NONE, + Self::PlayerStatEvent(_) => GameMessage::PlayerStatEvent, + Self::PlayerSpectate(_) => GameMessage::PlayerSpectate, + Self::PlayerInputChange(_) => GameMessage::PlayerInputChange, + } } - } - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { - match self { - Self::NONE => None, - Self::PlayerStatEvent(v) => Some(v.pack(fbb).as_union_value()), - Self::PlayerSpectate(v) => Some(v.pack(fbb).as_union_value()), - Self::PlayerInputChange(v) => Some(v.pack(fbb).as_union_value()), + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> { + match self { + Self::NONE => None, + Self::PlayerStatEvent(v) => Some(v.pack(fbb).as_union_value()), + Self::PlayerSpectate(v) => Some(v.pack(fbb).as_union_value()), + Self::PlayerInputChange(v) => Some(v.pack(fbb).as_union_value()), + } } - } - /// If the union variant matches, return the owned PlayerStatEventT, setting the union to NONE. - pub fn take_player_stat_event(&mut self) -> Option> { - if let Self::PlayerStatEvent(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::PlayerStatEvent(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return the owned PlayerStatEventT, setting the union to NONE. + pub fn take_player_stat_event(&mut self) -> Option> { + if let Self::PlayerStatEvent(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::PlayerStatEvent(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } } - } - /// If the union variant matches, return a reference to the PlayerStatEventT. - pub fn as_player_stat_event(&self) -> Option<&PlayerStatEventT> { - if let Self::PlayerStatEvent(v) = self { Some(v.as_ref()) } else { None } - } - - /// If the union variant matches, return a mutable reference to the PlayerStatEventT. - pub fn as_player_stat_event_mut(&mut self) -> Option<&mut PlayerStatEventT> { - if let Self::PlayerStatEvent(v) = self { Some(v.as_mut()) } else { None } - } - - /// If the union variant matches, return the owned PlayerSpectateT, setting the union to NONE. - pub fn take_player_spectate(&mut self) -> Option> { - if let Self::PlayerSpectate(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::PlayerSpectate(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return a reference to the PlayerStatEventT. + pub fn as_player_stat_event(&self) -> Option<&PlayerStatEventT> { + if let Self::PlayerStatEvent(v) = self { Some(v.as_ref()) } else { None } } - } - /// If the union variant matches, return a reference to the PlayerSpectateT. - pub fn as_player_spectate(&self) -> Option<&PlayerSpectateT> { - if let Self::PlayerSpectate(v) = self { Some(v.as_ref()) } else { None } - } - - /// If the union variant matches, return a mutable reference to the PlayerSpectateT. - pub fn as_player_spectate_mut(&mut self) -> Option<&mut PlayerSpectateT> { - if let Self::PlayerSpectate(v) = self { Some(v.as_mut()) } else { None } - } - - /// If the union variant matches, return the owned PlayerInputChangeT, setting the union to NONE. - pub fn take_player_input_change(&mut self) -> Option> { - if let Self::PlayerInputChange(_) = self { - let v = ::core::mem::replace(self, Self::NONE); - if let Self::PlayerInputChange(w) = v { - Some(w) - } else { - unreachable!() - } - } else { - None + /// If the union variant matches, return a mutable reference to the PlayerStatEventT. + pub fn as_player_stat_event_mut(&mut self) -> Option<&mut PlayerStatEventT> { + if let Self::PlayerStatEvent(v) = self { Some(v.as_mut()) } else { None } } - } - /// If the union variant matches, return a reference to the PlayerInputChangeT. - pub fn as_player_input_change(&self) -> Option<&PlayerInputChangeT> { - if let Self::PlayerInputChange(v) = self { Some(v.as_ref()) } else { None } - } + /// If the union variant matches, return the owned PlayerSpectateT, setting the union to NONE. + pub fn take_player_spectate(&mut self) -> Option> { + if let Self::PlayerSpectate(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::PlayerSpectate(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } + } - /// If the union variant matches, return a mutable reference to the PlayerInputChangeT. - pub fn as_player_input_change_mut(&mut self) -> Option<&mut PlayerInputChangeT> { - if let Self::PlayerInputChange(v) = self { Some(v.as_mut()) } else { None } - } + /// If the union variant matches, return a reference to the PlayerSpectateT. + pub fn as_player_spectate(&self) -> Option<&PlayerSpectateT> { + if let Self::PlayerSpectate(v) = self { Some(v.as_ref()) } else { None } + } + + /// If the union variant matches, return a mutable reference to the PlayerSpectateT. + pub fn as_player_spectate_mut(&mut self) -> Option<&mut PlayerSpectateT> { + if let Self::PlayerSpectate(v) = self { Some(v.as_mut()) } else { None } + } + + /// If the union variant matches, return the owned PlayerInputChangeT, setting the union to NONE. + pub fn take_player_input_change(&mut self) -> Option> { + if let Self::PlayerInputChange(_) = self { + let v = ::core::mem::replace(self, Self::NONE); + if let Self::PlayerInputChange(w) = v { + Some(w) + } else { + unreachable!() + } + } else { + None + } + } + + /// If the union variant matches, return a reference to the PlayerInputChangeT. + pub fn as_player_input_change(&self) -> Option<&PlayerInputChangeT> { + if let Self::PlayerInputChange(v) = self { Some(v.as_ref()) } else { None } + } + + /// If the union variant matches, return a mutable reference to the PlayerInputChangeT. + pub fn as_player_input_change_mut(&mut self) -> Option<&mut PlayerInputChangeT> { + if let Self::PlayerInputChange(v) = self { Some(v.as_mut()) } else { None } + } } diff --git a/tests/rust_namer_test/rust_namer_test/game_message_wrapper_generated.rs b/tests/rust_namer_test/rust_namer_test/game_message_wrapper_generated.rs index 6132c77e3..a72cbc539 100644 --- a/tests/rust_namer_test/rust_namer_test/game_message_wrapper_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/game_message_wrapper_generated.rs @@ -7,146 +7,146 @@ pub enum GameMessageWrapperOffset {} #[derive(Copy, Clone, PartialEq)] pub struct GameMessageWrapper<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for GameMessageWrapper<'a> { - type Inner = GameMessageWrapper<'a>; + type Inner = GameMessageWrapper<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> GameMessageWrapper<'a> { - pub const VT_MESSAGE_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 6; + pub const VT_MESSAGE_TYPE: ::flatbuffers::VOffsetT = 4; + pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 6; - pub const fn get_fully_qualified_name() -> &'static str { - "RustNamerTest.GameMessageWrapper" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - GameMessageWrapper { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args GameMessageWrapperArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = GameMessageWrapperBuilder::new(_fbb); - if let Some(x) = args.Message { builder.add_Message(x); } - builder.add_Message_type(args.Message_type); - builder.finish() - } - - pub fn unpack(&self) -> GameMessageWrapperT { - let Message = match self.Message_type() { - GameMessage::NONE => GameMessageT::NONE, - GameMessage::PlayerStatEvent => GameMessageT::PlayerStatEvent(alloc::boxed::Box::new( - self.Message_as_player_stat_event() - .expect("Invalid union table, expected `GameMessage::PlayerStatEvent`.") - .unpack() - )), - GameMessage::PlayerSpectate => GameMessageT::PlayerSpectate(alloc::boxed::Box::new( - self.Message_as_player_spectate() - .expect("Invalid union table, expected `GameMessage::PlayerSpectate`.") - .unpack() - )), - GameMessage::PlayerInputChange => GameMessageT::PlayerInputChange(alloc::boxed::Box::new( - self.Message_as_player_input_change() - .expect("Invalid union table, expected `GameMessage::PlayerInputChange`.") - .unpack() - )), - _ => GameMessageT::NONE, - }; - GameMessageWrapperT { - Message, + pub const fn get_fully_qualified_name() -> &'static str { + "RustNamerTest.GameMessageWrapper" } - } - #[inline] - pub fn Message_type(&self) -> GameMessage { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(GameMessageWrapper::VT_MESSAGE_TYPE, Some(GameMessage::NONE)).unwrap()} - } - - #[inline] - pub fn Message(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(GameMessageWrapper::VT_MESSAGE, None)} - } - - #[inline] - #[allow(non_snake_case)] - pub fn Message_as_player_stat_event(&self) -> Option> { - if self.Message_type() == GameMessage::PlayerStatEvent { - self.Message().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { PlayerStatEvent::init_from_table(t) } - }) - } else { - None + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + GameMessageWrapper { _tab: table } } - } - #[inline] - #[allow(non_snake_case)] - pub fn Message_as_player_spectate(&self) -> Option> { - if self.Message_type() == GameMessage::PlayerSpectate { - self.Message().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { PlayerSpectate::init_from_table(t) } - }) - } else { - None + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args GameMessageWrapperArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = GameMessageWrapperBuilder::new(_fbb); + if let Some(x) = args.Message { builder.add_Message(x); } + builder.add_Message_type(args.Message_type); + builder.finish() } - } - #[inline] - #[allow(non_snake_case)] - pub fn Message_as_player_input_change(&self) -> Option> { - if self.Message_type() == GameMessage::PlayerInputChange { - self.Message().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { PlayerInputChange::init_from_table(t) } - }) - } else { - None + pub fn unpack(&self) -> GameMessageWrapperT { + let Message = match self.Message_type() { + GameMessage::NONE => GameMessageT::NONE, + GameMessage::PlayerStatEvent => GameMessageT::PlayerStatEvent(alloc::boxed::Box::new( + self.Message_as_player_stat_event() + .expect("Invalid union table, expected `GameMessage::PlayerStatEvent`.") + .unpack() + )), + GameMessage::PlayerSpectate => GameMessageT::PlayerSpectate(alloc::boxed::Box::new( + self.Message_as_player_spectate() + .expect("Invalid union table, expected `GameMessage::PlayerSpectate`.") + .unpack() + )), + GameMessage::PlayerInputChange => GameMessageT::PlayerInputChange(alloc::boxed::Box::new( + self.Message_as_player_input_change() + .expect("Invalid union table, expected `GameMessage::PlayerInputChange`.") + .unpack() + )), + _ => GameMessageT::NONE, + }; + GameMessageWrapperT { + Message, + } + } + + #[inline] + pub fn Message_type(&self) -> GameMessage { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(GameMessageWrapper::VT_MESSAGE_TYPE, Some(GameMessage::NONE)).unwrap()} + } + + #[inline] + pub fn Message(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(GameMessageWrapper::VT_MESSAGE, None)} + } + + #[inline] + #[allow(non_snake_case)] + pub fn Message_as_player_stat_event(&self) -> Option> { + if self.Message_type() == GameMessage::PlayerStatEvent { + self.Message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { PlayerStatEvent::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn Message_as_player_spectate(&self) -> Option> { + if self.Message_type() == GameMessage::PlayerSpectate { + self.Message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { PlayerSpectate::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn Message_as_player_input_change(&self) -> Option> { + if self.Message_type() == GameMessage::PlayerInputChange { + self.Message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { PlayerInputChange::init_from_table(t) } + }) + } else { + None + } } - } } impl ::flatbuffers::Verifiable for GameMessageWrapper<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_union::("Message_type", Self::VT_MESSAGE_TYPE, "Message", Self::VT_MESSAGE, false, |key, v, pos| { - match key { - GameMessage::PlayerStatEvent => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("GameMessage::PlayerStatEvent", pos), - GameMessage::PlayerSpectate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("GameMessage::PlayerSpectate", pos), - GameMessage::PlayerInputChange => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("GameMessage::PlayerInputChange", pos), - _ => Ok(()), - } - })? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_union::("Message_type", Self::VT_MESSAGE_TYPE, "Message", Self::VT_MESSAGE, false, |key, v, pos| { + match key { + GameMessage::PlayerStatEvent => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("GameMessage::PlayerStatEvent", pos), + GameMessage::PlayerSpectate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("GameMessage::PlayerSpectate", pos), + GameMessage::PlayerInputChange => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("GameMessage::PlayerInputChange", pos), + _ => Ok(()), + } + })? + .finish(); + Ok(()) + } } pub struct GameMessageWrapperArgs { @@ -155,106 +155,106 @@ pub struct GameMessageWrapperArgs { } impl<'a> Default for GameMessageWrapperArgs { - #[inline] - fn default() -> Self { - GameMessageWrapperArgs { - Message_type: GameMessage::NONE, - Message: None, + #[inline] + fn default() -> Self { + GameMessageWrapperArgs { + Message_type: GameMessage::NONE, + Message: None, + } } - } } pub struct GameMessageWrapperBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GameMessageWrapperBuilder<'a, 'b, A> { - #[inline] - pub fn add_Message_type(&mut self, Message_type: GameMessage) { - self.fbb_.push_slot::(GameMessageWrapper::VT_MESSAGE_TYPE, Message_type, GameMessage::NONE); - } - - #[inline] - pub fn add_Message(&mut self, Message: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(GameMessageWrapper::VT_MESSAGE, Message); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GameMessageWrapperBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - GameMessageWrapperBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_Message_type(&mut self, Message_type: GameMessage) { + self.fbb_.push_slot::(GameMessageWrapper::VT_MESSAGE_TYPE, Message_type, GameMessage::NONE); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_Message(&mut self, Message: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(GameMessageWrapper::VT_MESSAGE, Message); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GameMessageWrapperBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + GameMessageWrapperBuilder { + 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 ::core::fmt::Debug for GameMessageWrapper<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("GameMessageWrapper"); - ds.field("Message_type", &self.Message_type()); - match self.Message_type() { - GameMessage::PlayerStatEvent => { - if let Some(x) = self.Message_as_player_stat_event() { - ds.field("Message", &x) - } else { - ds.field("Message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - GameMessage::PlayerSpectate => { - if let Some(x) = self.Message_as_player_spectate() { - ds.field("Message", &x) - } else { - ds.field("Message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - GameMessage::PlayerInputChange => { - if let Some(x) = self.Message_as_player_input_change() { - ds.field("Message", &x) - } else { - ds.field("Message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("Message", &x) - }, - }; - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("GameMessageWrapper"); + ds.field("Message_type", &self.Message_type()); + match self.Message_type() { + GameMessage::PlayerStatEvent => { + if let Some(x) = self.Message_as_player_stat_event() { + ds.field("Message", &x) + } else { + ds.field("Message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + GameMessage::PlayerSpectate => { + if let Some(x) = self.Message_as_player_spectate() { + ds.field("Message", &x) + } else { + ds.field("Message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + GameMessage::PlayerInputChange => { + if let Some(x) = self.Message_as_player_input_change() { + ds.field("Message", &x) + } else { + ds.field("Message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + _ => { + let x: Option<()> = None; + ds.field("Message", &x) + }, + }; + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct GameMessageWrapperT { - pub Message: GameMessageT, + pub Message: GameMessageT, } impl Default for GameMessageWrapperT { - fn default() -> Self { - Self { - Message: GameMessageT::NONE, + fn default() -> Self { + Self { + Message: GameMessageT::NONE, + } } - } } impl GameMessageWrapperT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let Message_type = self.Message.game_message_type(); - let Message = self.Message.pack(_fbb); - GameMessageWrapper::create(_fbb, &GameMessageWrapperArgs{ - Message_type, - Message, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let Message_type = self.Message.game_message_type(); + let Message = self.Message.pack(_fbb); + GameMessageWrapper::create(_fbb, &GameMessageWrapperArgs{ + Message_type, + Message, + }) + } } diff --git a/tests/rust_namer_test/rust_namer_test/player_input_change_generated.rs b/tests/rust_namer_test/rust_namer_test/player_input_change_generated.rs index 75fb6e4f6..ede5f7fd6 100644 --- a/tests/rust_namer_test/rust_namer_test/player_input_change_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/player_input_change_generated.rs @@ -7,92 +7,92 @@ pub enum PlayerInputChangeOffset {} #[derive(Copy, Clone, PartialEq)] pub struct PlayerInputChange<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for PlayerInputChange<'a> { - type Inner = PlayerInputChange<'a>; + type Inner = PlayerInputChange<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> PlayerInputChange<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "RustNamerTest.PlayerInputChange" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - PlayerInputChange { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args PlayerInputChangeArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = PlayerInputChangeBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> PlayerInputChangeT { - PlayerInputChangeT { + pub const fn get_fully_qualified_name() -> &'static str { + "RustNamerTest.PlayerInputChange" + } + + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + PlayerInputChange { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _args: &'args PlayerInputChangeArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = PlayerInputChangeBuilder::new(_fbb); + builder.finish() + } + + pub fn unpack(&self) -> PlayerInputChangeT { + PlayerInputChangeT { + } } - } } impl ::flatbuffers::Verifiable for PlayerInputChange<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct PlayerInputChangeArgs { } impl<'a> Default for PlayerInputChangeArgs { - #[inline] - fn default() -> Self { - PlayerInputChangeArgs { + #[inline] + fn default() -> Self { + PlayerInputChangeArgs { + } } - } } pub struct PlayerInputChangeBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PlayerInputChangeBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerInputChangeBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - PlayerInputChangeBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerInputChangeBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + PlayerInputChangeBuilder { + fbb_: _fbb, + start_: start, + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for PlayerInputChange<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("PlayerInputChange"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("PlayerInputChange"); + ds.finish() + } } #[non_exhaustive] @@ -101,18 +101,18 @@ pub struct PlayerInputChangeT { } impl Default for PlayerInputChangeT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl PlayerInputChangeT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - PlayerInputChange::create(_fbb, &PlayerInputChangeArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + PlayerInputChange::create(_fbb, &PlayerInputChangeArgs{ + }) + } } diff --git a/tests/rust_namer_test/rust_namer_test/player_spectate_generated.rs b/tests/rust_namer_test/rust_namer_test/player_spectate_generated.rs index df9fbd9be..13b9de44c 100644 --- a/tests/rust_namer_test/rust_namer_test/player_spectate_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/player_spectate_generated.rs @@ -7,92 +7,92 @@ pub enum PlayerSpectateOffset {} #[derive(Copy, Clone, PartialEq)] pub struct PlayerSpectate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for PlayerSpectate<'a> { - type Inner = PlayerSpectate<'a>; + type Inner = PlayerSpectate<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> PlayerSpectate<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "RustNamerTest.PlayerSpectate" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - PlayerSpectate { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args PlayerSpectateArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = PlayerSpectateBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> PlayerSpectateT { - PlayerSpectateT { + pub const fn get_fully_qualified_name() -> &'static str { + "RustNamerTest.PlayerSpectate" + } + + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + PlayerSpectate { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _args: &'args PlayerSpectateArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = PlayerSpectateBuilder::new(_fbb); + builder.finish() + } + + pub fn unpack(&self) -> PlayerSpectateT { + PlayerSpectateT { + } } - } } impl ::flatbuffers::Verifiable for PlayerSpectate<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct PlayerSpectateArgs { } impl<'a> Default for PlayerSpectateArgs { - #[inline] - fn default() -> Self { - PlayerSpectateArgs { + #[inline] + fn default() -> Self { + PlayerSpectateArgs { + } } - } } pub struct PlayerSpectateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PlayerSpectateBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerSpectateBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - PlayerSpectateBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerSpectateBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + PlayerSpectateBuilder { + fbb_: _fbb, + start_: start, + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for PlayerSpectate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("PlayerSpectate"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("PlayerSpectate"); + ds.finish() + } } #[non_exhaustive] @@ -101,18 +101,18 @@ pub struct PlayerSpectateT { } impl Default for PlayerSpectateT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl PlayerSpectateT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - PlayerSpectate::create(_fbb, &PlayerSpectateArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + PlayerSpectate::create(_fbb, &PlayerSpectateArgs{ + }) + } } diff --git a/tests/rust_namer_test/rust_namer_test/player_stat_event_generated.rs b/tests/rust_namer_test/rust_namer_test/player_stat_event_generated.rs index 4ed80f0af..ba57cc239 100644 --- a/tests/rust_namer_test/rust_namer_test/player_stat_event_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/player_stat_event_generated.rs @@ -7,92 +7,92 @@ pub enum PlayerStatEventOffset {} #[derive(Copy, Clone, PartialEq)] pub struct PlayerStatEvent<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for PlayerStatEvent<'a> { - type Inner = PlayerStatEvent<'a>; + type Inner = PlayerStatEvent<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> PlayerStatEvent<'a> { - pub const fn get_fully_qualified_name() -> &'static str { - "RustNamerTest.PlayerStatEvent" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - PlayerStatEvent { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - _args: &'args PlayerStatEventArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = PlayerStatEventBuilder::new(_fbb); - builder.finish() - } - - pub fn unpack(&self) -> PlayerStatEventT { - PlayerStatEventT { + pub const fn get_fully_qualified_name() -> &'static str { + "RustNamerTest.PlayerStatEvent" + } + + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + PlayerStatEvent { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _args: &'args PlayerStatEventArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = PlayerStatEventBuilder::new(_fbb); + builder.finish() + } + + pub fn unpack(&self) -> PlayerStatEventT { + PlayerStatEventT { + } } - } } impl ::flatbuffers::Verifiable for PlayerStatEvent<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .finish(); + Ok(()) + } } pub struct PlayerStatEventArgs { } impl<'a> Default for PlayerStatEventArgs { - #[inline] - fn default() -> Self { - PlayerStatEventArgs { + #[inline] + fn default() -> Self { + PlayerStatEventArgs { + } } - } } pub struct PlayerStatEventBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PlayerStatEventBuilder<'a, 'b, A> { - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerStatEventBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - PlayerStatEventBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PlayerStatEventBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + PlayerStatEventBuilder { + fbb_: _fbb, + start_: start, + } } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn finish(self) -> ::flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + ::flatbuffers::WIPOffset::new(o.value()) + } } impl ::core::fmt::Debug for PlayerStatEvent<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("PlayerStatEvent"); - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("PlayerStatEvent"); + ds.finish() + } } #[non_exhaustive] @@ -101,18 +101,18 @@ pub struct PlayerStatEventT { } impl Default for PlayerStatEventT { - fn default() -> Self { - Self { + fn default() -> Self { + Self { + } } - } } impl PlayerStatEventT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - PlayerStatEvent::create(_fbb, &PlayerStatEventArgs{ - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + PlayerStatEvent::create(_fbb, &PlayerStatEventArgs{ + }) + } } diff --git a/tests/rust_namer_test/rust_namer_test/possibly_reserved_words_generated.rs b/tests/rust_namer_test/rust_namer_test/possibly_reserved_words_generated.rs index bff14ad2c..36bdc38f4 100644 --- a/tests/rust_namer_test/rust_namer_test/possibly_reserved_words_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/possibly_reserved_words_generated.rs @@ -8,41 +8,41 @@ use super::*; #[derive(Clone, Copy, PartialEq)] pub struct PossiblyReservedWords(pub [u8; 16]); -impl Default for PossiblyReservedWords { - fn default() -> Self { - Self([0; 16]) - } +impl Default for PossiblyReservedWords { + fn default() -> Self { + Self([0; 16]) + } } impl ::core::fmt::Debug for PossiblyReservedWords { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - f.debug_struct("PossiblyReservedWords") - .field("follow_", &self.follow_()) - .field("push_", &self.push_()) - .field("size", &self.size()) - .field("alignment", &self.alignment()) - .finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + f.debug_struct("PossiblyReservedWords") + .field("follow_", &self.follow_()) + .field("push_", &self.push_()) + .field("size", &self.size()) + .field("alignment", &self.alignment()) + .finish() + } } impl ::flatbuffers::SimpleToVerifyInSlice for PossiblyReservedWords {} impl<'a> ::flatbuffers::Follow<'a> for PossiblyReservedWords { - type Inner = &'a PossiblyReservedWords; + type Inner = &'a PossiblyReservedWords; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { <&'a PossiblyReservedWords>::follow(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { <&'a PossiblyReservedWords>::follow(buf, loc) } + } } impl<'a> ::flatbuffers::Follow<'a> for &'a PossiblyReservedWords { - type Inner = &'a PossiblyReservedWords; + type Inner = &'a PossiblyReservedWords; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + unsafe { ::flatbuffers::follow_cast_ref::(buf, loc) } + } } impl<'b> ::flatbuffers::Push for PossiblyReservedWords { @@ -61,175 +61,175 @@ impl<'b> ::flatbuffers::Push for PossiblyReservedWords { } impl<'a> ::flatbuffers::Verifiable for PossiblyReservedWords { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.in_buffer::(pos) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.in_buffer::(pos) + } } impl<'a> PossiblyReservedWords { - #[allow(clippy::too_many_arguments)] - pub fn new( - follow_: f32, - push_: f32, - size: f32, - alignment: f32, - ) -> Self { - let mut s = Self([0; 16]); - s.set_follow_(follow_); - s.set_push_(push_); - s.set_size(size); - s.set_alignment(alignment); - s - } - - pub const fn get_fully_qualified_name() -> &'static str { - "RustNamerTest.PossiblyReservedWords" - } - - pub fn follow_(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_follow_(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + #[allow(clippy::too_many_arguments)] + pub fn new( + follow_: f32, + push_: f32, + size: f32, + alignment: f32, + ) -> Self { + let mut s = Self([0; 16]); + s.set_follow_(follow_); + s.set_push_(push_); + s.set_size(size); + s.set_alignment(alignment); + s } - } - pub fn push_(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[4..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_push_(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[4..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub const fn get_fully_qualified_name() -> &'static str { + "RustNamerTest.PossiblyReservedWords" } - } - pub fn size(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[8..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_size(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[8..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn follow_(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[0..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) } - } - pub fn alignment(&self) -> f32 { - let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - ::flatbuffers::EndianScalar::from_little_endian(unsafe { - ::core::ptr::copy_nonoverlapping( - self.0[12..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - ::core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_alignment(&mut self, x: f32) { - let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - ::core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[12..].as_mut_ptr(), - ::core::mem::size_of::<::Scalar>(), - ); + pub fn set_follow_(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[0..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } } - } - pub fn unpack(&self) -> PossiblyReservedWordsT { - PossiblyReservedWordsT { - follow_: self.follow_(), - push_: self.push_(), - size: self.size(), - alignment: self.alignment(), + pub fn push_(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[4..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_push_(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[4..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn size(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[8..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_size(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[8..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn alignment(&self) -> f32 { + let mut mem = ::core::mem::MaybeUninit::<::Scalar>::uninit(); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + ::flatbuffers::EndianScalar::from_little_endian(unsafe { + ::core::ptr::copy_nonoverlapping( + self.0[12..].as_ptr(), + mem.as_mut_ptr() as *mut u8, + ::core::mem::size_of::<::Scalar>(), + ); + mem.assume_init() + }) + } + + pub fn set_alignment(&mut self, x: f32) { + let x_le = ::flatbuffers::EndianScalar::to_little_endian(x); + // Safety: + // Created from a valid Table for this object + // Which contains a valid value in this slot + unsafe { + ::core::ptr::copy_nonoverlapping( + &x_le as *const _ as *const u8, + self.0[12..].as_mut_ptr(), + ::core::mem::size_of::<::Scalar>(), + ); + } + } + + pub fn unpack(&self) -> PossiblyReservedWordsT { + PossiblyReservedWordsT { + follow_: self.follow_(), + push_: self.push_(), + size: self.size(), + alignment: self.alignment(), + } } - } } #[derive(Debug, Clone, PartialEq, Default)] pub struct PossiblyReservedWordsT { - pub follow_: f32, - pub push_: f32, - pub size: f32, - pub alignment: f32, + pub follow_: f32, + pub push_: f32, + pub size: f32, + pub alignment: f32, } impl PossiblyReservedWordsT { - pub fn pack(&self) -> PossiblyReservedWords { - PossiblyReservedWords::new( - self.follow_, - self.push_, - self.size, - self.alignment, - ) - } + pub fn pack(&self) -> PossiblyReservedWords { + PossiblyReservedWords::new( + self.follow_, + self.push_, + self.size, + self.alignment, + ) + } } diff --git a/tests/rust_namer_test/rust_namer_test/root_table_generated.rs b/tests/rust_namer_test/rust_namer_test/root_table_generated.rs index 7677de092..0ff2e5c63 100644 --- a/tests/rust_namer_test/rust_namer_test/root_table_generated.rs +++ b/tests/rust_namer_test/rust_namer_test/root_table_generated.rs @@ -7,104 +7,104 @@ pub enum RootTableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct RootTable<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } impl<'a> ::flatbuffers::Follow<'a> for RootTable<'a> { - type Inner = RootTable<'a>; + type Inner = RootTable<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } - } + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } } + } } impl<'a> RootTable<'a> { - pub const VT_FIELD42_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_FIELD42: ::flatbuffers::VOffsetT = 6; + pub const VT_FIELD42_TYPE: ::flatbuffers::VOffsetT = 4; + pub const VT_FIELD42: ::flatbuffers::VOffsetT = 6; - pub const fn get_fully_qualified_name() -> &'static str { - "RustNamerTest.RootTable" - } - - #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { - RootTable { _tab: table } - } - - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, - args: &'args RootTableArgs - ) -> ::flatbuffers::WIPOffset> { - let mut builder = RootTableBuilder::new(_fbb); - if let Some(x) = args.field42 { builder.add_field42(x); } - builder.add_field42_type(args.field42_type); - builder.finish() - } - - pub fn unpack(&self) -> RootTableT { - let field42 = match self.field42_type() { - FieldUnion::NONE => FieldUnionT::NONE, - FieldUnion::f => FieldUnionT::F(alloc::boxed::Box::new( - self.field42_as_f() - .expect("Invalid union table, expected `FieldUnion::f`.") - .unpack() - )), - _ => FieldUnionT::NONE, - }; - RootTableT { - field42, + pub const fn get_fully_qualified_name() -> &'static str { + "RustNamerTest.RootTable" } - } - #[inline] - pub fn field42_type(&self) -> FieldUnion { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(RootTable::VT_FIELD42_TYPE, Some(FieldUnion::NONE)).unwrap()} - } - - #[inline] - pub fn field42(&self) -> Option<::flatbuffers::Table<'a>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(RootTable::VT_FIELD42, None)} - } - - #[inline] - #[allow(non_snake_case)] - pub fn field42_as_f(&self) -> Option> { - if self.field42_type() == FieldUnion::f { - self.field42().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { FieldTable::init_from_table(t) } - }) - } else { - None + #[inline] + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + RootTable { _tab: table } + } + + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + args: &'args RootTableArgs + ) -> ::flatbuffers::WIPOffset> { + let mut builder = RootTableBuilder::new(_fbb); + if let Some(x) = args.field42 { builder.add_field42(x); } + builder.add_field42_type(args.field42_type); + builder.finish() + } + + pub fn unpack(&self) -> RootTableT { + let field42 = match self.field42_type() { + FieldUnion::NONE => FieldUnionT::NONE, + FieldUnion::f => FieldUnionT::F(alloc::boxed::Box::new( + self.field42_as_f() + .expect("Invalid union table, expected `FieldUnion::f`.") + .unpack() + )), + _ => FieldUnionT::NONE, + }; + RootTableT { + field42, + } + } + + #[inline] + pub fn field42_type(&self) -> FieldUnion { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(RootTable::VT_FIELD42_TYPE, Some(FieldUnion::NONE)).unwrap()} + } + + #[inline] + pub fn field42(&self) -> Option<::flatbuffers::Table<'a>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(RootTable::VT_FIELD42, None)} + } + + #[inline] + #[allow(non_snake_case)] + pub fn field42_as_f(&self) -> Option> { + if self.field42_type() == FieldUnion::f { + self.field42().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { FieldTable::init_from_table(t) } + }) + } else { + None + } } - } } impl ::flatbuffers::Verifiable for RootTable<'_> { - #[inline] - fn run_verifier( - v: &mut ::flatbuffers::Verifier, pos: usize - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { - v.visit_table(pos)? - .visit_union::("field42_type", Self::VT_FIELD42_TYPE, "field42", Self::VT_FIELD42, false, |key, v, pos| { - match key { - FieldUnion::f => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("FieldUnion::f", pos), - _ => Ok(()), - } - })? - .finish(); - Ok(()) - } + #[inline] + fn run_verifier( + v: &mut ::flatbuffers::Verifier, pos: usize + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + v.visit_table(pos)? + .visit_union::("field42_type", Self::VT_FIELD42_TYPE, "field42", Self::VT_FIELD42, false, |key, v, pos| { + match key { + FieldUnion::f => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("FieldUnion::f", pos), + _ => Ok(()), + } + })? + .finish(); + Ok(()) + } } pub struct RootTableArgs { @@ -113,92 +113,92 @@ pub struct RootTableArgs { } impl<'a> Default for RootTableArgs { - #[inline] - fn default() -> Self { - RootTableArgs { - field42_type: FieldUnion::NONE, - field42: None, + #[inline] + fn default() -> Self { + RootTableArgs { + field42_type: FieldUnion::NONE, + field42: None, + } } - } } pub struct RootTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RootTableBuilder<'a, 'b, A> { - #[inline] - pub fn add_field42_type(&mut self, field42_type: FieldUnion) { - self.fbb_.push_slot::(RootTable::VT_FIELD42_TYPE, field42_type, FieldUnion::NONE); - } - - #[inline] - pub fn add_field42(&mut self, field42: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RootTable::VT_FIELD42, field42); - } - - #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> RootTableBuilder<'a, 'b, A> { - let start = _fbb.start_table(); - RootTableBuilder { - fbb_: _fbb, - start_: start, + #[inline] + pub fn add_field42_type(&mut self, field42_type: FieldUnion) { + self.fbb_.push_slot::(RootTable::VT_FIELD42_TYPE, field42_type, FieldUnion::NONE); } - } - #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_field42(&mut self, field42: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RootTable::VT_FIELD42, field42); + } + + #[inline] + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> RootTableBuilder<'a, 'b, A> { + let start = _fbb.start_table(); + RootTableBuilder { + 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 ::core::fmt::Debug for RootTable<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - let mut ds = f.debug_struct("RootTable"); - ds.field("field42_type", &self.field42_type()); - match self.field42_type() { - FieldUnion::f => { - if let Some(x) = self.field42_as_f() { - ds.field("field42", &x) - } else { - ds.field("field42", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("field42", &x) - }, - }; - ds.finish() - } + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + let mut ds = f.debug_struct("RootTable"); + ds.field("field42_type", &self.field42_type()); + match self.field42_type() { + FieldUnion::f => { + if let Some(x) = self.field42_as_f() { + ds.field("field42", &x) + } else { + ds.field("field42", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + _ => { + let x: Option<()> = None; + ds.field("field42", &x) + }, + }; + ds.finish() + } } #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub struct RootTableT { - pub field42: FieldUnionT, + pub field42: FieldUnionT, } impl Default for RootTableT { - fn default() -> Self { - Self { - field42: FieldUnionT::NONE, + fn default() -> Self { + Self { + field42: FieldUnionT::NONE, + } } - } } impl RootTableT { - pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( - &self, - _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> - ) -> ::flatbuffers::WIPOffset> { - let field42_type = self.field42.field_union_type(); - let field42 = self.field42.pack(_fbb); - RootTable::create(_fbb, &RootTableArgs{ - field42_type, - field42, - }) - } + pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>( + &self, + _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A> + ) -> ::flatbuffers::WIPOffset> { + let field42_type = self.field42.field_union_type(); + let field42 = self.field42.pack(_fbb); + RootTable::create(_fbb, &RootTableArgs{ + field42_type, + field42, + }) + } }