1 // automatically generated by the FlatBuffers compiler, do not modify
2 // @generated
3 extern crate alloc;
4 extern crate flatbuffers;
5 use alloc::boxed::Box;
6 use alloc::string::{String, ToString};
7 use alloc::vec::Vec;
8 use core::mem;
9 use core::cmp::Ordering;
10 extern crate serde;
11 use self::serde::ser::{Serialize, Serializer, SerializeStruct};
12 use self::flatbuffers::{EndianScalar, Follow};
13 use super::*;
14 pub enum MonsterOffset {}
15 #[derive(Copy, Clone, PartialEq)]
16
17 /// an example documentation comment: "monster object"
18 pub struct Monster<'a> {
19 pub _tab: flatbuffers::Table<'a>,
20 }
21
22 impl<'a> flatbuffers::Follow<'a> for Monster<'a> {
23 type Inner = Monster<'a>;
24 #[inline]
follow(buf: &'a [u8], loc: usize) -> Self::Inner25 unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
26 Self { _tab: flatbuffers::Table::new(buf, loc) }
27 }
28 }
29
30 impl<'a> Monster<'a> {
31 pub const VT_POS: flatbuffers::VOffsetT = 4;
32 pub const VT_MANA: flatbuffers::VOffsetT = 6;
33 pub const VT_HP: flatbuffers::VOffsetT = 8;
34 pub const VT_NAME: flatbuffers::VOffsetT = 10;
35 pub const VT_INVENTORY: flatbuffers::VOffsetT = 14;
36 pub const VT_COLOR: flatbuffers::VOffsetT = 16;
37 pub const VT_TEST_TYPE: flatbuffers::VOffsetT = 18;
38 pub const VT_TEST: flatbuffers::VOffsetT = 20;
39 pub const VT_TEST4: flatbuffers::VOffsetT = 22;
40 pub const VT_TESTARRAYOFSTRING: flatbuffers::VOffsetT = 24;
41 pub const VT_TESTARRAYOFTABLES: flatbuffers::VOffsetT = 26;
42 pub const VT_ENEMY: flatbuffers::VOffsetT = 28;
43 pub const VT_TESTNESTEDFLATBUFFER: flatbuffers::VOffsetT = 30;
44 pub const VT_TESTEMPTY: flatbuffers::VOffsetT = 32;
45 pub const VT_TESTBOOL: flatbuffers::VOffsetT = 34;
46 pub const VT_TESTHASHS32_FNV1: flatbuffers::VOffsetT = 36;
47 pub const VT_TESTHASHU32_FNV1: flatbuffers::VOffsetT = 38;
48 pub const VT_TESTHASHS64_FNV1: flatbuffers::VOffsetT = 40;
49 pub const VT_TESTHASHU64_FNV1: flatbuffers::VOffsetT = 42;
50 pub const VT_TESTHASHS32_FNV1A: flatbuffers::VOffsetT = 44;
51 pub const VT_TESTHASHU32_FNV1A: flatbuffers::VOffsetT = 46;
52 pub const VT_TESTHASHS64_FNV1A: flatbuffers::VOffsetT = 48;
53 pub const VT_TESTHASHU64_FNV1A: flatbuffers::VOffsetT = 50;
54 pub const VT_TESTARRAYOFBOOLS: flatbuffers::VOffsetT = 52;
55 pub const VT_TESTF: flatbuffers::VOffsetT = 54;
56 pub const VT_TESTF2: flatbuffers::VOffsetT = 56;
57 pub const VT_TESTF3: flatbuffers::VOffsetT = 58;
58 pub const VT_TESTARRAYOFSTRING2: flatbuffers::VOffsetT = 60;
59 pub const VT_TESTARRAYOFSORTEDSTRUCT: flatbuffers::VOffsetT = 62;
60 pub const VT_FLEX: flatbuffers::VOffsetT = 64;
61 pub const VT_TEST5: flatbuffers::VOffsetT = 66;
62 pub const VT_VECTOR_OF_LONGS: flatbuffers::VOffsetT = 68;
63 pub const VT_VECTOR_OF_DOUBLES: flatbuffers::VOffsetT = 70;
64 pub const VT_PARENT_NAMESPACE_TEST: flatbuffers::VOffsetT = 72;
65 pub const VT_VECTOR_OF_REFERRABLES: flatbuffers::VOffsetT = 74;
66 pub const VT_SINGLE_WEAK_REFERENCE: flatbuffers::VOffsetT = 76;
67 pub const VT_VECTOR_OF_WEAK_REFERENCES: flatbuffers::VOffsetT = 78;
68 pub const VT_VECTOR_OF_STRONG_REFERRABLES: flatbuffers::VOffsetT = 80;
69 pub const VT_CO_OWNING_REFERENCE: flatbuffers::VOffsetT = 82;
70 pub const VT_VECTOR_OF_CO_OWNING_REFERENCES: flatbuffers::VOffsetT = 84;
71 pub const VT_NON_OWNING_REFERENCE: flatbuffers::VOffsetT = 86;
72 pub const VT_VECTOR_OF_NON_OWNING_REFERENCES: flatbuffers::VOffsetT = 88;
73 pub const VT_ANY_UNIQUE_TYPE: flatbuffers::VOffsetT = 90;
74 pub const VT_ANY_UNIQUE: flatbuffers::VOffsetT = 92;
75 pub const VT_ANY_AMBIGUOUS_TYPE: flatbuffers::VOffsetT = 94;
76 pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96;
77 pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;
78 pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100;
79 pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102;
80 pub const VT_SCALAR_KEY_SORTED_TABLES: flatbuffers::VOffsetT = 104;
81 pub const VT_NATIVE_INLINE: flatbuffers::VOffsetT = 106;
82 pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: flatbuffers::VOffsetT = 108;
83 pub const VT_LONG_ENUM_NORMAL_DEFAULT: flatbuffers::VOffsetT = 110;
84 pub const VT_NAN_DEFAULT: flatbuffers::VOffsetT = 112;
85 pub const VT_INF_DEFAULT: flatbuffers::VOffsetT = 114;
86 pub const VT_POSITIVE_INF_DEFAULT: flatbuffers::VOffsetT = 116;
87 pub const VT_INFINITY_DEFAULT: flatbuffers::VOffsetT = 118;
88 pub const VT_POSITIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 120;
89 pub const VT_NEGATIVE_INF_DEFAULT: flatbuffers::VOffsetT = 122;
90 pub const VT_NEGATIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 124;
91 pub const VT_DOUBLE_INF_DEFAULT: flatbuffers::VOffsetT = 126;
92
get_fully_qualified_name() -> &'static str93 pub const fn get_fully_qualified_name() -> &'static str {
94 "MyGame.Example.Monster"
95 }
96
97 #[inline]
init_from_table(table: flatbuffers::Table<'a>) -> Self98 pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
99 Monster { _tab: table }
100 }
101 #[allow(unused_mut)]
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<Monster<'bldr>>102 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
103 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
104 args: &'args MonsterArgs<'args>
105 ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
106 let mut builder = MonsterBuilder::new(_fbb);
107 builder.add_double_inf_default(args.double_inf_default);
108 builder.add_long_enum_normal_default(args.long_enum_normal_default);
109 builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default);
110 builder.add_non_owning_reference(args.non_owning_reference);
111 builder.add_co_owning_reference(args.co_owning_reference);
112 builder.add_single_weak_reference(args.single_weak_reference);
113 builder.add_testhashu64_fnv1a(args.testhashu64_fnv1a);
114 builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a);
115 builder.add_testhashu64_fnv1(args.testhashu64_fnv1);
116 builder.add_testhashs64_fnv1(args.testhashs64_fnv1);
117 builder.add_negative_infinity_default(args.negative_infinity_default);
118 builder.add_negative_inf_default(args.negative_inf_default);
119 builder.add_positive_infinity_default(args.positive_infinity_default);
120 builder.add_infinity_default(args.infinity_default);
121 builder.add_positive_inf_default(args.positive_inf_default);
122 builder.add_inf_default(args.inf_default);
123 builder.add_nan_default(args.nan_default);
124 if let Some(x) = args.native_inline { builder.add_native_inline(x); }
125 if let Some(x) = args.scalar_key_sorted_tables { builder.add_scalar_key_sorted_tables(x); }
126 if let Some(x) = args.testrequirednestedflatbuffer { builder.add_testrequirednestedflatbuffer(x); }
127 if let Some(x) = args.vector_of_enums { builder.add_vector_of_enums(x); }
128 if let Some(x) = args.any_ambiguous { builder.add_any_ambiguous(x); }
129 if let Some(x) = args.any_unique { builder.add_any_unique(x); }
130 if let Some(x) = args.vector_of_non_owning_references { builder.add_vector_of_non_owning_references(x); }
131 if let Some(x) = args.vector_of_co_owning_references { builder.add_vector_of_co_owning_references(x); }
132 if let Some(x) = args.vector_of_strong_referrables { builder.add_vector_of_strong_referrables(x); }
133 if let Some(x) = args.vector_of_weak_references { builder.add_vector_of_weak_references(x); }
134 if let Some(x) = args.vector_of_referrables { builder.add_vector_of_referrables(x); }
135 if let Some(x) = args.parent_namespace_test { builder.add_parent_namespace_test(x); }
136 if let Some(x) = args.vector_of_doubles { builder.add_vector_of_doubles(x); }
137 if let Some(x) = args.vector_of_longs { builder.add_vector_of_longs(x); }
138 if let Some(x) = args.test5 { builder.add_test5(x); }
139 if let Some(x) = args.flex { builder.add_flex(x); }
140 if let Some(x) = args.testarrayofsortedstruct { builder.add_testarrayofsortedstruct(x); }
141 if let Some(x) = args.testarrayofstring2 { builder.add_testarrayofstring2(x); }
142 builder.add_testf3(args.testf3);
143 builder.add_testf2(args.testf2);
144 builder.add_testf(args.testf);
145 if let Some(x) = args.testarrayofbools { builder.add_testarrayofbools(x); }
146 builder.add_testhashu32_fnv1a(args.testhashu32_fnv1a);
147 builder.add_testhashs32_fnv1a(args.testhashs32_fnv1a);
148 builder.add_testhashu32_fnv1(args.testhashu32_fnv1);
149 builder.add_testhashs32_fnv1(args.testhashs32_fnv1);
150 if let Some(x) = args.testempty { builder.add_testempty(x); }
151 if let Some(x) = args.testnestedflatbuffer { builder.add_testnestedflatbuffer(x); }
152 if let Some(x) = args.enemy { builder.add_enemy(x); }
153 if let Some(x) = args.testarrayoftables { builder.add_testarrayoftables(x); }
154 if let Some(x) = args.testarrayofstring { builder.add_testarrayofstring(x); }
155 if let Some(x) = args.test4 { builder.add_test4(x); }
156 if let Some(x) = args.test { builder.add_test(x); }
157 if let Some(x) = args.inventory { builder.add_inventory(x); }
158 if let Some(x) = args.name { builder.add_name(x); }
159 if let Some(x) = args.pos { builder.add_pos(x); }
160 builder.add_hp(args.hp);
161 builder.add_mana(args.mana);
162 builder.add_signed_enum(args.signed_enum);
163 builder.add_any_ambiguous_type(args.any_ambiguous_type);
164 builder.add_any_unique_type(args.any_unique_type);
165 builder.add_testbool(args.testbool);
166 builder.add_test_type(args.test_type);
167 builder.add_color(args.color);
168 builder.finish()
169 }
170
unpack(&self) -> MonsterT171 pub fn unpack(&self) -> MonsterT {
172 let pos = self.pos().map(|x| {
173 x.unpack()
174 });
175 let mana = self.mana();
176 let hp = self.hp();
177 let name = {
178 let x = self.name();
179 x.to_string()
180 };
181 let inventory = self.inventory().map(|x| {
182 x.into_iter().collect()
183 });
184 let color = self.color();
185 let test = match self.test_type() {
186 Any::NONE => AnyT::NONE,
187 Any::Monster => AnyT::Monster(Box::new(
188 self.test_as_monster()
189 .expect("Invalid union table, expected `Any::Monster`.")
190 .unpack()
191 )),
192 Any::TestSimpleTableWithEnum => AnyT::TestSimpleTableWithEnum(Box::new(
193 self.test_as_test_simple_table_with_enum()
194 .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`.")
195 .unpack()
196 )),
197 Any::MyGame_Example2_Monster => AnyT::MyGameExample2Monster(Box::new(
198 self.test_as_my_game_example_2_monster()
199 .expect("Invalid union table, expected `Any::MyGame_Example2_Monster`.")
200 .unpack()
201 )),
202 _ => AnyT::NONE,
203 };
204 let test4 = self.test4().map(|x| {
205 x.iter().map(|t| t.unpack()).collect()
206 });
207 let testarrayofstring = self.testarrayofstring().map(|x| {
208 x.iter().map(|s| s.to_string()).collect()
209 });
210 let testarrayoftables = self.testarrayoftables().map(|x| {
211 x.iter().map(|t| t.unpack()).collect()
212 });
213 let enemy = self.enemy().map(|x| {
214 Box::new(x.unpack())
215 });
216 let testnestedflatbuffer = self.testnestedflatbuffer().map(|x| {
217 x.into_iter().collect()
218 });
219 let testempty = self.testempty().map(|x| {
220 Box::new(x.unpack())
221 });
222 let testbool = self.testbool();
223 let testhashs32_fnv1 = self.testhashs32_fnv1();
224 let testhashu32_fnv1 = self.testhashu32_fnv1();
225 let testhashs64_fnv1 = self.testhashs64_fnv1();
226 let testhashu64_fnv1 = self.testhashu64_fnv1();
227 let testhashs32_fnv1a = self.testhashs32_fnv1a();
228 let testhashu32_fnv1a = self.testhashu32_fnv1a();
229 let testhashs64_fnv1a = self.testhashs64_fnv1a();
230 let testhashu64_fnv1a = self.testhashu64_fnv1a();
231 let testarrayofbools = self.testarrayofbools().map(|x| {
232 x.into_iter().collect()
233 });
234 let testf = self.testf();
235 let testf2 = self.testf2();
236 let testf3 = self.testf3();
237 let testarrayofstring2 = self.testarrayofstring2().map(|x| {
238 x.iter().map(|s| s.to_string()).collect()
239 });
240 let testarrayofsortedstruct = self.testarrayofsortedstruct().map(|x| {
241 x.iter().map(|t| t.unpack()).collect()
242 });
243 let flex = self.flex().map(|x| {
244 x.into_iter().collect()
245 });
246 let test5 = self.test5().map(|x| {
247 x.iter().map(|t| t.unpack()).collect()
248 });
249 let vector_of_longs = self.vector_of_longs().map(|x| {
250 x.into_iter().collect()
251 });
252 let vector_of_doubles = self.vector_of_doubles().map(|x| {
253 x.into_iter().collect()
254 });
255 let parent_namespace_test = self.parent_namespace_test().map(|x| {
256 Box::new(x.unpack())
257 });
258 let vector_of_referrables = self.vector_of_referrables().map(|x| {
259 x.iter().map(|t| t.unpack()).collect()
260 });
261 let single_weak_reference = self.single_weak_reference();
262 let vector_of_weak_references = self.vector_of_weak_references().map(|x| {
263 x.into_iter().collect()
264 });
265 let vector_of_strong_referrables = self.vector_of_strong_referrables().map(|x| {
266 x.iter().map(|t| t.unpack()).collect()
267 });
268 let co_owning_reference = self.co_owning_reference();
269 let vector_of_co_owning_references = self.vector_of_co_owning_references().map(|x| {
270 x.into_iter().collect()
271 });
272 let non_owning_reference = self.non_owning_reference();
273 let vector_of_non_owning_references = self.vector_of_non_owning_references().map(|x| {
274 x.into_iter().collect()
275 });
276 let any_unique = match self.any_unique_type() {
277 AnyUniqueAliases::NONE => AnyUniqueAliasesT::NONE,
278 AnyUniqueAliases::M => AnyUniqueAliasesT::M(Box::new(
279 self.any_unique_as_m()
280 .expect("Invalid union table, expected `AnyUniqueAliases::M`.")
281 .unpack()
282 )),
283 AnyUniqueAliases::TS => AnyUniqueAliasesT::TS(Box::new(
284 self.any_unique_as_ts()
285 .expect("Invalid union table, expected `AnyUniqueAliases::TS`.")
286 .unpack()
287 )),
288 AnyUniqueAliases::M2 => AnyUniqueAliasesT::M2(Box::new(
289 self.any_unique_as_m2()
290 .expect("Invalid union table, expected `AnyUniqueAliases::M2`.")
291 .unpack()
292 )),
293 _ => AnyUniqueAliasesT::NONE,
294 };
295 let any_ambiguous = match self.any_ambiguous_type() {
296 AnyAmbiguousAliases::NONE => AnyAmbiguousAliasesT::NONE,
297 AnyAmbiguousAliases::M1 => AnyAmbiguousAliasesT::M1(Box::new(
298 self.any_ambiguous_as_m1()
299 .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`.")
300 .unpack()
301 )),
302 AnyAmbiguousAliases::M2 => AnyAmbiguousAliasesT::M2(Box::new(
303 self.any_ambiguous_as_m2()
304 .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`.")
305 .unpack()
306 )),
307 AnyAmbiguousAliases::M3 => AnyAmbiguousAliasesT::M3(Box::new(
308 self.any_ambiguous_as_m3()
309 .expect("Invalid union table, expected `AnyAmbiguousAliases::M3`.")
310 .unpack()
311 )),
312 _ => AnyAmbiguousAliasesT::NONE,
313 };
314 let vector_of_enums = self.vector_of_enums().map(|x| {
315 x.into_iter().collect()
316 });
317 let signed_enum = self.signed_enum();
318 let testrequirednestedflatbuffer = self.testrequirednestedflatbuffer().map(|x| {
319 x.into_iter().collect()
320 });
321 let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| {
322 x.iter().map(|t| t.unpack()).collect()
323 });
324 let native_inline = self.native_inline().map(|x| {
325 x.unpack()
326 });
327 let long_enum_non_enum_default = self.long_enum_non_enum_default();
328 let long_enum_normal_default = self.long_enum_normal_default();
329 let nan_default = self.nan_default();
330 let inf_default = self.inf_default();
331 let positive_inf_default = self.positive_inf_default();
332 let infinity_default = self.infinity_default();
333 let positive_infinity_default = self.positive_infinity_default();
334 let negative_inf_default = self.negative_inf_default();
335 let negative_infinity_default = self.negative_infinity_default();
336 let double_inf_default = self.double_inf_default();
337 MonsterT {
338 pos,
339 mana,
340 hp,
341 name,
342 inventory,
343 color,
344 test,
345 test4,
346 testarrayofstring,
347 testarrayoftables,
348 enemy,
349 testnestedflatbuffer,
350 testempty,
351 testbool,
352 testhashs32_fnv1,
353 testhashu32_fnv1,
354 testhashs64_fnv1,
355 testhashu64_fnv1,
356 testhashs32_fnv1a,
357 testhashu32_fnv1a,
358 testhashs64_fnv1a,
359 testhashu64_fnv1a,
360 testarrayofbools,
361 testf,
362 testf2,
363 testf3,
364 testarrayofstring2,
365 testarrayofsortedstruct,
366 flex,
367 test5,
368 vector_of_longs,
369 vector_of_doubles,
370 parent_namespace_test,
371 vector_of_referrables,
372 single_weak_reference,
373 vector_of_weak_references,
374 vector_of_strong_referrables,
375 co_owning_reference,
376 vector_of_co_owning_references,
377 non_owning_reference,
378 vector_of_non_owning_references,
379 any_unique,
380 any_ambiguous,
381 vector_of_enums,
382 signed_enum,
383 testrequirednestedflatbuffer,
384 scalar_key_sorted_tables,
385 native_inline,
386 long_enum_non_enum_default,
387 long_enum_normal_default,
388 nan_default,
389 inf_default,
390 positive_inf_default,
391 infinity_default,
392 positive_infinity_default,
393 negative_inf_default,
394 negative_infinity_default,
395 double_inf_default,
396 }
397 }
398
399 #[inline]
pos(&self) -> Option<&'a Vec3>400 pub fn pos(&self) -> Option<&'a Vec3> {
401 // Safety:
402 // Created from valid Table for this object
403 // which contains a valid value in this slot
404 unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
405 }
406 #[inline]
mana(&self) -> i16407 pub fn mana(&self) -> i16 {
408 // Safety:
409 // Created from valid Table for this object
410 // which contains a valid value in this slot
411 unsafe { self._tab.get::<i16>(Monster::VT_MANA, Some(150)).unwrap()}
412 }
413 #[inline]
hp(&self) -> i16414 pub fn hp(&self) -> i16 {
415 // Safety:
416 // Created from valid Table for this object
417 // which contains a valid value in this slot
418 unsafe { self._tab.get::<i16>(Monster::VT_HP, Some(100)).unwrap()}
419 }
420 #[inline]
name(&self) -> &'a str421 pub fn name(&self) -> &'a str {
422 // Safety:
423 // Created from valid Table for this object
424 // which contains a valid value in this slot
425 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None).unwrap()}
426 }
427 #[inline]
key_compare_less_than(&self, o: &Monster) -> bool428 pub fn key_compare_less_than(&self, o: &Monster) -> bool {
429 self.name() < o.name()
430 }
431
432 #[inline]
key_compare_with_value(&self, val: & str) -> ::core::cmp::Ordering433 pub fn key_compare_with_value(&self, val: & str) -> ::core::cmp::Ordering {
434 let key = self.name();
435 key.cmp(val)
436 }
437 #[inline]
inventory(&self) -> Option<flatbuffers::Vector<'a, u8>>438 pub fn inventory(&self) -> Option<flatbuffers::Vector<'a, u8>> {
439 // Safety:
440 // Created from valid Table for this object
441 // which contains a valid value in this slot
442 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)}
443 }
444 #[inline]
color(&self) -> Color445 pub fn color(&self) -> Color {
446 // Safety:
447 // Created from valid Table for this object
448 // which contains a valid value in this slot
449 unsafe { self._tab.get::<Color>(Monster::VT_COLOR, Some(Color::Blue)).unwrap()}
450 }
451 #[inline]
test_type(&self) -> Any452 pub fn test_type(&self) -> Any {
453 // Safety:
454 // Created from valid Table for this object
455 // which contains a valid value in this slot
456 unsafe { self._tab.get::<Any>(Monster::VT_TEST_TYPE, Some(Any::NONE)).unwrap()}
457 }
458 #[inline]
test(&self) -> Option<flatbuffers::Table<'a>>459 pub fn test(&self) -> Option<flatbuffers::Table<'a>> {
460 // Safety:
461 // Created from valid Table for this object
462 // which contains a valid value in this slot
463 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Monster::VT_TEST, None)}
464 }
465 #[inline]
test4(&self) -> Option<flatbuffers::Vector<'a, Test>>466 pub fn test4(&self) -> Option<flatbuffers::Vector<'a, Test>> {
467 // Safety:
468 // Created from valid Table for this object
469 // which contains a valid value in this slot
470 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST4, None)}
471 }
472 #[inline]
testarrayofstring(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>473 pub fn testarrayofstring(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
474 // Safety:
475 // Created from valid Table for this object
476 // which contains a valid value in this slot
477 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING, None)}
478 }
479 /// an example documentation comment: this will end up in the generated code
480 /// multiline too
481 #[inline]
testarrayoftables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Monster<'a>>>>482 pub fn testarrayoftables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Monster<'a>>>> {
483 // Safety:
484 // Created from valid Table for this object
485 // which contains a valid value in this slot
486 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Monster>>>>(Monster::VT_TESTARRAYOFTABLES, None)}
487 }
488 #[inline]
enemy(&self) -> Option<Monster<'a>>489 pub fn enemy(&self) -> Option<Monster<'a>> {
490 // Safety:
491 // Created from valid Table for this object
492 // which contains a valid value in this slot
493 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Monster>>(Monster::VT_ENEMY, None)}
494 }
495 #[inline]
testnestedflatbuffer(&self) -> Option<flatbuffers::Vector<'a, u8>>496 pub fn testnestedflatbuffer(&self) -> Option<flatbuffers::Vector<'a, u8>> {
497 // Safety:
498 // Created from valid Table for this object
499 // which contains a valid value in this slot
500 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTNESTEDFLATBUFFER, None)}
501 }
testnestedflatbuffer_nested_flatbuffer(&'a self) -> Option<Monster<'a>>502 pub fn testnestedflatbuffer_nested_flatbuffer(&'a self) -> Option<Monster<'a>> {
503 self.testnestedflatbuffer().map(|data| {
504 use flatbuffers::Follow;
505 // Safety:
506 // Created from a valid Table for this object
507 // Which contains a valid flatbuffer in this slot
508 unsafe { <flatbuffers::ForwardsUOffset<Monster<'a>>>::follow(data.bytes(), 0) }
509 })
510 }
511 #[inline]
testempty(&self) -> Option<Stat<'a>>512 pub fn testempty(&self) -> Option<Stat<'a>> {
513 // Safety:
514 // Created from valid Table for this object
515 // which contains a valid value in this slot
516 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Stat>>(Monster::VT_TESTEMPTY, None)}
517 }
518 #[inline]
testbool(&self) -> bool519 pub fn testbool(&self) -> bool {
520 // Safety:
521 // Created from valid Table for this object
522 // which contains a valid value in this slot
523 unsafe { self._tab.get::<bool>(Monster::VT_TESTBOOL, Some(false)).unwrap()}
524 }
525 #[inline]
testhashs32_fnv1(&self) -> i32526 pub fn testhashs32_fnv1(&self) -> i32 {
527 // Safety:
528 // Created from valid Table for this object
529 // which contains a valid value in this slot
530 unsafe { self._tab.get::<i32>(Monster::VT_TESTHASHS32_FNV1, Some(0)).unwrap()}
531 }
532 #[inline]
testhashu32_fnv1(&self) -> u32533 pub fn testhashu32_fnv1(&self) -> u32 {
534 // Safety:
535 // Created from valid Table for this object
536 // which contains a valid value in this slot
537 unsafe { self._tab.get::<u32>(Monster::VT_TESTHASHU32_FNV1, Some(0)).unwrap()}
538 }
539 #[inline]
testhashs64_fnv1(&self) -> i64540 pub fn testhashs64_fnv1(&self) -> i64 {
541 // Safety:
542 // Created from valid Table for this object
543 // which contains a valid value in this slot
544 unsafe { self._tab.get::<i64>(Monster::VT_TESTHASHS64_FNV1, Some(0)).unwrap()}
545 }
546 #[inline]
testhashu64_fnv1(&self) -> u64547 pub fn testhashu64_fnv1(&self) -> u64 {
548 // Safety:
549 // Created from valid Table for this object
550 // which contains a valid value in this slot
551 unsafe { self._tab.get::<u64>(Monster::VT_TESTHASHU64_FNV1, Some(0)).unwrap()}
552 }
553 #[inline]
testhashs32_fnv1a(&self) -> i32554 pub fn testhashs32_fnv1a(&self) -> i32 {
555 // Safety:
556 // Created from valid Table for this object
557 // which contains a valid value in this slot
558 unsafe { self._tab.get::<i32>(Monster::VT_TESTHASHS32_FNV1A, Some(0)).unwrap()}
559 }
560 #[inline]
testhashu32_fnv1a(&self) -> u32561 pub fn testhashu32_fnv1a(&self) -> u32 {
562 // Safety:
563 // Created from valid Table for this object
564 // which contains a valid value in this slot
565 unsafe { self._tab.get::<u32>(Monster::VT_TESTHASHU32_FNV1A, Some(0)).unwrap()}
566 }
567 #[inline]
testhashs64_fnv1a(&self) -> i64568 pub fn testhashs64_fnv1a(&self) -> i64 {
569 // Safety:
570 // Created from valid Table for this object
571 // which contains a valid value in this slot
572 unsafe { self._tab.get::<i64>(Monster::VT_TESTHASHS64_FNV1A, Some(0)).unwrap()}
573 }
574 #[inline]
testhashu64_fnv1a(&self) -> u64575 pub fn testhashu64_fnv1a(&self) -> u64 {
576 // Safety:
577 // Created from valid Table for this object
578 // which contains a valid value in this slot
579 unsafe { self._tab.get::<u64>(Monster::VT_TESTHASHU64_FNV1A, Some(0)).unwrap()}
580 }
581 #[inline]
testarrayofbools(&self) -> Option<flatbuffers::Vector<'a, bool>>582 pub fn testarrayofbools(&self) -> Option<flatbuffers::Vector<'a, bool>> {
583 // Safety:
584 // Created from valid Table for this object
585 // which contains a valid value in this slot
586 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, bool>>>(Monster::VT_TESTARRAYOFBOOLS, None)}
587 }
588 #[inline]
testf(&self) -> f32589 pub fn testf(&self) -> f32 {
590 // Safety:
591 // Created from valid Table for this object
592 // which contains a valid value in this slot
593 unsafe { self._tab.get::<f32>(Monster::VT_TESTF, Some(3.14159)).unwrap()}
594 }
595 #[inline]
testf2(&self) -> f32596 pub fn testf2(&self) -> f32 {
597 // Safety:
598 // Created from valid Table for this object
599 // which contains a valid value in this slot
600 unsafe { self._tab.get::<f32>(Monster::VT_TESTF2, Some(3.0)).unwrap()}
601 }
602 #[inline]
testf3(&self) -> f32603 pub fn testf3(&self) -> f32 {
604 // Safety:
605 // Created from valid Table for this object
606 // which contains a valid value in this slot
607 unsafe { self._tab.get::<f32>(Monster::VT_TESTF3, Some(0.0)).unwrap()}
608 }
609 #[inline]
testarrayofstring2(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>610 pub fn testarrayofstring2(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
611 // Safety:
612 // Created from valid Table for this object
613 // which contains a valid value in this slot
614 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>(Monster::VT_TESTARRAYOFSTRING2, None)}
615 }
616 #[inline]
testarrayofsortedstruct(&self) -> Option<flatbuffers::Vector<'a, Ability>>617 pub fn testarrayofsortedstruct(&self) -> Option<flatbuffers::Vector<'a, Ability>> {
618 // Safety:
619 // Created from valid Table for this object
620 // which contains a valid value in this slot
621 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Ability>>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, None)}
622 }
623 #[inline]
flex(&self) -> Option<flatbuffers::Vector<'a, u8>>624 pub fn flex(&self) -> Option<flatbuffers::Vector<'a, u8>> {
625 // Safety:
626 // Created from valid Table for this object
627 // which contains a valid value in this slot
628 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Monster::VT_FLEX, None)}
629 }
630 #[inline]
test5(&self) -> Option<flatbuffers::Vector<'a, Test>>631 pub fn test5(&self) -> Option<flatbuffers::Vector<'a, Test>> {
632 // Safety:
633 // Created from valid Table for this object
634 // which contains a valid value in this slot
635 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Test>>>(Monster::VT_TEST5, None)}
636 }
637 #[inline]
vector_of_longs(&self) -> Option<flatbuffers::Vector<'a, i64>>638 pub fn vector_of_longs(&self) -> Option<flatbuffers::Vector<'a, i64>> {
639 // Safety:
640 // Created from valid Table for this object
641 // which contains a valid value in this slot
642 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i64>>>(Monster::VT_VECTOR_OF_LONGS, None)}
643 }
644 #[inline]
vector_of_doubles(&self) -> Option<flatbuffers::Vector<'a, f64>>645 pub fn vector_of_doubles(&self) -> Option<flatbuffers::Vector<'a, f64>> {
646 // Safety:
647 // Created from valid Table for this object
648 // which contains a valid value in this slot
649 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, f64>>>(Monster::VT_VECTOR_OF_DOUBLES, None)}
650 }
651 #[inline]
parent_namespace_test(&self) -> Option<super::InParentNamespace<'a>>652 pub fn parent_namespace_test(&self) -> Option<super::InParentNamespace<'a>> {
653 // Safety:
654 // Created from valid Table for this object
655 // which contains a valid value in this slot
656 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<super::InParentNamespace>>(Monster::VT_PARENT_NAMESPACE_TEST, None)}
657 }
658 #[inline]
vector_of_referrables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable<'a>>>>659 pub fn vector_of_referrables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable<'a>>>> {
660 // Safety:
661 // Created from valid Table for this object
662 // which contains a valid value in this slot
663 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable>>>>(Monster::VT_VECTOR_OF_REFERRABLES, None)}
664 }
665 #[inline]
single_weak_reference(&self) -> u64666 pub fn single_weak_reference(&self) -> u64 {
667 // Safety:
668 // Created from valid Table for this object
669 // which contains a valid value in this slot
670 unsafe { self._tab.get::<u64>(Monster::VT_SINGLE_WEAK_REFERENCE, Some(0)).unwrap()}
671 }
672 #[inline]
vector_of_weak_references(&self) -> Option<flatbuffers::Vector<'a, u64>>673 pub fn vector_of_weak_references(&self) -> Option<flatbuffers::Vector<'a, u64>> {
674 // Safety:
675 // Created from valid Table for this object
676 // which contains a valid value in this slot
677 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, None)}
678 }
679 #[inline]
vector_of_strong_referrables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable<'a>>>>680 pub fn vector_of_strong_referrables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable<'a>>>> {
681 // Safety:
682 // Created from valid Table for this object
683 // which contains a valid value in this slot
684 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable>>>>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, None)}
685 }
686 #[inline]
co_owning_reference(&self) -> u64687 pub fn co_owning_reference(&self) -> u64 {
688 // Safety:
689 // Created from valid Table for this object
690 // which contains a valid value in this slot
691 unsafe { self._tab.get::<u64>(Monster::VT_CO_OWNING_REFERENCE, Some(0)).unwrap()}
692 }
693 #[inline]
vector_of_co_owning_references(&self) -> Option<flatbuffers::Vector<'a, u64>>694 pub fn vector_of_co_owning_references(&self) -> Option<flatbuffers::Vector<'a, u64>> {
695 // Safety:
696 // Created from valid Table for this object
697 // which contains a valid value in this slot
698 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, None)}
699 }
700 #[inline]
non_owning_reference(&self) -> u64701 pub fn non_owning_reference(&self) -> u64 {
702 // Safety:
703 // Created from valid Table for this object
704 // which contains a valid value in this slot
705 unsafe { self._tab.get::<u64>(Monster::VT_NON_OWNING_REFERENCE, Some(0)).unwrap()}
706 }
707 #[inline]
vector_of_non_owning_references(&self) -> Option<flatbuffers::Vector<'a, u64>>708 pub fn vector_of_non_owning_references(&self) -> Option<flatbuffers::Vector<'a, u64>> {
709 // Safety:
710 // Created from valid Table for this object
711 // which contains a valid value in this slot
712 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u64>>>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, None)}
713 }
714 #[inline]
any_unique_type(&self) -> AnyUniqueAliases715 pub fn any_unique_type(&self) -> AnyUniqueAliases {
716 // Safety:
717 // Created from valid Table for this object
718 // which contains a valid value in this slot
719 unsafe { self._tab.get::<AnyUniqueAliases>(Monster::VT_ANY_UNIQUE_TYPE, Some(AnyUniqueAliases::NONE)).unwrap()}
720 }
721 #[inline]
any_unique(&self) -> Option<flatbuffers::Table<'a>>722 pub fn any_unique(&self) -> Option<flatbuffers::Table<'a>> {
723 // Safety:
724 // Created from valid Table for this object
725 // which contains a valid value in this slot
726 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Monster::VT_ANY_UNIQUE, None)}
727 }
728 #[inline]
any_ambiguous_type(&self) -> AnyAmbiguousAliases729 pub fn any_ambiguous_type(&self) -> AnyAmbiguousAliases {
730 // Safety:
731 // Created from valid Table for this object
732 // which contains a valid value in this slot
733 unsafe { self._tab.get::<AnyAmbiguousAliases>(Monster::VT_ANY_AMBIGUOUS_TYPE, Some(AnyAmbiguousAliases::NONE)).unwrap()}
734 }
735 #[inline]
any_ambiguous(&self) -> Option<flatbuffers::Table<'a>>736 pub fn any_ambiguous(&self) -> Option<flatbuffers::Table<'a>> {
737 // Safety:
738 // Created from valid Table for this object
739 // which contains a valid value in this slot
740 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Monster::VT_ANY_AMBIGUOUS, None)}
741 }
742 #[inline]
vector_of_enums(&self) -> Option<flatbuffers::Vector<'a, Color>>743 pub fn vector_of_enums(&self) -> Option<flatbuffers::Vector<'a, Color>> {
744 // Safety:
745 // Created from valid Table for this object
746 // which contains a valid value in this slot
747 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Color>>>(Monster::VT_VECTOR_OF_ENUMS, None)}
748 }
749 #[inline]
signed_enum(&self) -> Race750 pub fn signed_enum(&self) -> Race {
751 // Safety:
752 // Created from valid Table for this object
753 // which contains a valid value in this slot
754 unsafe { self._tab.get::<Race>(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()}
755 }
756 #[inline]
testrequirednestedflatbuffer(&self) -> Option<flatbuffers::Vector<'a, u8>>757 pub fn testrequirednestedflatbuffer(&self) -> Option<flatbuffers::Vector<'a, u8>> {
758 // Safety:
759 // Created from valid Table for this object
760 // which contains a valid value in this slot
761 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None)}
762 }
testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option<Monster<'a>>763 pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option<Monster<'a>> {
764 self.testrequirednestedflatbuffer().map(|data| {
765 use flatbuffers::Follow;
766 // Safety:
767 // Created from a valid Table for this object
768 // Which contains a valid flatbuffer in this slot
769 unsafe { <flatbuffers::ForwardsUOffset<Monster<'a>>>::follow(data.bytes(), 0) }
770 })
771 }
772 #[inline]
scalar_key_sorted_tables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat<'a>>>>773 pub fn scalar_key_sorted_tables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat<'a>>>> {
774 // Safety:
775 // Created from valid Table for this object
776 // which contains a valid value in this slot
777 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat>>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)}
778 }
779 #[inline]
native_inline(&self) -> Option<&'a Test>780 pub fn native_inline(&self) -> Option<&'a Test> {
781 // Safety:
782 // Created from valid Table for this object
783 // which contains a valid value in this slot
784 unsafe { self._tab.get::<Test>(Monster::VT_NATIVE_INLINE, None)}
785 }
786 #[inline]
long_enum_non_enum_default(&self) -> LongEnum787 pub fn long_enum_non_enum_default(&self) -> LongEnum {
788 // Safety:
789 // Created from valid Table for this object
790 // which contains a valid value in this slot
791 unsafe { self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, Some(Default::default())).unwrap()}
792 }
793 #[inline]
long_enum_normal_default(&self) -> LongEnum794 pub fn long_enum_normal_default(&self) -> LongEnum {
795 // Safety:
796 // Created from valid Table for this object
797 // which contains a valid value in this slot
798 unsafe { self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()}
799 }
800 #[inline]
nan_default(&self) -> f32801 pub fn nan_default(&self) -> f32 {
802 // Safety:
803 // Created from valid Table for this object
804 // which contains a valid value in this slot
805 unsafe { self._tab.get::<f32>(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()}
806 }
807 #[inline]
inf_default(&self) -> f32808 pub fn inf_default(&self) -> f32 {
809 // Safety:
810 // Created from valid Table for this object
811 // which contains a valid value in this slot
812 unsafe { self._tab.get::<f32>(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
813 }
814 #[inline]
positive_inf_default(&self) -> f32815 pub fn positive_inf_default(&self) -> f32 {
816 // Safety:
817 // Created from valid Table for this object
818 // which contains a valid value in this slot
819 unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
820 }
821 #[inline]
infinity_default(&self) -> f32822 pub fn infinity_default(&self) -> f32 {
823 // Safety:
824 // Created from valid Table for this object
825 // which contains a valid value in this slot
826 unsafe { self._tab.get::<f32>(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
827 }
828 #[inline]
positive_infinity_default(&self) -> f32829 pub fn positive_infinity_default(&self) -> f32 {
830 // Safety:
831 // Created from valid Table for this object
832 // which contains a valid value in this slot
833 unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
834 }
835 #[inline]
negative_inf_default(&self) -> f32836 pub fn negative_inf_default(&self) -> f32 {
837 // Safety:
838 // Created from valid Table for this object
839 // which contains a valid value in this slot
840 unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
841 }
842 #[inline]
negative_infinity_default(&self) -> f32843 pub fn negative_infinity_default(&self) -> f32 {
844 // Safety:
845 // Created from valid Table for this object
846 // which contains a valid value in this slot
847 unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
848 }
849 #[inline]
double_inf_default(&self) -> f64850 pub fn double_inf_default(&self) -> f64 {
851 // Safety:
852 // Created from valid Table for this object
853 // which contains a valid value in this slot
854 unsafe { self._tab.get::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()}
855 }
856 #[inline]
857 #[allow(non_snake_case)]
test_as_monster(&self) -> Option<Monster<'a>>858 pub fn test_as_monster(&self) -> Option<Monster<'a>> {
859 if self.test_type() == Any::Monster {
860 self.test().map(|t| {
861 // Safety:
862 // Created from a valid Table for this object
863 // Which contains a valid union in this slot
864 unsafe { Monster::init_from_table(t) }
865 })
866 } else {
867 None
868 }
869 }
870
871 #[inline]
872 #[allow(non_snake_case)]
test_as_test_simple_table_with_enum(&self) -> Option<TestSimpleTableWithEnum<'a>>873 pub fn test_as_test_simple_table_with_enum(&self) -> Option<TestSimpleTableWithEnum<'a>> {
874 if self.test_type() == Any::TestSimpleTableWithEnum {
875 self.test().map(|t| {
876 // Safety:
877 // Created from a valid Table for this object
878 // Which contains a valid union in this slot
879 unsafe { TestSimpleTableWithEnum::init_from_table(t) }
880 })
881 } else {
882 None
883 }
884 }
885
886 #[inline]
887 #[allow(non_snake_case)]
test_as_my_game_example_2_monster(&self) -> Option<super::example_2::Monster<'a>>888 pub fn test_as_my_game_example_2_monster(&self) -> Option<super::example_2::Monster<'a>> {
889 if self.test_type() == Any::MyGame_Example2_Monster {
890 self.test().map(|t| {
891 // Safety:
892 // Created from a valid Table for this object
893 // Which contains a valid union in this slot
894 unsafe { super::example_2::Monster::init_from_table(t) }
895 })
896 } else {
897 None
898 }
899 }
900
901 #[inline]
902 #[allow(non_snake_case)]
any_unique_as_m(&self) -> Option<Monster<'a>>903 pub fn any_unique_as_m(&self) -> Option<Monster<'a>> {
904 if self.any_unique_type() == AnyUniqueAliases::M {
905 self.any_unique().map(|t| {
906 // Safety:
907 // Created from a valid Table for this object
908 // Which contains a valid union in this slot
909 unsafe { Monster::init_from_table(t) }
910 })
911 } else {
912 None
913 }
914 }
915
916 #[inline]
917 #[allow(non_snake_case)]
any_unique_as_ts(&self) -> Option<TestSimpleTableWithEnum<'a>>918 pub fn any_unique_as_ts(&self) -> Option<TestSimpleTableWithEnum<'a>> {
919 if self.any_unique_type() == AnyUniqueAliases::TS {
920 self.any_unique().map(|t| {
921 // Safety:
922 // Created from a valid Table for this object
923 // Which contains a valid union in this slot
924 unsafe { TestSimpleTableWithEnum::init_from_table(t) }
925 })
926 } else {
927 None
928 }
929 }
930
931 #[inline]
932 #[allow(non_snake_case)]
any_unique_as_m2(&self) -> Option<super::example_2::Monster<'a>>933 pub fn any_unique_as_m2(&self) -> Option<super::example_2::Monster<'a>> {
934 if self.any_unique_type() == AnyUniqueAliases::M2 {
935 self.any_unique().map(|t| {
936 // Safety:
937 // Created from a valid Table for this object
938 // Which contains a valid union in this slot
939 unsafe { super::example_2::Monster::init_from_table(t) }
940 })
941 } else {
942 None
943 }
944 }
945
946 #[inline]
947 #[allow(non_snake_case)]
any_ambiguous_as_m1(&self) -> Option<Monster<'a>>948 pub fn any_ambiguous_as_m1(&self) -> Option<Monster<'a>> {
949 if self.any_ambiguous_type() == AnyAmbiguousAliases::M1 {
950 self.any_ambiguous().map(|t| {
951 // Safety:
952 // Created from a valid Table for this object
953 // Which contains a valid union in this slot
954 unsafe { Monster::init_from_table(t) }
955 })
956 } else {
957 None
958 }
959 }
960
961 #[inline]
962 #[allow(non_snake_case)]
any_ambiguous_as_m2(&self) -> Option<Monster<'a>>963 pub fn any_ambiguous_as_m2(&self) -> Option<Monster<'a>> {
964 if self.any_ambiguous_type() == AnyAmbiguousAliases::M2 {
965 self.any_ambiguous().map(|t| {
966 // Safety:
967 // Created from a valid Table for this object
968 // Which contains a valid union in this slot
969 unsafe { Monster::init_from_table(t) }
970 })
971 } else {
972 None
973 }
974 }
975
976 #[inline]
977 #[allow(non_snake_case)]
any_ambiguous_as_m3(&self) -> Option<Monster<'a>>978 pub fn any_ambiguous_as_m3(&self) -> Option<Monster<'a>> {
979 if self.any_ambiguous_type() == AnyAmbiguousAliases::M3 {
980 self.any_ambiguous().map(|t| {
981 // Safety:
982 // Created from a valid Table for this object
983 // Which contains a valid union in this slot
984 unsafe { Monster::init_from_table(t) }
985 })
986 } else {
987 None
988 }
989 }
990
991 }
992
993 impl flatbuffers::Verifiable for Monster<'_> {
994 #[inline]
run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer>995 fn run_verifier(
996 v: &mut flatbuffers::Verifier, pos: usize
997 ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
998 use self::flatbuffers::Verifiable;
999 v.visit_table(pos)?
1000 .visit_field::<Vec3>("pos", Self::VT_POS, false)?
1001 .visit_field::<i16>("mana", Self::VT_MANA, false)?
1002 .visit_field::<i16>("hp", Self::VT_HP, false)?
1003 .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
1004 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)?
1005 .visit_field::<Color>("color", Self::VT_COLOR, false)?
1006 .visit_union::<Any, _>("test_type", Self::VT_TEST_TYPE, "test", Self::VT_TEST, false, |key, v, pos| {
1007 match key {
1008 Any::Monster => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Monster>>("Any::Monster", pos),
1009 Any::TestSimpleTableWithEnum => v.verify_union_variant::<flatbuffers::ForwardsUOffset<TestSimpleTableWithEnum>>("Any::TestSimpleTableWithEnum", pos),
1010 Any::MyGame_Example2_Monster => v.verify_union_variant::<flatbuffers::ForwardsUOffset<super::example_2::Monster>>("Any::MyGame_Example2_Monster", pos),
1011 _ => Ok(()),
1012 }
1013 })?
1014 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Test>>>("test4", Self::VT_TEST4, false)?
1015 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring", Self::VT_TESTARRAYOFSTRING, false)?
1016 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Monster>>>>("testarrayoftables", Self::VT_TESTARRAYOFTABLES, false)?
1017 .visit_field::<flatbuffers::ForwardsUOffset<Monster>>("enemy", Self::VT_ENEMY, false)?
1018 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("testnestedflatbuffer", Self::VT_TESTNESTEDFLATBUFFER, false)?
1019 .visit_field::<flatbuffers::ForwardsUOffset<Stat>>("testempty", Self::VT_TESTEMPTY, false)?
1020 .visit_field::<bool>("testbool", Self::VT_TESTBOOL, false)?
1021 .visit_field::<i32>("testhashs32_fnv1", Self::VT_TESTHASHS32_FNV1, false)?
1022 .visit_field::<u32>("testhashu32_fnv1", Self::VT_TESTHASHU32_FNV1, false)?
1023 .visit_field::<i64>("testhashs64_fnv1", Self::VT_TESTHASHS64_FNV1, false)?
1024 .visit_field::<u64>("testhashu64_fnv1", Self::VT_TESTHASHU64_FNV1, false)?
1025 .visit_field::<i32>("testhashs32_fnv1a", Self::VT_TESTHASHS32_FNV1A, false)?
1026 .visit_field::<u32>("testhashu32_fnv1a", Self::VT_TESTHASHU32_FNV1A, false)?
1027 .visit_field::<i64>("testhashs64_fnv1a", Self::VT_TESTHASHS64_FNV1A, false)?
1028 .visit_field::<u64>("testhashu64_fnv1a", Self::VT_TESTHASHU64_FNV1A, false)?
1029 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, bool>>>("testarrayofbools", Self::VT_TESTARRAYOFBOOLS, false)?
1030 .visit_field::<f32>("testf", Self::VT_TESTF, false)?
1031 .visit_field::<f32>("testf2", Self::VT_TESTF2, false)?
1032 .visit_field::<f32>("testf3", Self::VT_TESTF3, false)?
1033 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("testarrayofstring2", Self::VT_TESTARRAYOFSTRING2, false)?
1034 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Ability>>>("testarrayofsortedstruct", Self::VT_TESTARRAYOFSORTEDSTRUCT, false)?
1035 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("flex", Self::VT_FLEX, false)?
1036 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Test>>>("test5", Self::VT_TEST5, false)?
1037 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i64>>>("vector_of_longs", Self::VT_VECTOR_OF_LONGS, false)?
1038 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f64>>>("vector_of_doubles", Self::VT_VECTOR_OF_DOUBLES, false)?
1039 .visit_field::<flatbuffers::ForwardsUOffset<super::InParentNamespace>>("parent_namespace_test", Self::VT_PARENT_NAMESPACE_TEST, false)?
1040 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Referrable>>>>("vector_of_referrables", Self::VT_VECTOR_OF_REFERRABLES, false)?
1041 .visit_field::<u64>("single_weak_reference", Self::VT_SINGLE_WEAK_REFERENCE, false)?
1042 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u64>>>("vector_of_weak_references", Self::VT_VECTOR_OF_WEAK_REFERENCES, false)?
1043 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Referrable>>>>("vector_of_strong_referrables", Self::VT_VECTOR_OF_STRONG_REFERRABLES, false)?
1044 .visit_field::<u64>("co_owning_reference", Self::VT_CO_OWNING_REFERENCE, false)?
1045 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u64>>>("vector_of_co_owning_references", Self::VT_VECTOR_OF_CO_OWNING_REFERENCES, false)?
1046 .visit_field::<u64>("non_owning_reference", Self::VT_NON_OWNING_REFERENCE, false)?
1047 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u64>>>("vector_of_non_owning_references", Self::VT_VECTOR_OF_NON_OWNING_REFERENCES, false)?
1048 .visit_union::<AnyUniqueAliases, _>("any_unique_type", Self::VT_ANY_UNIQUE_TYPE, "any_unique", Self::VT_ANY_UNIQUE, false, |key, v, pos| {
1049 match key {
1050 AnyUniqueAliases::M => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Monster>>("AnyUniqueAliases::M", pos),
1051 AnyUniqueAliases::TS => v.verify_union_variant::<flatbuffers::ForwardsUOffset<TestSimpleTableWithEnum>>("AnyUniqueAliases::TS", pos),
1052 AnyUniqueAliases::M2 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<super::example_2::Monster>>("AnyUniqueAliases::M2", pos),
1053 _ => Ok(()),
1054 }
1055 })?
1056 .visit_union::<AnyAmbiguousAliases, _>("any_ambiguous_type", Self::VT_ANY_AMBIGUOUS_TYPE, "any_ambiguous", Self::VT_ANY_AMBIGUOUS, false, |key, v, pos| {
1057 match key {
1058 AnyAmbiguousAliases::M1 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Monster>>("AnyAmbiguousAliases::M1", pos),
1059 AnyAmbiguousAliases::M2 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Monster>>("AnyAmbiguousAliases::M2", pos),
1060 AnyAmbiguousAliases::M3 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Monster>>("AnyAmbiguousAliases::M3", pos),
1061 _ => Ok(()),
1062 }
1063 })?
1064 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Color>>>("vector_of_enums", Self::VT_VECTOR_OF_ENUMS, false)?
1065 .visit_field::<Race>("signed_enum", Self::VT_SIGNED_ENUM, false)?
1066 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)?
1067 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Stat>>>>("scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)?
1068 .visit_field::<Test>("native_inline", Self::VT_NATIVE_INLINE, false)?
1069 .visit_field::<LongEnum>("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)?
1070 .visit_field::<LongEnum>("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)?
1071 .visit_field::<f32>("nan_default", Self::VT_NAN_DEFAULT, false)?
1072 .visit_field::<f32>("inf_default", Self::VT_INF_DEFAULT, false)?
1073 .visit_field::<f32>("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)?
1074 .visit_field::<f32>("infinity_default", Self::VT_INFINITY_DEFAULT, false)?
1075 .visit_field::<f32>("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)?
1076 .visit_field::<f32>("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)?
1077 .visit_field::<f32>("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)?
1078 .visit_field::<f64>("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)?
1079 .finish();
1080 Ok(())
1081 }
1082 }
1083 pub struct MonsterArgs<'a> {
1084 pub pos: Option<&'a Vec3>,
1085 pub mana: i16,
1086 pub hp: i16,
1087 pub name: Option<flatbuffers::WIPOffset<&'a str>>,
1088 pub inventory: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
1089 pub color: Color,
1090 pub test_type: Any,
1091 pub test: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
1092 pub test4: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Test>>>,
1093 pub testarrayofstring: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
1094 pub testarrayoftables: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Monster<'a>>>>>,
1095 pub enemy: Option<flatbuffers::WIPOffset<Monster<'a>>>,
1096 pub testnestedflatbuffer: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
1097 pub testempty: Option<flatbuffers::WIPOffset<Stat<'a>>>,
1098 pub testbool: bool,
1099 pub testhashs32_fnv1: i32,
1100 pub testhashu32_fnv1: u32,
1101 pub testhashs64_fnv1: i64,
1102 pub testhashu64_fnv1: u64,
1103 pub testhashs32_fnv1a: i32,
1104 pub testhashu32_fnv1a: u32,
1105 pub testhashs64_fnv1a: i64,
1106 pub testhashu64_fnv1a: u64,
1107 pub testarrayofbools: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, bool>>>,
1108 pub testf: f32,
1109 pub testf2: f32,
1110 pub testf3: f32,
1111 pub testarrayofstring2: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
1112 pub testarrayofsortedstruct: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Ability>>>,
1113 pub flex: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
1114 pub test5: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Test>>>,
1115 pub vector_of_longs: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, i64>>>,
1116 pub vector_of_doubles: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f64>>>,
1117 pub parent_namespace_test: Option<flatbuffers::WIPOffset<super::InParentNamespace<'a>>>,
1118 pub vector_of_referrables: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable<'a>>>>>,
1119 pub single_weak_reference: u64,
1120 pub vector_of_weak_references: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u64>>>,
1121 pub vector_of_strong_referrables: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Referrable<'a>>>>>,
1122 pub co_owning_reference: u64,
1123 pub vector_of_co_owning_references: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u64>>>,
1124 pub non_owning_reference: u64,
1125 pub vector_of_non_owning_references: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u64>>>,
1126 pub any_unique_type: AnyUniqueAliases,
1127 pub any_unique: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
1128 pub any_ambiguous_type: AnyAmbiguousAliases,
1129 pub any_ambiguous: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
1130 pub vector_of_enums: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Color>>>,
1131 pub signed_enum: Race,
1132 pub testrequirednestedflatbuffer: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
1133 pub scalar_key_sorted_tables: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat<'a>>>>>,
1134 pub native_inline: Option<&'a Test>,
1135 pub long_enum_non_enum_default: LongEnum,
1136 pub long_enum_normal_default: LongEnum,
1137 pub nan_default: f32,
1138 pub inf_default: f32,
1139 pub positive_inf_default: f32,
1140 pub infinity_default: f32,
1141 pub positive_infinity_default: f32,
1142 pub negative_inf_default: f32,
1143 pub negative_infinity_default: f32,
1144 pub double_inf_default: f64,
1145 }
1146 impl<'a> Default for MonsterArgs<'a> {
1147 #[inline]
default() -> Self1148 fn default() -> Self {
1149 MonsterArgs {
1150 pos: None,
1151 mana: 150,
1152 hp: 100,
1153 name: None, // required field
1154 inventory: None,
1155 color: Color::Blue,
1156 test_type: Any::NONE,
1157 test: None,
1158 test4: None,
1159 testarrayofstring: None,
1160 testarrayoftables: None,
1161 enemy: None,
1162 testnestedflatbuffer: None,
1163 testempty: None,
1164 testbool: false,
1165 testhashs32_fnv1: 0,
1166 testhashu32_fnv1: 0,
1167 testhashs64_fnv1: 0,
1168 testhashu64_fnv1: 0,
1169 testhashs32_fnv1a: 0,
1170 testhashu32_fnv1a: 0,
1171 testhashs64_fnv1a: 0,
1172 testhashu64_fnv1a: 0,
1173 testarrayofbools: None,
1174 testf: 3.14159,
1175 testf2: 3.0,
1176 testf3: 0.0,
1177 testarrayofstring2: None,
1178 testarrayofsortedstruct: None,
1179 flex: None,
1180 test5: None,
1181 vector_of_longs: None,
1182 vector_of_doubles: None,
1183 parent_namespace_test: None,
1184 vector_of_referrables: None,
1185 single_weak_reference: 0,
1186 vector_of_weak_references: None,
1187 vector_of_strong_referrables: None,
1188 co_owning_reference: 0,
1189 vector_of_co_owning_references: None,
1190 non_owning_reference: 0,
1191 vector_of_non_owning_references: None,
1192 any_unique_type: AnyUniqueAliases::NONE,
1193 any_unique: None,
1194 any_ambiguous_type: AnyAmbiguousAliases::NONE,
1195 any_ambiguous: None,
1196 vector_of_enums: None,
1197 signed_enum: Race::None,
1198 testrequirednestedflatbuffer: None,
1199 scalar_key_sorted_tables: None,
1200 native_inline: None,
1201 long_enum_non_enum_default: Default::default(),
1202 long_enum_normal_default: LongEnum::LongOne,
1203 nan_default: f32::NAN,
1204 inf_default: f32::INFINITY,
1205 positive_inf_default: f32::INFINITY,
1206 infinity_default: f32::INFINITY,
1207 positive_infinity_default: f32::INFINITY,
1208 negative_inf_default: f32::NEG_INFINITY,
1209 negative_infinity_default: f32::NEG_INFINITY,
1210 double_inf_default: f64::INFINITY,
1211 }
1212 }
1213 }
1214
1215 impl Serialize for Monster<'_> {
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,1216 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1217 where
1218 S: Serializer,
1219 {
1220 let mut s = serializer.serialize_struct("Monster", 62)?;
1221 if let Some(f) = self.pos() {
1222 s.serialize_field("pos", &f)?;
1223 } else {
1224 s.skip_field("pos")?;
1225 }
1226 s.serialize_field("mana", &self.mana())?;
1227 s.serialize_field("hp", &self.hp())?;
1228 s.serialize_field("name", &self.name())?;
1229 if let Some(f) = self.inventory() {
1230 s.serialize_field("inventory", &f)?;
1231 } else {
1232 s.skip_field("inventory")?;
1233 }
1234 s.serialize_field("color", &self.color())?;
1235 s.serialize_field("test_type", &self.test_type())?;
1236 match self.test_type() {
1237 Any::NONE => (),
1238 Any::Monster => {
1239 let f = self.test_as_monster()
1240 .expect("Invalid union table, expected `Any::Monster`.");
1241 s.serialize_field("test", &f)?;
1242 }
1243 Any::TestSimpleTableWithEnum => {
1244 let f = self.test_as_test_simple_table_with_enum()
1245 .expect("Invalid union table, expected `Any::TestSimpleTableWithEnum`.");
1246 s.serialize_field("test", &f)?;
1247 }
1248 Any::MyGame_Example2_Monster => {
1249 let f = self.test_as_my_game_example_2_monster()
1250 .expect("Invalid union table, expected `Any::MyGame_Example2_Monster`.");
1251 s.serialize_field("test", &f)?;
1252 }
1253 _ => unimplemented!(),
1254 }
1255 if let Some(f) = self.test4() {
1256 s.serialize_field("test4", &f)?;
1257 } else {
1258 s.skip_field("test4")?;
1259 }
1260 if let Some(f) = self.testarrayofstring() {
1261 s.serialize_field("testarrayofstring", &f)?;
1262 } else {
1263 s.skip_field("testarrayofstring")?;
1264 }
1265 if let Some(f) = self.testarrayoftables() {
1266 s.serialize_field("testarrayoftables", &f)?;
1267 } else {
1268 s.skip_field("testarrayoftables")?;
1269 }
1270 if let Some(f) = self.enemy() {
1271 s.serialize_field("enemy", &f)?;
1272 } else {
1273 s.skip_field("enemy")?;
1274 }
1275 if let Some(f) = self.testnestedflatbuffer() {
1276 s.serialize_field("testnestedflatbuffer", &f)?;
1277 } else {
1278 s.skip_field("testnestedflatbuffer")?;
1279 }
1280 if let Some(f) = self.testempty() {
1281 s.serialize_field("testempty", &f)?;
1282 } else {
1283 s.skip_field("testempty")?;
1284 }
1285 s.serialize_field("testbool", &self.testbool())?;
1286 s.serialize_field("testhashs32_fnv1", &self.testhashs32_fnv1())?;
1287 s.serialize_field("testhashu32_fnv1", &self.testhashu32_fnv1())?;
1288 s.serialize_field("testhashs64_fnv1", &self.testhashs64_fnv1())?;
1289 s.serialize_field("testhashu64_fnv1", &self.testhashu64_fnv1())?;
1290 s.serialize_field("testhashs32_fnv1a", &self.testhashs32_fnv1a())?;
1291 s.serialize_field("testhashu32_fnv1a", &self.testhashu32_fnv1a())?;
1292 s.serialize_field("testhashs64_fnv1a", &self.testhashs64_fnv1a())?;
1293 s.serialize_field("testhashu64_fnv1a", &self.testhashu64_fnv1a())?;
1294 if let Some(f) = self.testarrayofbools() {
1295 s.serialize_field("testarrayofbools", &f)?;
1296 } else {
1297 s.skip_field("testarrayofbools")?;
1298 }
1299 s.serialize_field("testf", &self.testf())?;
1300 s.serialize_field("testf2", &self.testf2())?;
1301 s.serialize_field("testf3", &self.testf3())?;
1302 if let Some(f) = self.testarrayofstring2() {
1303 s.serialize_field("testarrayofstring2", &f)?;
1304 } else {
1305 s.skip_field("testarrayofstring2")?;
1306 }
1307 if let Some(f) = self.testarrayofsortedstruct() {
1308 s.serialize_field("testarrayofsortedstruct", &f)?;
1309 } else {
1310 s.skip_field("testarrayofsortedstruct")?;
1311 }
1312 if let Some(f) = self.flex() {
1313 s.serialize_field("flex", &f)?;
1314 } else {
1315 s.skip_field("flex")?;
1316 }
1317 if let Some(f) = self.test5() {
1318 s.serialize_field("test5", &f)?;
1319 } else {
1320 s.skip_field("test5")?;
1321 }
1322 if let Some(f) = self.vector_of_longs() {
1323 s.serialize_field("vector_of_longs", &f)?;
1324 } else {
1325 s.skip_field("vector_of_longs")?;
1326 }
1327 if let Some(f) = self.vector_of_doubles() {
1328 s.serialize_field("vector_of_doubles", &f)?;
1329 } else {
1330 s.skip_field("vector_of_doubles")?;
1331 }
1332 if let Some(f) = self.parent_namespace_test() {
1333 s.serialize_field("parent_namespace_test", &f)?;
1334 } else {
1335 s.skip_field("parent_namespace_test")?;
1336 }
1337 if let Some(f) = self.vector_of_referrables() {
1338 s.serialize_field("vector_of_referrables", &f)?;
1339 } else {
1340 s.skip_field("vector_of_referrables")?;
1341 }
1342 s.serialize_field("single_weak_reference", &self.single_weak_reference())?;
1343 if let Some(f) = self.vector_of_weak_references() {
1344 s.serialize_field("vector_of_weak_references", &f)?;
1345 } else {
1346 s.skip_field("vector_of_weak_references")?;
1347 }
1348 if let Some(f) = self.vector_of_strong_referrables() {
1349 s.serialize_field("vector_of_strong_referrables", &f)?;
1350 } else {
1351 s.skip_field("vector_of_strong_referrables")?;
1352 }
1353 s.serialize_field("co_owning_reference", &self.co_owning_reference())?;
1354 if let Some(f) = self.vector_of_co_owning_references() {
1355 s.serialize_field("vector_of_co_owning_references", &f)?;
1356 } else {
1357 s.skip_field("vector_of_co_owning_references")?;
1358 }
1359 s.serialize_field("non_owning_reference", &self.non_owning_reference())?;
1360 if let Some(f) = self.vector_of_non_owning_references() {
1361 s.serialize_field("vector_of_non_owning_references", &f)?;
1362 } else {
1363 s.skip_field("vector_of_non_owning_references")?;
1364 }
1365 s.serialize_field("any_unique_type", &self.any_unique_type())?;
1366 match self.any_unique_type() {
1367 AnyUniqueAliases::NONE => (),
1368 AnyUniqueAliases::M => {
1369 let f = self.any_unique_as_m()
1370 .expect("Invalid union table, expected `AnyUniqueAliases::M`.");
1371 s.serialize_field("any_unique", &f)?;
1372 }
1373 AnyUniqueAliases::TS => {
1374 let f = self.any_unique_as_ts()
1375 .expect("Invalid union table, expected `AnyUniqueAliases::TS`.");
1376 s.serialize_field("any_unique", &f)?;
1377 }
1378 AnyUniqueAliases::M2 => {
1379 let f = self.any_unique_as_m2()
1380 .expect("Invalid union table, expected `AnyUniqueAliases::M2`.");
1381 s.serialize_field("any_unique", &f)?;
1382 }
1383 _ => unimplemented!(),
1384 }
1385 s.serialize_field("any_ambiguous_type", &self.any_ambiguous_type())?;
1386 match self.any_ambiguous_type() {
1387 AnyAmbiguousAliases::NONE => (),
1388 AnyAmbiguousAliases::M1 => {
1389 let f = self.any_ambiguous_as_m1()
1390 .expect("Invalid union table, expected `AnyAmbiguousAliases::M1`.");
1391 s.serialize_field("any_ambiguous", &f)?;
1392 }
1393 AnyAmbiguousAliases::M2 => {
1394 let f = self.any_ambiguous_as_m2()
1395 .expect("Invalid union table, expected `AnyAmbiguousAliases::M2`.");
1396 s.serialize_field("any_ambiguous", &f)?;
1397 }
1398 AnyAmbiguousAliases::M3 => {
1399 let f = self.any_ambiguous_as_m3()
1400 .expect("Invalid union table, expected `AnyAmbiguousAliases::M3`.");
1401 s.serialize_field("any_ambiguous", &f)?;
1402 }
1403 _ => unimplemented!(),
1404 }
1405 if let Some(f) = self.vector_of_enums() {
1406 s.serialize_field("vector_of_enums", &f)?;
1407 } else {
1408 s.skip_field("vector_of_enums")?;
1409 }
1410 s.serialize_field("signed_enum", &self.signed_enum())?;
1411 if let Some(f) = self.testrequirednestedflatbuffer() {
1412 s.serialize_field("testrequirednestedflatbuffer", &f)?;
1413 } else {
1414 s.skip_field("testrequirednestedflatbuffer")?;
1415 }
1416 if let Some(f) = self.scalar_key_sorted_tables() {
1417 s.serialize_field("scalar_key_sorted_tables", &f)?;
1418 } else {
1419 s.skip_field("scalar_key_sorted_tables")?;
1420 }
1421 if let Some(f) = self.native_inline() {
1422 s.serialize_field("native_inline", &f)?;
1423 } else {
1424 s.skip_field("native_inline")?;
1425 }
1426 s.serialize_field("long_enum_non_enum_default", &self.long_enum_non_enum_default())?;
1427 s.serialize_field("long_enum_normal_default", &self.long_enum_normal_default())?;
1428 s.serialize_field("nan_default", &self.nan_default())?;
1429 s.serialize_field("inf_default", &self.inf_default())?;
1430 s.serialize_field("positive_inf_default", &self.positive_inf_default())?;
1431 s.serialize_field("infinity_default", &self.infinity_default())?;
1432 s.serialize_field("positive_infinity_default", &self.positive_infinity_default())?;
1433 s.serialize_field("negative_inf_default", &self.negative_inf_default())?;
1434 s.serialize_field("negative_infinity_default", &self.negative_infinity_default())?;
1435 s.serialize_field("double_inf_default", &self.double_inf_default())?;
1436 s.end()
1437 }
1438 }
1439
1440 pub struct MonsterBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
1441 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
1442 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
1443 }
1444 impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
1445 #[inline]
add_pos(&mut self, pos: &Vec3)1446 pub fn add_pos(&mut self, pos: &Vec3) {
1447 self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
1448 }
1449 #[inline]
add_mana(&mut self, mana: i16)1450 pub fn add_mana(&mut self, mana: i16) {
1451 self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
1452 }
1453 #[inline]
add_hp(&mut self, hp: i16)1454 pub fn add_hp(&mut self, hp: i16) {
1455 self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
1456 }
1457 #[inline]
add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>)1458 pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
1459 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
1460 }
1461 #[inline]
add_inventory(&mut self, inventory: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>)1462 pub fn add_inventory(&mut self, inventory: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
1463 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
1464 }
1465 #[inline]
add_color(&mut self, color: Color)1466 pub fn add_color(&mut self, color: Color) {
1467 self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
1468 }
1469 #[inline]
add_test_type(&mut self, test_type: Any)1470 pub fn add_test_type(&mut self, test_type: Any) {
1471 self.fbb_.push_slot::<Any>(Monster::VT_TEST_TYPE, test_type, Any::NONE);
1472 }
1473 #[inline]
add_test(&mut self, test: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>)1474 pub fn add_test(&mut self, test: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
1475 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TEST, test);
1476 }
1477 #[inline]
add_test4(&mut self, test4: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Test>>)1478 pub fn add_test4(&mut self, test4: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Test>>) {
1479 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TEST4, test4);
1480 }
1481 #[inline]
add_testarrayofstring(&mut self, testarrayofstring: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b str>>>)1482 pub fn add_testarrayofstring(&mut self, testarrayofstring: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b str>>>) {
1483 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING, testarrayofstring);
1484 }
1485 #[inline]
add_testarrayoftables(&mut self, testarrayoftables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Monster<'b >>>>)1486 pub fn add_testarrayoftables(&mut self, testarrayoftables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Monster<'b >>>>) {
1487 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFTABLES, testarrayoftables);
1488 }
1489 #[inline]
add_enemy(&mut self, enemy: flatbuffers::WIPOffset<Monster<'b >>)1490 pub fn add_enemy(&mut self, enemy: flatbuffers::WIPOffset<Monster<'b >>) {
1491 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Monster>>(Monster::VT_ENEMY, enemy);
1492 }
1493 #[inline]
add_testnestedflatbuffer(&mut self, testnestedflatbuffer: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>)1494 pub fn add_testnestedflatbuffer(&mut self, testnestedflatbuffer: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
1495 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer);
1496 }
1497 #[inline]
add_testempty(&mut self, testempty: flatbuffers::WIPOffset<Stat<'b >>)1498 pub fn add_testempty(&mut self, testempty: flatbuffers::WIPOffset<Stat<'b >>) {
1499 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Stat>>(Monster::VT_TESTEMPTY, testempty);
1500 }
1501 #[inline]
add_testbool(&mut self, testbool: bool)1502 pub fn add_testbool(&mut self, testbool: bool) {
1503 self.fbb_.push_slot::<bool>(Monster::VT_TESTBOOL, testbool, false);
1504 }
1505 #[inline]
add_testhashs32_fnv1(&mut self, testhashs32_fnv1: i32)1506 pub fn add_testhashs32_fnv1(&mut self, testhashs32_fnv1: i32) {
1507 self.fbb_.push_slot::<i32>(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0);
1508 }
1509 #[inline]
add_testhashu32_fnv1(&mut self, testhashu32_fnv1: u32)1510 pub fn add_testhashu32_fnv1(&mut self, testhashu32_fnv1: u32) {
1511 self.fbb_.push_slot::<u32>(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0);
1512 }
1513 #[inline]
add_testhashs64_fnv1(&mut self, testhashs64_fnv1: i64)1514 pub fn add_testhashs64_fnv1(&mut self, testhashs64_fnv1: i64) {
1515 self.fbb_.push_slot::<i64>(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0);
1516 }
1517 #[inline]
add_testhashu64_fnv1(&mut self, testhashu64_fnv1: u64)1518 pub fn add_testhashu64_fnv1(&mut self, testhashu64_fnv1: u64) {
1519 self.fbb_.push_slot::<u64>(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0);
1520 }
1521 #[inline]
add_testhashs32_fnv1a(&mut self, testhashs32_fnv1a: i32)1522 pub fn add_testhashs32_fnv1a(&mut self, testhashs32_fnv1a: i32) {
1523 self.fbb_.push_slot::<i32>(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0);
1524 }
1525 #[inline]
add_testhashu32_fnv1a(&mut self, testhashu32_fnv1a: u32)1526 pub fn add_testhashu32_fnv1a(&mut self, testhashu32_fnv1a: u32) {
1527 self.fbb_.push_slot::<u32>(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0);
1528 }
1529 #[inline]
add_testhashs64_fnv1a(&mut self, testhashs64_fnv1a: i64)1530 pub fn add_testhashs64_fnv1a(&mut self, testhashs64_fnv1a: i64) {
1531 self.fbb_.push_slot::<i64>(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0);
1532 }
1533 #[inline]
add_testhashu64_fnv1a(&mut self, testhashu64_fnv1a: u64)1534 pub fn add_testhashu64_fnv1a(&mut self, testhashu64_fnv1a: u64) {
1535 self.fbb_.push_slot::<u64>(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0);
1536 }
1537 #[inline]
add_testarrayofbools(&mut self, testarrayofbools: flatbuffers::WIPOffset<flatbuffers::Vector<'b , bool>>)1538 pub fn add_testarrayofbools(&mut self, testarrayofbools: flatbuffers::WIPOffset<flatbuffers::Vector<'b , bool>>) {
1539 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools);
1540 }
1541 #[inline]
add_testf(&mut self, testf: f32)1542 pub fn add_testf(&mut self, testf: f32) {
1543 self.fbb_.push_slot::<f32>(Monster::VT_TESTF, testf, 3.14159);
1544 }
1545 #[inline]
add_testf2(&mut self, testf2: f32)1546 pub fn add_testf2(&mut self, testf2: f32) {
1547 self.fbb_.push_slot::<f32>(Monster::VT_TESTF2, testf2, 3.0);
1548 }
1549 #[inline]
add_testf3(&mut self, testf3: f32)1550 pub fn add_testf3(&mut self, testf3: f32) {
1551 self.fbb_.push_slot::<f32>(Monster::VT_TESTF3, testf3, 0.0);
1552 }
1553 #[inline]
add_testarrayofstring2(&mut self, testarrayofstring2: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b str>>>)1554 pub fn add_testarrayofstring2(&mut self, testarrayofstring2: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b str>>>) {
1555 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2);
1556 }
1557 #[inline]
add_testarrayofsortedstruct(&mut self, testarrayofsortedstruct: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Ability>>)1558 pub fn add_testarrayofsortedstruct(&mut self, testarrayofsortedstruct: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Ability>>) {
1559 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct);
1560 }
1561 #[inline]
add_flex(&mut self, flex: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>)1562 pub fn add_flex(&mut self, flex: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
1563 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_FLEX, flex);
1564 }
1565 #[inline]
add_test5(&mut self, test5: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Test>>)1566 pub fn add_test5(&mut self, test5: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Test>>) {
1567 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TEST5, test5);
1568 }
1569 #[inline]
add_vector_of_longs(&mut self, vector_of_longs: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i64>>)1570 pub fn add_vector_of_longs(&mut self, vector_of_longs: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i64>>) {
1571 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_LONGS, vector_of_longs);
1572 }
1573 #[inline]
add_vector_of_doubles(&mut self, vector_of_doubles: flatbuffers::WIPOffset<flatbuffers::Vector<'b , f64>>)1574 pub fn add_vector_of_doubles(&mut self, vector_of_doubles: flatbuffers::WIPOffset<flatbuffers::Vector<'b , f64>>) {
1575 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles);
1576 }
1577 #[inline]
add_parent_namespace_test(&mut self, parent_namespace_test: flatbuffers::WIPOffset<super::InParentNamespace<'b >>)1578 pub fn add_parent_namespace_test(&mut self, parent_namespace_test: flatbuffers::WIPOffset<super::InParentNamespace<'b >>) {
1579 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<super::InParentNamespace>>(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test);
1580 }
1581 #[inline]
add_vector_of_referrables(&mut self, vector_of_referrables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Referrable<'b >>>>)1582 pub fn add_vector_of_referrables(&mut self, vector_of_referrables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Referrable<'b >>>>) {
1583 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables);
1584 }
1585 #[inline]
add_single_weak_reference(&mut self, single_weak_reference: u64)1586 pub fn add_single_weak_reference(&mut self, single_weak_reference: u64) {
1587 self.fbb_.push_slot::<u64>(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0);
1588 }
1589 #[inline]
add_vector_of_weak_references(&mut self, vector_of_weak_references: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u64>>)1590 pub fn add_vector_of_weak_references(&mut self, vector_of_weak_references: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u64>>) {
1591 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references);
1592 }
1593 #[inline]
add_vector_of_strong_referrables(&mut self, vector_of_strong_referrables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Referrable<'b >>>>)1594 pub fn add_vector_of_strong_referrables(&mut self, vector_of_strong_referrables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Referrable<'b >>>>) {
1595 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables);
1596 }
1597 #[inline]
add_co_owning_reference(&mut self, co_owning_reference: u64)1598 pub fn add_co_owning_reference(&mut self, co_owning_reference: u64) {
1599 self.fbb_.push_slot::<u64>(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0);
1600 }
1601 #[inline]
add_vector_of_co_owning_references(&mut self, vector_of_co_owning_references: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u64>>)1602 pub fn add_vector_of_co_owning_references(&mut self, vector_of_co_owning_references: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u64>>) {
1603 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references);
1604 }
1605 #[inline]
add_non_owning_reference(&mut self, non_owning_reference: u64)1606 pub fn add_non_owning_reference(&mut self, non_owning_reference: u64) {
1607 self.fbb_.push_slot::<u64>(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0);
1608 }
1609 #[inline]
add_vector_of_non_owning_references(&mut self, vector_of_non_owning_references: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u64>>)1610 pub fn add_vector_of_non_owning_references(&mut self, vector_of_non_owning_references: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u64>>) {
1611 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references);
1612 }
1613 #[inline]
add_any_unique_type(&mut self, any_unique_type: AnyUniqueAliases)1614 pub fn add_any_unique_type(&mut self, any_unique_type: AnyUniqueAliases) {
1615 self.fbb_.push_slot::<AnyUniqueAliases>(Monster::VT_ANY_UNIQUE_TYPE, any_unique_type, AnyUniqueAliases::NONE);
1616 }
1617 #[inline]
add_any_unique(&mut self, any_unique: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>)1618 pub fn add_any_unique(&mut self, any_unique: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
1619 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_ANY_UNIQUE, any_unique);
1620 }
1621 #[inline]
add_any_ambiguous_type(&mut self, any_ambiguous_type: AnyAmbiguousAliases)1622 pub fn add_any_ambiguous_type(&mut self, any_ambiguous_type: AnyAmbiguousAliases) {
1623 self.fbb_.push_slot::<AnyAmbiguousAliases>(Monster::VT_ANY_AMBIGUOUS_TYPE, any_ambiguous_type, AnyAmbiguousAliases::NONE);
1624 }
1625 #[inline]
add_any_ambiguous(&mut self, any_ambiguous: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>)1626 pub fn add_any_ambiguous(&mut self, any_ambiguous: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
1627 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_ANY_AMBIGUOUS, any_ambiguous);
1628 }
1629 #[inline]
add_vector_of_enums(&mut self, vector_of_enums: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Color>>)1630 pub fn add_vector_of_enums(&mut self, vector_of_enums: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Color>>) {
1631 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums);
1632 }
1633 #[inline]
add_signed_enum(&mut self, signed_enum: Race)1634 pub fn add_signed_enum(&mut self, signed_enum: Race) {
1635 self.fbb_.push_slot::<Race>(Monster::VT_SIGNED_ENUM, signed_enum, Race::None);
1636 }
1637 #[inline]
add_testrequirednestedflatbuffer(&mut self, testrequirednestedflatbuffer: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>)1638 pub fn add_testrequirednestedflatbuffer(&mut self, testrequirednestedflatbuffer: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
1639 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
1640 }
1641 #[inline]
add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Stat<'b >>>>)1642 pub fn add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Stat<'b >>>>) {
1643 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
1644 }
1645 #[inline]
add_native_inline(&mut self, native_inline: &Test)1646 pub fn add_native_inline(&mut self, native_inline: &Test) {
1647 self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline);
1648 }
1649 #[inline]
add_long_enum_non_enum_default(&mut self, long_enum_non_enum_default: LongEnum)1650 pub fn add_long_enum_non_enum_default(&mut self, long_enum_non_enum_default: LongEnum) {
1651 self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, long_enum_non_enum_default, Default::default());
1652 }
1653 #[inline]
add_long_enum_normal_default(&mut self, long_enum_normal_default: LongEnum)1654 pub fn add_long_enum_normal_default(&mut self, long_enum_normal_default: LongEnum) {
1655 self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne);
1656 }
1657 #[inline]
add_nan_default(&mut self, nan_default: f32)1658 pub fn add_nan_default(&mut self, nan_default: f32) {
1659 self.fbb_.push_slot::<f32>(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN);
1660 }
1661 #[inline]
add_inf_default(&mut self, inf_default: f32)1662 pub fn add_inf_default(&mut self, inf_default: f32) {
1663 self.fbb_.push_slot::<f32>(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY);
1664 }
1665 #[inline]
add_positive_inf_default(&mut self, positive_inf_default: f32)1666 pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) {
1667 self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY);
1668 }
1669 #[inline]
add_infinity_default(&mut self, infinity_default: f32)1670 pub fn add_infinity_default(&mut self, infinity_default: f32) {
1671 self.fbb_.push_slot::<f32>(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY);
1672 }
1673 #[inline]
add_positive_infinity_default(&mut self, positive_infinity_default: f32)1674 pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) {
1675 self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY);
1676 }
1677 #[inline]
add_negative_inf_default(&mut self, negative_inf_default: f32)1678 pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) {
1679 self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY);
1680 }
1681 #[inline]
add_negative_infinity_default(&mut self, negative_infinity_default: f32)1682 pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) {
1683 self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY);
1684 }
1685 #[inline]
add_double_inf_default(&mut self, double_inf_default: f64)1686 pub fn add_double_inf_default(&mut self, double_inf_default: f64) {
1687 self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY);
1688 }
1689 #[inline]
new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A>1690 pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
1691 let start = _fbb.start_table();
1692 MonsterBuilder {
1693 fbb_: _fbb,
1694 start_: start,
1695 }
1696 }
1697 #[inline]
finish(self) -> flatbuffers::WIPOffset<Monster<'a>>1698 pub fn finish(self) -> flatbuffers::WIPOffset<Monster<'a>> {
1699 let o = self.fbb_.end_table(self.start_);
1700 self.fbb_.required(o, Monster::VT_NAME,"name");
1701 flatbuffers::WIPOffset::new(o.value())
1702 }
1703 }
1704
1705 impl core::fmt::Debug for Monster<'_> {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result1706 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1707 let mut ds = f.debug_struct("Monster");
1708 ds.field("pos", &self.pos());
1709 ds.field("mana", &self.mana());
1710 ds.field("hp", &self.hp());
1711 ds.field("name", &self.name());
1712 ds.field("inventory", &self.inventory());
1713 ds.field("color", &self.color());
1714 ds.field("test_type", &self.test_type());
1715 match self.test_type() {
1716 Any::Monster => {
1717 if let Some(x) = self.test_as_monster() {
1718 ds.field("test", &x)
1719 } else {
1720 ds.field("test", &"InvalidFlatbuffer: Union discriminant does not match value.")
1721 }
1722 },
1723 Any::TestSimpleTableWithEnum => {
1724 if let Some(x) = self.test_as_test_simple_table_with_enum() {
1725 ds.field("test", &x)
1726 } else {
1727 ds.field("test", &"InvalidFlatbuffer: Union discriminant does not match value.")
1728 }
1729 },
1730 Any::MyGame_Example2_Monster => {
1731 if let Some(x) = self.test_as_my_game_example_2_monster() {
1732 ds.field("test", &x)
1733 } else {
1734 ds.field("test", &"InvalidFlatbuffer: Union discriminant does not match value.")
1735 }
1736 },
1737 _ => {
1738 let x: Option<()> = None;
1739 ds.field("test", &x)
1740 },
1741 };
1742 ds.field("test4", &self.test4());
1743 ds.field("testarrayofstring", &self.testarrayofstring());
1744 ds.field("testarrayoftables", &self.testarrayoftables());
1745 ds.field("enemy", &self.enemy());
1746 ds.field("testnestedflatbuffer", &self.testnestedflatbuffer());
1747 ds.field("testempty", &self.testempty());
1748 ds.field("testbool", &self.testbool());
1749 ds.field("testhashs32_fnv1", &self.testhashs32_fnv1());
1750 ds.field("testhashu32_fnv1", &self.testhashu32_fnv1());
1751 ds.field("testhashs64_fnv1", &self.testhashs64_fnv1());
1752 ds.field("testhashu64_fnv1", &self.testhashu64_fnv1());
1753 ds.field("testhashs32_fnv1a", &self.testhashs32_fnv1a());
1754 ds.field("testhashu32_fnv1a", &self.testhashu32_fnv1a());
1755 ds.field("testhashs64_fnv1a", &self.testhashs64_fnv1a());
1756 ds.field("testhashu64_fnv1a", &self.testhashu64_fnv1a());
1757 ds.field("testarrayofbools", &self.testarrayofbools());
1758 ds.field("testf", &self.testf());
1759 ds.field("testf2", &self.testf2());
1760 ds.field("testf3", &self.testf3());
1761 ds.field("testarrayofstring2", &self.testarrayofstring2());
1762 ds.field("testarrayofsortedstruct", &self.testarrayofsortedstruct());
1763 ds.field("flex", &self.flex());
1764 ds.field("test5", &self.test5());
1765 ds.field("vector_of_longs", &self.vector_of_longs());
1766 ds.field("vector_of_doubles", &self.vector_of_doubles());
1767 ds.field("parent_namespace_test", &self.parent_namespace_test());
1768 ds.field("vector_of_referrables", &self.vector_of_referrables());
1769 ds.field("single_weak_reference", &self.single_weak_reference());
1770 ds.field("vector_of_weak_references", &self.vector_of_weak_references());
1771 ds.field("vector_of_strong_referrables", &self.vector_of_strong_referrables());
1772 ds.field("co_owning_reference", &self.co_owning_reference());
1773 ds.field("vector_of_co_owning_references", &self.vector_of_co_owning_references());
1774 ds.field("non_owning_reference", &self.non_owning_reference());
1775 ds.field("vector_of_non_owning_references", &self.vector_of_non_owning_references());
1776 ds.field("any_unique_type", &self.any_unique_type());
1777 match self.any_unique_type() {
1778 AnyUniqueAliases::M => {
1779 if let Some(x) = self.any_unique_as_m() {
1780 ds.field("any_unique", &x)
1781 } else {
1782 ds.field("any_unique", &"InvalidFlatbuffer: Union discriminant does not match value.")
1783 }
1784 },
1785 AnyUniqueAliases::TS => {
1786 if let Some(x) = self.any_unique_as_ts() {
1787 ds.field("any_unique", &x)
1788 } else {
1789 ds.field("any_unique", &"InvalidFlatbuffer: Union discriminant does not match value.")
1790 }
1791 },
1792 AnyUniqueAliases::M2 => {
1793 if let Some(x) = self.any_unique_as_m2() {
1794 ds.field("any_unique", &x)
1795 } else {
1796 ds.field("any_unique", &"InvalidFlatbuffer: Union discriminant does not match value.")
1797 }
1798 },
1799 _ => {
1800 let x: Option<()> = None;
1801 ds.field("any_unique", &x)
1802 },
1803 };
1804 ds.field("any_ambiguous_type", &self.any_ambiguous_type());
1805 match self.any_ambiguous_type() {
1806 AnyAmbiguousAliases::M1 => {
1807 if let Some(x) = self.any_ambiguous_as_m1() {
1808 ds.field("any_ambiguous", &x)
1809 } else {
1810 ds.field("any_ambiguous", &"InvalidFlatbuffer: Union discriminant does not match value.")
1811 }
1812 },
1813 AnyAmbiguousAliases::M2 => {
1814 if let Some(x) = self.any_ambiguous_as_m2() {
1815 ds.field("any_ambiguous", &x)
1816 } else {
1817 ds.field("any_ambiguous", &"InvalidFlatbuffer: Union discriminant does not match value.")
1818 }
1819 },
1820 AnyAmbiguousAliases::M3 => {
1821 if let Some(x) = self.any_ambiguous_as_m3() {
1822 ds.field("any_ambiguous", &x)
1823 } else {
1824 ds.field("any_ambiguous", &"InvalidFlatbuffer: Union discriminant does not match value.")
1825 }
1826 },
1827 _ => {
1828 let x: Option<()> = None;
1829 ds.field("any_ambiguous", &x)
1830 },
1831 };
1832 ds.field("vector_of_enums", &self.vector_of_enums());
1833 ds.field("signed_enum", &self.signed_enum());
1834 ds.field("testrequirednestedflatbuffer", &self.testrequirednestedflatbuffer());
1835 ds.field("scalar_key_sorted_tables", &self.scalar_key_sorted_tables());
1836 ds.field("native_inline", &self.native_inline());
1837 ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default());
1838 ds.field("long_enum_normal_default", &self.long_enum_normal_default());
1839 ds.field("nan_default", &self.nan_default());
1840 ds.field("inf_default", &self.inf_default());
1841 ds.field("positive_inf_default", &self.positive_inf_default());
1842 ds.field("infinity_default", &self.infinity_default());
1843 ds.field("positive_infinity_default", &self.positive_infinity_default());
1844 ds.field("negative_inf_default", &self.negative_inf_default());
1845 ds.field("negative_infinity_default", &self.negative_infinity_default());
1846 ds.field("double_inf_default", &self.double_inf_default());
1847 ds.finish()
1848 }
1849 }
1850 #[non_exhaustive]
1851 #[derive(Debug, Clone, PartialEq)]
1852 pub struct MonsterT {
1853 pub pos: Option<Vec3T>,
1854 pub mana: i16,
1855 pub hp: i16,
1856 pub name: String,
1857 pub inventory: Option<Vec<u8>>,
1858 pub color: Color,
1859 pub test: AnyT,
1860 pub test4: Option<Vec<TestT>>,
1861 pub testarrayofstring: Option<Vec<String>>,
1862 pub testarrayoftables: Option<Vec<MonsterT>>,
1863 pub enemy: Option<Box<MonsterT>>,
1864 pub testnestedflatbuffer: Option<Vec<u8>>,
1865 pub testempty: Option<Box<StatT>>,
1866 pub testbool: bool,
1867 pub testhashs32_fnv1: i32,
1868 pub testhashu32_fnv1: u32,
1869 pub testhashs64_fnv1: i64,
1870 pub testhashu64_fnv1: u64,
1871 pub testhashs32_fnv1a: i32,
1872 pub testhashu32_fnv1a: u32,
1873 pub testhashs64_fnv1a: i64,
1874 pub testhashu64_fnv1a: u64,
1875 pub testarrayofbools: Option<Vec<bool>>,
1876 pub testf: f32,
1877 pub testf2: f32,
1878 pub testf3: f32,
1879 pub testarrayofstring2: Option<Vec<String>>,
1880 pub testarrayofsortedstruct: Option<Vec<AbilityT>>,
1881 pub flex: Option<Vec<u8>>,
1882 pub test5: Option<Vec<TestT>>,
1883 pub vector_of_longs: Option<Vec<i64>>,
1884 pub vector_of_doubles: Option<Vec<f64>>,
1885 pub parent_namespace_test: Option<Box<super::InParentNamespaceT>>,
1886 pub vector_of_referrables: Option<Vec<ReferrableT>>,
1887 pub single_weak_reference: u64,
1888 pub vector_of_weak_references: Option<Vec<u64>>,
1889 pub vector_of_strong_referrables: Option<Vec<ReferrableT>>,
1890 pub co_owning_reference: u64,
1891 pub vector_of_co_owning_references: Option<Vec<u64>>,
1892 pub non_owning_reference: u64,
1893 pub vector_of_non_owning_references: Option<Vec<u64>>,
1894 pub any_unique: AnyUniqueAliasesT,
1895 pub any_ambiguous: AnyAmbiguousAliasesT,
1896 pub vector_of_enums: Option<Vec<Color>>,
1897 pub signed_enum: Race,
1898 pub testrequirednestedflatbuffer: Option<Vec<u8>>,
1899 pub scalar_key_sorted_tables: Option<Vec<StatT>>,
1900 pub native_inline: Option<TestT>,
1901 pub long_enum_non_enum_default: LongEnum,
1902 pub long_enum_normal_default: LongEnum,
1903 pub nan_default: f32,
1904 pub inf_default: f32,
1905 pub positive_inf_default: f32,
1906 pub infinity_default: f32,
1907 pub positive_infinity_default: f32,
1908 pub negative_inf_default: f32,
1909 pub negative_infinity_default: f32,
1910 pub double_inf_default: f64,
1911 }
1912 impl Default for MonsterT {
default() -> Self1913 fn default() -> Self {
1914 Self {
1915 pos: None,
1916 mana: 150,
1917 hp: 100,
1918 name: "".to_string(),
1919 inventory: None,
1920 color: Color::Blue,
1921 test: AnyT::NONE,
1922 test4: None,
1923 testarrayofstring: None,
1924 testarrayoftables: None,
1925 enemy: None,
1926 testnestedflatbuffer: None,
1927 testempty: None,
1928 testbool: false,
1929 testhashs32_fnv1: 0,
1930 testhashu32_fnv1: 0,
1931 testhashs64_fnv1: 0,
1932 testhashu64_fnv1: 0,
1933 testhashs32_fnv1a: 0,
1934 testhashu32_fnv1a: 0,
1935 testhashs64_fnv1a: 0,
1936 testhashu64_fnv1a: 0,
1937 testarrayofbools: None,
1938 testf: 3.14159,
1939 testf2: 3.0,
1940 testf3: 0.0,
1941 testarrayofstring2: None,
1942 testarrayofsortedstruct: None,
1943 flex: None,
1944 test5: None,
1945 vector_of_longs: None,
1946 vector_of_doubles: None,
1947 parent_namespace_test: None,
1948 vector_of_referrables: None,
1949 single_weak_reference: 0,
1950 vector_of_weak_references: None,
1951 vector_of_strong_referrables: None,
1952 co_owning_reference: 0,
1953 vector_of_co_owning_references: None,
1954 non_owning_reference: 0,
1955 vector_of_non_owning_references: None,
1956 any_unique: AnyUniqueAliasesT::NONE,
1957 any_ambiguous: AnyAmbiguousAliasesT::NONE,
1958 vector_of_enums: None,
1959 signed_enum: Race::None,
1960 testrequirednestedflatbuffer: None,
1961 scalar_key_sorted_tables: None,
1962 native_inline: None,
1963 long_enum_non_enum_default: Default::default(),
1964 long_enum_normal_default: LongEnum::LongOne,
1965 nan_default: f32::NAN,
1966 inf_default: f32::INFINITY,
1967 positive_inf_default: f32::INFINITY,
1968 infinity_default: f32::INFINITY,
1969 positive_infinity_default: f32::INFINITY,
1970 negative_inf_default: f32::NEG_INFINITY,
1971 negative_infinity_default: f32::NEG_INFINITY,
1972 double_inf_default: f64::INFINITY,
1973 }
1974 }
1975 }
1976 impl MonsterT {
pack<'b, A: flatbuffers::Allocator + 'b>( &self, _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A> ) -> flatbuffers::WIPOffset<Monster<'b>>1977 pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
1978 &self,
1979 _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
1980 ) -> flatbuffers::WIPOffset<Monster<'b>> {
1981 let pos_tmp = self.pos.as_ref().map(|x| x.pack());
1982 let pos = pos_tmp.as_ref();
1983 let mana = self.mana;
1984 let hp = self.hp;
1985 let name = Some({
1986 let x = &self.name;
1987 _fbb.create_string(x)
1988 });
1989 let inventory = self.inventory.as_ref().map(|x|{
1990 _fbb.create_vector(x)
1991 });
1992 let color = self.color;
1993 let test_type = self.test.any_type();
1994 let test = self.test.pack(_fbb);
1995 let test4 = self.test4.as_ref().map(|x|{
1996 let w: Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
1997 });
1998 let testarrayofstring = self.testarrayofstring.as_ref().map(|x|{
1999 let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
2000 });
2001 let testarrayoftables = self.testarrayoftables.as_ref().map(|x|{
2002 let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
2003 });
2004 let enemy = self.enemy.as_ref().map(|x|{
2005 x.pack(_fbb)
2006 });
2007 let testnestedflatbuffer = self.testnestedflatbuffer.as_ref().map(|x|{
2008 _fbb.create_vector(x)
2009 });
2010 let testempty = self.testempty.as_ref().map(|x|{
2011 x.pack(_fbb)
2012 });
2013 let testbool = self.testbool;
2014 let testhashs32_fnv1 = self.testhashs32_fnv1;
2015 let testhashu32_fnv1 = self.testhashu32_fnv1;
2016 let testhashs64_fnv1 = self.testhashs64_fnv1;
2017 let testhashu64_fnv1 = self.testhashu64_fnv1;
2018 let testhashs32_fnv1a = self.testhashs32_fnv1a;
2019 let testhashu32_fnv1a = self.testhashu32_fnv1a;
2020 let testhashs64_fnv1a = self.testhashs64_fnv1a;
2021 let testhashu64_fnv1a = self.testhashu64_fnv1a;
2022 let testarrayofbools = self.testarrayofbools.as_ref().map(|x|{
2023 _fbb.create_vector(x)
2024 });
2025 let testf = self.testf;
2026 let testf2 = self.testf2;
2027 let testf3 = self.testf3;
2028 let testarrayofstring2 = self.testarrayofstring2.as_ref().map(|x|{
2029 let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
2030 });
2031 let testarrayofsortedstruct = self.testarrayofsortedstruct.as_ref().map(|x|{
2032 let w: Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
2033 });
2034 let flex = self.flex.as_ref().map(|x|{
2035 _fbb.create_vector(x)
2036 });
2037 let test5 = self.test5.as_ref().map(|x|{
2038 let w: Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
2039 });
2040 let vector_of_longs = self.vector_of_longs.as_ref().map(|x|{
2041 _fbb.create_vector(x)
2042 });
2043 let vector_of_doubles = self.vector_of_doubles.as_ref().map(|x|{
2044 _fbb.create_vector(x)
2045 });
2046 let parent_namespace_test = self.parent_namespace_test.as_ref().map(|x|{
2047 x.pack(_fbb)
2048 });
2049 let vector_of_referrables = self.vector_of_referrables.as_ref().map(|x|{
2050 let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
2051 });
2052 let single_weak_reference = self.single_weak_reference;
2053 let vector_of_weak_references = self.vector_of_weak_references.as_ref().map(|x|{
2054 _fbb.create_vector(x)
2055 });
2056 let vector_of_strong_referrables = self.vector_of_strong_referrables.as_ref().map(|x|{
2057 let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
2058 });
2059 let co_owning_reference = self.co_owning_reference;
2060 let vector_of_co_owning_references = self.vector_of_co_owning_references.as_ref().map(|x|{
2061 _fbb.create_vector(x)
2062 });
2063 let non_owning_reference = self.non_owning_reference;
2064 let vector_of_non_owning_references = self.vector_of_non_owning_references.as_ref().map(|x|{
2065 _fbb.create_vector(x)
2066 });
2067 let any_unique_type = self.any_unique.any_unique_aliases_type();
2068 let any_unique = self.any_unique.pack(_fbb);
2069 let any_ambiguous_type = self.any_ambiguous.any_ambiguous_aliases_type();
2070 let any_ambiguous = self.any_ambiguous.pack(_fbb);
2071 let vector_of_enums = self.vector_of_enums.as_ref().map(|x|{
2072 _fbb.create_vector(x)
2073 });
2074 let signed_enum = self.signed_enum;
2075 let testrequirednestedflatbuffer = self.testrequirednestedflatbuffer.as_ref().map(|x|{
2076 _fbb.create_vector(x)
2077 });
2078 let scalar_key_sorted_tables = self.scalar_key_sorted_tables.as_ref().map(|x|{
2079 let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
2080 });
2081 let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack());
2082 let native_inline = native_inline_tmp.as_ref();
2083 let long_enum_non_enum_default = self.long_enum_non_enum_default;
2084 let long_enum_normal_default = self.long_enum_normal_default;
2085 let nan_default = self.nan_default;
2086 let inf_default = self.inf_default;
2087 let positive_inf_default = self.positive_inf_default;
2088 let infinity_default = self.infinity_default;
2089 let positive_infinity_default = self.positive_infinity_default;
2090 let negative_inf_default = self.negative_inf_default;
2091 let negative_infinity_default = self.negative_infinity_default;
2092 let double_inf_default = self.double_inf_default;
2093 Monster::create(_fbb, &MonsterArgs{
2094 pos,
2095 mana,
2096 hp,
2097 name,
2098 inventory,
2099 color,
2100 test_type,
2101 test,
2102 test4,
2103 testarrayofstring,
2104 testarrayoftables,
2105 enemy,
2106 testnestedflatbuffer,
2107 testempty,
2108 testbool,
2109 testhashs32_fnv1,
2110 testhashu32_fnv1,
2111 testhashs64_fnv1,
2112 testhashu64_fnv1,
2113 testhashs32_fnv1a,
2114 testhashu32_fnv1a,
2115 testhashs64_fnv1a,
2116 testhashu64_fnv1a,
2117 testarrayofbools,
2118 testf,
2119 testf2,
2120 testf3,
2121 testarrayofstring2,
2122 testarrayofsortedstruct,
2123 flex,
2124 test5,
2125 vector_of_longs,
2126 vector_of_doubles,
2127 parent_namespace_test,
2128 vector_of_referrables,
2129 single_weak_reference,
2130 vector_of_weak_references,
2131 vector_of_strong_referrables,
2132 co_owning_reference,
2133 vector_of_co_owning_references,
2134 non_owning_reference,
2135 vector_of_non_owning_references,
2136 any_unique_type,
2137 any_unique,
2138 any_ambiguous_type,
2139 any_ambiguous,
2140 vector_of_enums,
2141 signed_enum,
2142 testrequirednestedflatbuffer,
2143 scalar_key_sorted_tables,
2144 native_inline,
2145 long_enum_non_enum_default,
2146 long_enum_normal_default,
2147 nan_default,
2148 inf_default,
2149 positive_inf_default,
2150 infinity_default,
2151 positive_infinity_default,
2152 negative_inf_default,
2153 negative_infinity_default,
2154 double_inf_default,
2155 })
2156 }
2157 }
2158 #[inline]
2159 /// Verifies that a buffer of bytes contains a `Monster`
2160 /// and returns it.
2161 /// Note that verification is still experimental and may not
2162 /// catch every error, or be maximally performant. For the
2163 /// previous, unchecked, behavior use
2164 /// `root_as_monster_unchecked`.
root_as_monster(buf: &[u8]) -> Result<Monster, flatbuffers::InvalidFlatbuffer>2165 pub fn root_as_monster(buf: &[u8]) -> Result<Monster, flatbuffers::InvalidFlatbuffer> {
2166 flatbuffers::root::<Monster>(buf)
2167 }
2168 #[inline]
2169 /// Verifies that a buffer of bytes contains a size prefixed
2170 /// `Monster` and returns it.
2171 /// Note that verification is still experimental and may not
2172 /// catch every error, or be maximally performant. For the
2173 /// previous, unchecked, behavior use
2174 /// `size_prefixed_root_as_monster_unchecked`.
size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster, flatbuffers::InvalidFlatbuffer>2175 pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster, flatbuffers::InvalidFlatbuffer> {
2176 flatbuffers::size_prefixed_root::<Monster>(buf)
2177 }
2178 #[inline]
2179 /// Verifies, with the given options, that a buffer of bytes
2180 /// contains a `Monster` and returns it.
2181 /// Note that verification is still experimental and may not
2182 /// catch every error, or be maximally performant. For the
2183 /// previous, unchecked, behavior use
2184 /// `root_as_monster_unchecked`.
root_as_monster_with_opts<'b, 'o>( opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], ) -> Result<Monster<'b>, flatbuffers::InvalidFlatbuffer>2185 pub fn root_as_monster_with_opts<'b, 'o>(
2186 opts: &'o flatbuffers::VerifierOptions,
2187 buf: &'b [u8],
2188 ) -> Result<Monster<'b>, flatbuffers::InvalidFlatbuffer> {
2189 flatbuffers::root_with_opts::<Monster<'b>>(opts, buf)
2190 }
2191 #[inline]
2192 /// Verifies, with the given verifier options, that a buffer of
2193 /// bytes contains a size prefixed `Monster` and returns
2194 /// it. Note that verification is still experimental and may not
2195 /// catch every error, or be maximally performant. For the
2196 /// previous, unchecked, behavior use
2197 /// `root_as_monster_unchecked`.
size_prefixed_root_as_monster_with_opts<'b, 'o>( opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], ) -> Result<Monster<'b>, flatbuffers::InvalidFlatbuffer>2198 pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>(
2199 opts: &'o flatbuffers::VerifierOptions,
2200 buf: &'b [u8],
2201 ) -> Result<Monster<'b>, flatbuffers::InvalidFlatbuffer> {
2202 flatbuffers::size_prefixed_root_with_opts::<Monster<'b>>(opts, buf)
2203 }
2204 #[inline]
2205 /// Assumes, without verification, that a buffer of bytes contains a Monster and returns it.
2206 /// # Safety
2207 /// Callers must trust the given bytes do indeed contain a valid `Monster`.
root_as_monster_unchecked(buf: &[u8]) -> Monster2208 pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster {
2209 flatbuffers::root_unchecked::<Monster>(buf)
2210 }
2211 #[inline]
2212 /// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it.
2213 /// # Safety
2214 /// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`.
size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster2215 pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster {
2216 flatbuffers::size_prefixed_root_unchecked::<Monster>(buf)
2217 }
2218 pub const MONSTER_IDENTIFIER: &str = "MONS";
2219
2220 #[inline]
monster_buffer_has_identifier(buf: &[u8]) -> bool2221 pub fn monster_buffer_has_identifier(buf: &[u8]) -> bool {
2222 flatbuffers::buffer_has_identifier(buf, MONSTER_IDENTIFIER, false)
2223 }
2224
2225 #[inline]
monster_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool2226 pub fn monster_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
2227 flatbuffers::buffer_has_identifier(buf, MONSTER_IDENTIFIER, true)
2228 }
2229
2230 pub const MONSTER_EXTENSION: &str = "mon";
2231
2232 #[inline]
finish_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>( fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Monster<'a>>)2233 pub fn finish_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
2234 fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
2235 root: flatbuffers::WIPOffset<Monster<'a>>) {
2236 fbb.finish(root, Some(MONSTER_IDENTIFIER));
2237 }
2238
2239 #[inline]
finish_size_prefixed_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Monster<'a>>)2240 pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Monster<'a>>) {
2241 fbb.finish_size_prefixed(root, Some(MONSTER_IDENTIFIER));
2242 }
2243