xref: /aosp_15_r20/external/flatbuffers/tests/MyGame/Example/Monster.py (revision 890232f25432b36107d06881e0a25aaa6b473652) 
1# automatically generated by the FlatBuffers compiler, do not modify
2
3# namespace: Example
4
5import flatbuffers
6from flatbuffers.compat import import_numpy
7np = import_numpy()
8
9# an example documentation comment: "monster object"
10class Monster(object):
11    __slots__ = ['_tab']
12
13    @classmethod
14    def GetRootAs(cls, buf, offset=0):
15        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
16        x = Monster()
17        x.Init(buf, n + offset)
18        return x
19
20    @classmethod
21    def GetRootAsMonster(cls, buf, offset=0):
22        """This method is deprecated. Please switch to GetRootAs."""
23        return cls.GetRootAs(buf, offset)
24    @classmethod
25    def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
26        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
27
28    # Monster
29    def Init(self, buf, pos):
30        self._tab = flatbuffers.table.Table(buf, pos)
31
32    # Monster
33    def Pos(self):
34        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
35        if o != 0:
36            x = o + self._tab.Pos
37            from MyGame.Example.Vec3 import Vec3
38            obj = Vec3()
39            obj.Init(self._tab.Bytes, x)
40            return obj
41        return None
42
43    # Monster
44    def Mana(self):
45        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
46        if o != 0:
47            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
48        return 150
49
50    # Monster
51    def Hp(self):
52        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
53        if o != 0:
54            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
55        return 100
56
57    # Monster
58    def Name(self):
59        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
60        if o != 0:
61            return self._tab.String(o + self._tab.Pos)
62        return None
63
64    # Monster
65    def Inventory(self, j):
66        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
67        if o != 0:
68            a = self._tab.Vector(o)
69            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
70        return 0
71
72    # Monster
73    def InventoryAsNumpy(self):
74        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
75        if o != 0:
76            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
77        return 0
78
79    # Monster
80    def InventoryLength(self):
81        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
82        if o != 0:
83            return self._tab.VectorLen(o)
84        return 0
85
86    # Monster
87    def InventoryIsNone(self):
88        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
89        return o == 0
90
91    # Monster
92    def Color(self):
93        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
94        if o != 0:
95            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
96        return 8
97
98    # Monster
99    def TestType(self):
100        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
101        if o != 0:
102            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
103        return 0
104
105    # Monster
106    def Test(self):
107        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
108        if o != 0:
109            from flatbuffers.table import Table
110            obj = Table(bytearray(), 0)
111            self._tab.Union(obj, o)
112            return obj
113        return None
114
115    # Monster
116    def Test4(self, j):
117        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
118        if o != 0:
119            x = self._tab.Vector(o)
120            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
121            from MyGame.Example.Test import Test
122            obj = Test()
123            obj.Init(self._tab.Bytes, x)
124            return obj
125        return None
126
127    # Monster
128    def Test4Length(self):
129        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
130        if o != 0:
131            return self._tab.VectorLen(o)
132        return 0
133
134    # Monster
135    def Test4IsNone(self):
136        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
137        return o == 0
138
139    # Monster
140    def Testarrayofstring(self, j):
141        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
142        if o != 0:
143            a = self._tab.Vector(o)
144            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
145        return ""
146
147    # Monster
148    def TestarrayofstringLength(self):
149        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
150        if o != 0:
151            return self._tab.VectorLen(o)
152        return 0
153
154    # Monster
155    def TestarrayofstringIsNone(self):
156        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
157        return o == 0
158
159    # an example documentation comment: this will end up in the generated code
160    # multiline too
161    # Monster
162    def Testarrayoftables(self, j):
163        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
164        if o != 0:
165            x = self._tab.Vector(o)
166            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
167            x = self._tab.Indirect(x)
168            from MyGame.Example.Monster import Monster
169            obj = Monster()
170            obj.Init(self._tab.Bytes, x)
171            return obj
172        return None
173
174    # Monster
175    def TestarrayoftablesLength(self):
176        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
177        if o != 0:
178            return self._tab.VectorLen(o)
179        return 0
180
181    # Monster
182    def TestarrayoftablesIsNone(self):
183        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
184        return o == 0
185
186    # Monster
187    def Enemy(self):
188        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
189        if o != 0:
190            x = self._tab.Indirect(o + self._tab.Pos)
191            from MyGame.Example.Monster import Monster
192            obj = Monster()
193            obj.Init(self._tab.Bytes, x)
194            return obj
195        return None
196
197    # Monster
198    def Testnestedflatbuffer(self, j):
199        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
200        if o != 0:
201            a = self._tab.Vector(o)
202            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
203        return 0
204
205    # Monster
206    def TestnestedflatbufferAsNumpy(self):
207        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
208        if o != 0:
209            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
210        return 0
211
212    # Monster
213    def TestnestedflatbufferNestedRoot(self):
214        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
215        if o != 0:
216            from MyGame.Example.Monster import Monster
217            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
218        return 0
219
220    # Monster
221    def TestnestedflatbufferLength(self):
222        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
223        if o != 0:
224            return self._tab.VectorLen(o)
225        return 0
226
227    # Monster
228    def TestnestedflatbufferIsNone(self):
229        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
230        return o == 0
231
232    # Monster
233    def Testempty(self):
234        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
235        if o != 0:
236            x = self._tab.Indirect(o + self._tab.Pos)
237            from MyGame.Example.Stat import Stat
238            obj = Stat()
239            obj.Init(self._tab.Bytes, x)
240            return obj
241        return None
242
243    # Monster
244    def Testbool(self):
245        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
246        if o != 0:
247            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
248        return False
249
250    # Monster
251    def Testhashs32Fnv1(self):
252        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
253        if o != 0:
254            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
255        return 0
256
257    # Monster
258    def Testhashu32Fnv1(self):
259        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
260        if o != 0:
261            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
262        return 0
263
264    # Monster
265    def Testhashs64Fnv1(self):
266        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
267        if o != 0:
268            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
269        return 0
270
271    # Monster
272    def Testhashu64Fnv1(self):
273        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
274        if o != 0:
275            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
276        return 0
277
278    # Monster
279    def Testhashs32Fnv1a(self):
280        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
281        if o != 0:
282            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
283        return 0
284
285    # Monster
286    def Testhashu32Fnv1a(self):
287        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
288        if o != 0:
289            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
290        return 0
291
292    # Monster
293    def Testhashs64Fnv1a(self):
294        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
295        if o != 0:
296            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
297        return 0
298
299    # Monster
300    def Testhashu64Fnv1a(self):
301        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
302        if o != 0:
303            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
304        return 0
305
306    # Monster
307    def Testarrayofbools(self, j):
308        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
309        if o != 0:
310            a = self._tab.Vector(o)
311            return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
312        return 0
313
314    # Monster
315    def TestarrayofboolsAsNumpy(self):
316        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
317        if o != 0:
318            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
319        return 0
320
321    # Monster
322    def TestarrayofboolsLength(self):
323        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
324        if o != 0:
325            return self._tab.VectorLen(o)
326        return 0
327
328    # Monster
329    def TestarrayofboolsIsNone(self):
330        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
331        return o == 0
332
333    # Monster
334    def Testf(self):
335        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
336        if o != 0:
337            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
338        return 3.14159
339
340    # Monster
341    def Testf2(self):
342        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
343        if o != 0:
344            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
345        return 3.0
346
347    # Monster
348    def Testf3(self):
349        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
350        if o != 0:
351            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
352        return 0.0
353
354    # Monster
355    def Testarrayofstring2(self, j):
356        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
357        if o != 0:
358            a = self._tab.Vector(o)
359            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
360        return ""
361
362    # Monster
363    def Testarrayofstring2Length(self):
364        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
365        if o != 0:
366            return self._tab.VectorLen(o)
367        return 0
368
369    # Monster
370    def Testarrayofstring2IsNone(self):
371        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
372        return o == 0
373
374    # Monster
375    def Testarrayofsortedstruct(self, j):
376        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
377        if o != 0:
378            x = self._tab.Vector(o)
379            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
380            from MyGame.Example.Ability import Ability
381            obj = Ability()
382            obj.Init(self._tab.Bytes, x)
383            return obj
384        return None
385
386    # Monster
387    def TestarrayofsortedstructLength(self):
388        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
389        if o != 0:
390            return self._tab.VectorLen(o)
391        return 0
392
393    # Monster
394    def TestarrayofsortedstructIsNone(self):
395        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
396        return o == 0
397
398    # Monster
399    def Flex(self, j):
400        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
401        if o != 0:
402            a = self._tab.Vector(o)
403            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
404        return 0
405
406    # Monster
407    def FlexAsNumpy(self):
408        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
409        if o != 0:
410            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
411        return 0
412
413    # Monster
414    def FlexLength(self):
415        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
416        if o != 0:
417            return self._tab.VectorLen(o)
418        return 0
419
420    # Monster
421    def FlexIsNone(self):
422        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
423        return o == 0
424
425    # Monster
426    def Test5(self, j):
427        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
428        if o != 0:
429            x = self._tab.Vector(o)
430            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
431            from MyGame.Example.Test import Test
432            obj = Test()
433            obj.Init(self._tab.Bytes, x)
434            return obj
435        return None
436
437    # Monster
438    def Test5Length(self):
439        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
440        if o != 0:
441            return self._tab.VectorLen(o)
442        return 0
443
444    # Monster
445    def Test5IsNone(self):
446        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
447        return o == 0
448
449    # Monster
450    def VectorOfLongs(self, j):
451        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
452        if o != 0:
453            a = self._tab.Vector(o)
454            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
455        return 0
456
457    # Monster
458    def VectorOfLongsAsNumpy(self):
459        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
460        if o != 0:
461            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
462        return 0
463
464    # Monster
465    def VectorOfLongsLength(self):
466        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
467        if o != 0:
468            return self._tab.VectorLen(o)
469        return 0
470
471    # Monster
472    def VectorOfLongsIsNone(self):
473        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
474        return o == 0
475
476    # Monster
477    def VectorOfDoubles(self, j):
478        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
479        if o != 0:
480            a = self._tab.Vector(o)
481            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
482        return 0
483
484    # Monster
485    def VectorOfDoublesAsNumpy(self):
486        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
487        if o != 0:
488            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
489        return 0
490
491    # Monster
492    def VectorOfDoublesLength(self):
493        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
494        if o != 0:
495            return self._tab.VectorLen(o)
496        return 0
497
498    # Monster
499    def VectorOfDoublesIsNone(self):
500        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
501        return o == 0
502
503    # Monster
504    def ParentNamespaceTest(self):
505        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
506        if o != 0:
507            x = self._tab.Indirect(o + self._tab.Pos)
508            from MyGame.InParentNamespace import InParentNamespace
509            obj = InParentNamespace()
510            obj.Init(self._tab.Bytes, x)
511            return obj
512        return None
513
514    # Monster
515    def VectorOfReferrables(self, j):
516        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
517        if o != 0:
518            x = self._tab.Vector(o)
519            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
520            x = self._tab.Indirect(x)
521            from MyGame.Example.Referrable import Referrable
522            obj = Referrable()
523            obj.Init(self._tab.Bytes, x)
524            return obj
525        return None
526
527    # Monster
528    def VectorOfReferrablesLength(self):
529        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
530        if o != 0:
531            return self._tab.VectorLen(o)
532        return 0
533
534    # Monster
535    def VectorOfReferrablesIsNone(self):
536        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
537        return o == 0
538
539    # Monster
540    def SingleWeakReference(self):
541        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
542        if o != 0:
543            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
544        return 0
545
546    # Monster
547    def VectorOfWeakReferences(self, j):
548        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
549        if o != 0:
550            a = self._tab.Vector(o)
551            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
552        return 0
553
554    # Monster
555    def VectorOfWeakReferencesAsNumpy(self):
556        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
557        if o != 0:
558            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
559        return 0
560
561    # Monster
562    def VectorOfWeakReferencesLength(self):
563        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
564        if o != 0:
565            return self._tab.VectorLen(o)
566        return 0
567
568    # Monster
569    def VectorOfWeakReferencesIsNone(self):
570        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
571        return o == 0
572
573    # Monster
574    def VectorOfStrongReferrables(self, j):
575        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
576        if o != 0:
577            x = self._tab.Vector(o)
578            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
579            x = self._tab.Indirect(x)
580            from MyGame.Example.Referrable import Referrable
581            obj = Referrable()
582            obj.Init(self._tab.Bytes, x)
583            return obj
584        return None
585
586    # Monster
587    def VectorOfStrongReferrablesLength(self):
588        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
589        if o != 0:
590            return self._tab.VectorLen(o)
591        return 0
592
593    # Monster
594    def VectorOfStrongReferrablesIsNone(self):
595        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
596        return o == 0
597
598    # Monster
599    def CoOwningReference(self):
600        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
601        if o != 0:
602            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
603        return 0
604
605    # Monster
606    def VectorOfCoOwningReferences(self, j):
607        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
608        if o != 0:
609            a = self._tab.Vector(o)
610            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
611        return 0
612
613    # Monster
614    def VectorOfCoOwningReferencesAsNumpy(self):
615        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
616        if o != 0:
617            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
618        return 0
619
620    # Monster
621    def VectorOfCoOwningReferencesLength(self):
622        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
623        if o != 0:
624            return self._tab.VectorLen(o)
625        return 0
626
627    # Monster
628    def VectorOfCoOwningReferencesIsNone(self):
629        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
630        return o == 0
631
632    # Monster
633    def NonOwningReference(self):
634        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
635        if o != 0:
636            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
637        return 0
638
639    # Monster
640    def VectorOfNonOwningReferences(self, j):
641        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
642        if o != 0:
643            a = self._tab.Vector(o)
644            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
645        return 0
646
647    # Monster
648    def VectorOfNonOwningReferencesAsNumpy(self):
649        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
650        if o != 0:
651            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
652        return 0
653
654    # Monster
655    def VectorOfNonOwningReferencesLength(self):
656        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
657        if o != 0:
658            return self._tab.VectorLen(o)
659        return 0
660
661    # Monster
662    def VectorOfNonOwningReferencesIsNone(self):
663        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
664        return o == 0
665
666    # Monster
667    def AnyUniqueType(self):
668        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
669        if o != 0:
670            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
671        return 0
672
673    # Monster
674    def AnyUnique(self):
675        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
676        if o != 0:
677            from flatbuffers.table import Table
678            obj = Table(bytearray(), 0)
679            self._tab.Union(obj, o)
680            return obj
681        return None
682
683    # Monster
684    def AnyAmbiguousType(self):
685        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
686        if o != 0:
687            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
688        return 0
689
690    # Monster
691    def AnyAmbiguous(self):
692        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
693        if o != 0:
694            from flatbuffers.table import Table
695            obj = Table(bytearray(), 0)
696            self._tab.Union(obj, o)
697            return obj
698        return None
699
700    # Monster
701    def VectorOfEnums(self, j):
702        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
703        if o != 0:
704            a = self._tab.Vector(o)
705            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
706        return 0
707
708    # Monster
709    def VectorOfEnumsAsNumpy(self):
710        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
711        if o != 0:
712            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
713        return 0
714
715    # Monster
716    def VectorOfEnumsLength(self):
717        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
718        if o != 0:
719            return self._tab.VectorLen(o)
720        return 0
721
722    # Monster
723    def VectorOfEnumsIsNone(self):
724        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
725        return o == 0
726
727    # Monster
728    def SignedEnum(self):
729        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
730        if o != 0:
731            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
732        return -1
733
734    # Monster
735    def Testrequirednestedflatbuffer(self, j):
736        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
737        if o != 0:
738            a = self._tab.Vector(o)
739            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
740        return 0
741
742    # Monster
743    def TestrequirednestedflatbufferAsNumpy(self):
744        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
745        if o != 0:
746            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
747        return 0
748
749    # Monster
750    def TestrequirednestedflatbufferNestedRoot(self):
751        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
752        if o != 0:
753            from MyGame.Example.Monster import Monster
754            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
755        return 0
756
757    # Monster
758    def TestrequirednestedflatbufferLength(self):
759        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
760        if o != 0:
761            return self._tab.VectorLen(o)
762        return 0
763
764    # Monster
765    def TestrequirednestedflatbufferIsNone(self):
766        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
767        return o == 0
768
769    # Monster
770    def ScalarKeySortedTables(self, j):
771        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
772        if o != 0:
773            x = self._tab.Vector(o)
774            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
775            x = self._tab.Indirect(x)
776            from MyGame.Example.Stat import Stat
777            obj = Stat()
778            obj.Init(self._tab.Bytes, x)
779            return obj
780        return None
781
782    # Monster
783    def ScalarKeySortedTablesLength(self):
784        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
785        if o != 0:
786            return self._tab.VectorLen(o)
787        return 0
788
789    # Monster
790    def ScalarKeySortedTablesIsNone(self):
791        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
792        return o == 0
793
794    # Monster
795    def NativeInline(self):
796        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
797        if o != 0:
798            x = o + self._tab.Pos
799            from MyGame.Example.Test import Test
800            obj = Test()
801            obj.Init(self._tab.Bytes, x)
802            return obj
803        return None
804
805    # Monster
806    def LongEnumNonEnumDefault(self):
807        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
808        if o != 0:
809            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
810        return 0
811
812    # Monster
813    def LongEnumNormalDefault(self):
814        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
815        if o != 0:
816            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
817        return 2
818
819def MonsterStart(builder): builder.StartObject(54)
820def Start(builder):
821    return MonsterStart(builder)
822def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
823def AddPos(builder, pos):
824    return MonsterAddPos(builder, pos)
825def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
826def AddMana(builder, mana):
827    return MonsterAddMana(builder, mana)
828def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
829def AddHp(builder, hp):
830    return MonsterAddHp(builder, hp)
831def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
832def AddName(builder, name):
833    return MonsterAddName(builder, name)
834def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
835def AddInventory(builder, inventory):
836    return MonsterAddInventory(builder, inventory)
837def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
838def StartInventoryVector(builder, numElems):
839    return MonsterStartInventoryVector(builder, numElems)
840def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
841def AddColor(builder, color):
842    return MonsterAddColor(builder, color)
843def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
844def AddTestType(builder, testType):
845    return MonsterAddTestType(builder, testType)
846def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
847def AddTest(builder, test):
848    return MonsterAddTest(builder, test)
849def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
850def AddTest4(builder, test4):
851    return MonsterAddTest4(builder, test4)
852def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
853def StartTest4Vector(builder, numElems):
854    return MonsterStartTest4Vector(builder, numElems)
855def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
856def AddTestarrayofstring(builder, testarrayofstring):
857    return MonsterAddTestarrayofstring(builder, testarrayofstring)
858def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
859def StartTestarrayofstringVector(builder, numElems):
860    return MonsterStartTestarrayofstringVector(builder, numElems)
861def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
862def AddTestarrayoftables(builder, testarrayoftables):
863    return MonsterAddTestarrayoftables(builder, testarrayoftables)
864def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
865def StartTestarrayoftablesVector(builder, numElems):
866    return MonsterStartTestarrayoftablesVector(builder, numElems)
867def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
868def AddEnemy(builder, enemy):
869    return MonsterAddEnemy(builder, enemy)
870def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
871def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
872    return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
873def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
874def StartTestnestedflatbufferVector(builder, numElems):
875    return MonsterStartTestnestedflatbufferVector(builder, numElems)
876def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
877    builder.StartVector(1, len(bytes), 1)
878    builder.head = builder.head - len(bytes)
879    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
880    return builder.EndVector()
881def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
882    return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes)
883def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
884def AddTestempty(builder, testempty):
885    return MonsterAddTestempty(builder, testempty)
886def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
887def AddTestbool(builder, testbool):
888    return MonsterAddTestbool(builder, testbool)
889def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
890def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
891    return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
892def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
893def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
894    return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
895def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
896def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
897    return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
898def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
899def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
900    return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
901def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
902def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
903    return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
904def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
905def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
906    return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
907def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
908def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
909    return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
910def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
911def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
912    return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
913def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
914def AddTestarrayofbools(builder, testarrayofbools):
915    return MonsterAddTestarrayofbools(builder, testarrayofbools)
916def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
917def StartTestarrayofboolsVector(builder, numElems):
918    return MonsterStartTestarrayofboolsVector(builder, numElems)
919def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
920def AddTestf(builder, testf):
921    return MonsterAddTestf(builder, testf)
922def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
923def AddTestf2(builder, testf2):
924    return MonsterAddTestf2(builder, testf2)
925def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
926def AddTestf3(builder, testf3):
927    return MonsterAddTestf3(builder, testf3)
928def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
929def AddTestarrayofstring2(builder, testarrayofstring2):
930    return MonsterAddTestarrayofstring2(builder, testarrayofstring2)
931def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
932def StartTestarrayofstring2Vector(builder, numElems):
933    return MonsterStartTestarrayofstring2Vector(builder, numElems)
934def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
935def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
936    return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
937def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
938def StartTestarrayofsortedstructVector(builder, numElems):
939    return MonsterStartTestarrayofsortedstructVector(builder, numElems)
940def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
941def AddFlex(builder, flex):
942    return MonsterAddFlex(builder, flex)
943def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
944def StartFlexVector(builder, numElems):
945    return MonsterStartFlexVector(builder, numElems)
946def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
947def AddTest5(builder, test5):
948    return MonsterAddTest5(builder, test5)
949def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
950def StartTest5Vector(builder, numElems):
951    return MonsterStartTest5Vector(builder, numElems)
952def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
953def AddVectorOfLongs(builder, vectorOfLongs):
954    return MonsterAddVectorOfLongs(builder, vectorOfLongs)
955def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
956def StartVectorOfLongsVector(builder, numElems):
957    return MonsterStartVectorOfLongsVector(builder, numElems)
958def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
959def AddVectorOfDoubles(builder, vectorOfDoubles):
960    return MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
961def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
962def StartVectorOfDoublesVector(builder, numElems):
963    return MonsterStartVectorOfDoublesVector(builder, numElems)
964def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
965def AddParentNamespaceTest(builder, parentNamespaceTest):
966    return MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
967def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
968def AddVectorOfReferrables(builder, vectorOfReferrables):
969    return MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
970def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
971def StartVectorOfReferrablesVector(builder, numElems):
972    return MonsterStartVectorOfReferrablesVector(builder, numElems)
973def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
974def AddSingleWeakReference(builder, singleWeakReference):
975    return MonsterAddSingleWeakReference(builder, singleWeakReference)
976def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
977def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
978    return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
979def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
980def StartVectorOfWeakReferencesVector(builder, numElems):
981    return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
982def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
983def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
984    return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
985def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
986def StartVectorOfStrongReferrablesVector(builder, numElems):
987    return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
988def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
989def AddCoOwningReference(builder, coOwningReference):
990    return MonsterAddCoOwningReference(builder, coOwningReference)
991def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
992def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
993    return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
994def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
995def StartVectorOfCoOwningReferencesVector(builder, numElems):
996    return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
997def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
998def AddNonOwningReference(builder, nonOwningReference):
999    return MonsterAddNonOwningReference(builder, nonOwningReference)
1000def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
1001def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
1002    return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
1003def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1004def StartVectorOfNonOwningReferencesVector(builder, numElems):
1005    return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
1006def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
1007def AddAnyUniqueType(builder, anyUniqueType):
1008    return MonsterAddAnyUniqueType(builder, anyUniqueType)
1009def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
1010def AddAnyUnique(builder, anyUnique):
1011    return MonsterAddAnyUnique(builder, anyUnique)
1012def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
1013def AddAnyAmbiguousType(builder, anyAmbiguousType):
1014    return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
1015def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
1016def AddAnyAmbiguous(builder, anyAmbiguous):
1017    return MonsterAddAnyAmbiguous(builder, anyAmbiguous)
1018def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
1019def AddVectorOfEnums(builder, vectorOfEnums):
1020    return MonsterAddVectorOfEnums(builder, vectorOfEnums)
1021def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1022def StartVectorOfEnumsVector(builder, numElems):
1023    return MonsterStartVectorOfEnumsVector(builder, numElems)
1024def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
1025def AddSignedEnum(builder, signedEnum):
1026    return MonsterAddSignedEnum(builder, signedEnum)
1027def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
1028def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
1029    return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
1030def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1031def StartTestrequirednestedflatbufferVector(builder, numElems):
1032    return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
1033def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
1034    builder.StartVector(1, len(bytes), 1)
1035    builder.head = builder.head - len(bytes)
1036    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
1037    return builder.EndVector()
1038def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
1039    return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes)
1040def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
1041def AddScalarKeySortedTables(builder, scalarKeySortedTables):
1042    return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
1043def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1044def StartScalarKeySortedTablesVector(builder, numElems):
1045    return MonsterStartScalarKeySortedTablesVector(builder, numElems)
1046def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
1047def AddNativeInline(builder, nativeInline):
1048    return MonsterAddNativeInline(builder, nativeInline)
1049def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
1050def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
1051    return MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
1052def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
1053def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
1054    return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
1055def MonsterEnd(builder): return builder.EndObject()
1056def End(builder):
1057    return MonsterEnd(builder)
1058import MyGame.Example.Ability
1059import MyGame.Example.Any
1060import MyGame.Example.AnyAmbiguousAliases
1061import MyGame.Example.AnyUniqueAliases
1062import MyGame.Example.Referrable
1063import MyGame.Example.Stat
1064import MyGame.Example.Test
1065import MyGame.Example.TestSimpleTableWithEnum
1066import MyGame.Example.Vec3
1067import MyGame.Example2.Monster
1068import MyGame.InParentNamespace
1069try:
1070    from typing import List, Optional, Union
1071except:
1072    pass
1073
1074class MonsterT(object):
1075
1076    # MonsterT
1077    def __init__(self):
1078        self.pos = None  # type: Optional[MyGame.Example.Vec3.Vec3T]
1079        self.mana = 150  # type: int
1080        self.hp = 100  # type: int
1081        self.name = None  # type: str
1082        self.inventory = None  # type: List[int]
1083        self.color = 8  # type: int
1084        self.testType = 0  # type: int
1085        self.test = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
1086        self.test4 = None  # type: List[MyGame.Example.Test.TestT]
1087        self.testarrayofstring = None  # type: List[str]
1088        self.testarrayoftables = None  # type: List[MyGame.Example.Monster.MonsterT]
1089        self.enemy = None  # type: Optional[MyGame.Example.Monster.MonsterT]
1090        self.testnestedflatbuffer = None  # type: List[int]
1091        self.testempty = None  # type: Optional[MyGame.Example.Stat.StatT]
1092        self.testbool = False  # type: bool
1093        self.testhashs32Fnv1 = 0  # type: int
1094        self.testhashu32Fnv1 = 0  # type: int
1095        self.testhashs64Fnv1 = 0  # type: int
1096        self.testhashu64Fnv1 = 0  # type: int
1097        self.testhashs32Fnv1a = 0  # type: int
1098        self.testhashu32Fnv1a = 0  # type: int
1099        self.testhashs64Fnv1a = 0  # type: int
1100        self.testhashu64Fnv1a = 0  # type: int
1101        self.testarrayofbools = None  # type: List[bool]
1102        self.testf = 3.14159  # type: float
1103        self.testf2 = 3.0  # type: float
1104        self.testf3 = 0.0  # type: float
1105        self.testarrayofstring2 = None  # type: List[str]
1106        self.testarrayofsortedstruct = None  # type: List[MyGame.Example.Ability.AbilityT]
1107        self.flex = None  # type: List[int]
1108        self.test5 = None  # type: List[MyGame.Example.Test.TestT]
1109        self.vectorOfLongs = None  # type: List[int]
1110        self.vectorOfDoubles = None  # type: List[float]
1111        self.parentNamespaceTest = None  # type: Optional[MyGame.InParentNamespace.InParentNamespaceT]
1112        self.vectorOfReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
1113        self.singleWeakReference = 0  # type: int
1114        self.vectorOfWeakReferences = None  # type: List[int]
1115        self.vectorOfStrongReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
1116        self.coOwningReference = 0  # type: int
1117        self.vectorOfCoOwningReferences = None  # type: List[int]
1118        self.nonOwningReference = 0  # type: int
1119        self.vectorOfNonOwningReferences = None  # type: List[int]
1120        self.anyUniqueType = 0  # type: int
1121        self.anyUnique = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
1122        self.anyAmbiguousType = 0  # type: int
1123        self.anyAmbiguous = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
1124        self.vectorOfEnums = None  # type: List[int]
1125        self.signedEnum = -1  # type: int
1126        self.testrequirednestedflatbuffer = None  # type: List[int]
1127        self.scalarKeySortedTables = None  # type: List[MyGame.Example.Stat.StatT]
1128        self.nativeInline = None  # type: Optional[MyGame.Example.Test.TestT]
1129        self.longEnumNonEnumDefault = 0  # type: int
1130        self.longEnumNormalDefault = 2  # type: int
1131
1132    @classmethod
1133    def InitFromBuf(cls, buf, pos):
1134        monster = Monster()
1135        monster.Init(buf, pos)
1136        return cls.InitFromObj(monster)
1137
1138    @classmethod
1139    def InitFromObj(cls, monster):
1140        x = MonsterT()
1141        x._UnPack(monster)
1142        return x
1143
1144    # MonsterT
1145    def _UnPack(self, monster):
1146        if monster is None:
1147            return
1148        if monster.Pos() is not None:
1149            self.pos = MyGame.Example.Vec3.Vec3T.InitFromObj(monster.Pos())
1150        self.mana = monster.Mana()
1151        self.hp = monster.Hp()
1152        self.name = monster.Name()
1153        if not monster.InventoryIsNone():
1154            if np is None:
1155                self.inventory = []
1156                for i in range(monster.InventoryLength()):
1157                    self.inventory.append(monster.Inventory(i))
1158            else:
1159                self.inventory = monster.InventoryAsNumpy()
1160        self.color = monster.Color()
1161        self.testType = monster.TestType()
1162        self.test = MyGame.Example.Any.AnyCreator(self.testType, monster.Test())
1163        if not monster.Test4IsNone():
1164            self.test4 = []
1165            for i in range(monster.Test4Length()):
1166                if monster.Test4(i) is None:
1167                    self.test4.append(None)
1168                else:
1169                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test4(i))
1170                    self.test4.append(test_)
1171        if not monster.TestarrayofstringIsNone():
1172            self.testarrayofstring = []
1173            for i in range(monster.TestarrayofstringLength()):
1174                self.testarrayofstring.append(monster.Testarrayofstring(i))
1175        if not monster.TestarrayoftablesIsNone():
1176            self.testarrayoftables = []
1177            for i in range(monster.TestarrayoftablesLength()):
1178                if monster.Testarrayoftables(i) is None:
1179                    self.testarrayoftables.append(None)
1180                else:
1181                    monster_ = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Testarrayoftables(i))
1182                    self.testarrayoftables.append(monster_)
1183        if monster.Enemy() is not None:
1184            self.enemy = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Enemy())
1185        if not monster.TestnestedflatbufferIsNone():
1186            if np is None:
1187                self.testnestedflatbuffer = []
1188                for i in range(monster.TestnestedflatbufferLength()):
1189                    self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
1190            else:
1191                self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
1192        if monster.Testempty() is not None:
1193            self.testempty = MyGame.Example.Stat.StatT.InitFromObj(monster.Testempty())
1194        self.testbool = monster.Testbool()
1195        self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
1196        self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
1197        self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
1198        self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
1199        self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
1200        self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
1201        self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
1202        self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
1203        if not monster.TestarrayofboolsIsNone():
1204            if np is None:
1205                self.testarrayofbools = []
1206                for i in range(monster.TestarrayofboolsLength()):
1207                    self.testarrayofbools.append(monster.Testarrayofbools(i))
1208            else:
1209                self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
1210        self.testf = monster.Testf()
1211        self.testf2 = monster.Testf2()
1212        self.testf3 = monster.Testf3()
1213        if not monster.Testarrayofstring2IsNone():
1214            self.testarrayofstring2 = []
1215            for i in range(monster.Testarrayofstring2Length()):
1216                self.testarrayofstring2.append(monster.Testarrayofstring2(i))
1217        if not monster.TestarrayofsortedstructIsNone():
1218            self.testarrayofsortedstruct = []
1219            for i in range(monster.TestarrayofsortedstructLength()):
1220                if monster.Testarrayofsortedstruct(i) is None:
1221                    self.testarrayofsortedstruct.append(None)
1222                else:
1223                    ability_ = MyGame.Example.Ability.AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
1224                    self.testarrayofsortedstruct.append(ability_)
1225        if not monster.FlexIsNone():
1226            if np is None:
1227                self.flex = []
1228                for i in range(monster.FlexLength()):
1229                    self.flex.append(monster.Flex(i))
1230            else:
1231                self.flex = monster.FlexAsNumpy()
1232        if not monster.Test5IsNone():
1233            self.test5 = []
1234            for i in range(monster.Test5Length()):
1235                if monster.Test5(i) is None:
1236                    self.test5.append(None)
1237                else:
1238                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test5(i))
1239                    self.test5.append(test_)
1240        if not monster.VectorOfLongsIsNone():
1241            if np is None:
1242                self.vectorOfLongs = []
1243                for i in range(monster.VectorOfLongsLength()):
1244                    self.vectorOfLongs.append(monster.VectorOfLongs(i))
1245            else:
1246                self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
1247        if not monster.VectorOfDoublesIsNone():
1248            if np is None:
1249                self.vectorOfDoubles = []
1250                for i in range(monster.VectorOfDoublesLength()):
1251                    self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
1252            else:
1253                self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
1254        if monster.ParentNamespaceTest() is not None:
1255            self.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
1256        if not monster.VectorOfReferrablesIsNone():
1257            self.vectorOfReferrables = []
1258            for i in range(monster.VectorOfReferrablesLength()):
1259                if monster.VectorOfReferrables(i) is None:
1260                    self.vectorOfReferrables.append(None)
1261                else:
1262                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
1263                    self.vectorOfReferrables.append(referrable_)
1264        self.singleWeakReference = monster.SingleWeakReference()
1265        if not monster.VectorOfWeakReferencesIsNone():
1266            if np is None:
1267                self.vectorOfWeakReferences = []
1268                for i in range(monster.VectorOfWeakReferencesLength()):
1269                    self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
1270            else:
1271                self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
1272        if not monster.VectorOfStrongReferrablesIsNone():
1273            self.vectorOfStrongReferrables = []
1274            for i in range(monster.VectorOfStrongReferrablesLength()):
1275                if monster.VectorOfStrongReferrables(i) is None:
1276                    self.vectorOfStrongReferrables.append(None)
1277                else:
1278                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
1279                    self.vectorOfStrongReferrables.append(referrable_)
1280        self.coOwningReference = monster.CoOwningReference()
1281        if not monster.VectorOfCoOwningReferencesIsNone():
1282            if np is None:
1283                self.vectorOfCoOwningReferences = []
1284                for i in range(monster.VectorOfCoOwningReferencesLength()):
1285                    self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
1286            else:
1287                self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
1288        self.nonOwningReference = monster.NonOwningReference()
1289        if not monster.VectorOfNonOwningReferencesIsNone():
1290            if np is None:
1291                self.vectorOfNonOwningReferences = []
1292                for i in range(monster.VectorOfNonOwningReferencesLength()):
1293                    self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
1294            else:
1295                self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
1296        self.anyUniqueType = monster.AnyUniqueType()
1297        self.anyUnique = MyGame.Example.AnyUniqueAliases.AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
1298        self.anyAmbiguousType = monster.AnyAmbiguousType()
1299        self.anyAmbiguous = MyGame.Example.AnyAmbiguousAliases.AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
1300        if not monster.VectorOfEnumsIsNone():
1301            if np is None:
1302                self.vectorOfEnums = []
1303                for i in range(monster.VectorOfEnumsLength()):
1304                    self.vectorOfEnums.append(monster.VectorOfEnums(i))
1305            else:
1306                self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
1307        self.signedEnum = monster.SignedEnum()
1308        if not monster.TestrequirednestedflatbufferIsNone():
1309            if np is None:
1310                self.testrequirednestedflatbuffer = []
1311                for i in range(monster.TestrequirednestedflatbufferLength()):
1312                    self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
1313            else:
1314                self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
1315        if not monster.ScalarKeySortedTablesIsNone():
1316            self.scalarKeySortedTables = []
1317            for i in range(monster.ScalarKeySortedTablesLength()):
1318                if monster.ScalarKeySortedTables(i) is None:
1319                    self.scalarKeySortedTables.append(None)
1320                else:
1321                    stat_ = MyGame.Example.Stat.StatT.InitFromObj(monster.ScalarKeySortedTables(i))
1322                    self.scalarKeySortedTables.append(stat_)
1323        if monster.NativeInline() is not None:
1324            self.nativeInline = MyGame.Example.Test.TestT.InitFromObj(monster.NativeInline())
1325        self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
1326        self.longEnumNormalDefault = monster.LongEnumNormalDefault()
1327
1328    # MonsterT
1329    def Pack(self, builder):
1330        if self.name is not None:
1331            name = builder.CreateString(self.name)
1332        if self.inventory is not None:
1333            if np is not None and type(self.inventory) is np.ndarray:
1334                inventory = builder.CreateNumpyVector(self.inventory)
1335            else:
1336                MonsterStartInventoryVector(builder, len(self.inventory))
1337                for i in reversed(range(len(self.inventory))):
1338                    builder.PrependUint8(self.inventory[i])
1339                inventory = builder.EndVector()
1340        if self.test is not None:
1341            test = self.test.Pack(builder)
1342        if self.test4 is not None:
1343            MonsterStartTest4Vector(builder, len(self.test4))
1344            for i in reversed(range(len(self.test4))):
1345                self.test4[i].Pack(builder)
1346            test4 = builder.EndVector()
1347        if self.testarrayofstring is not None:
1348            testarrayofstringlist = []
1349            for i in range(len(self.testarrayofstring)):
1350                testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
1351            MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
1352            for i in reversed(range(len(self.testarrayofstring))):
1353                builder.PrependUOffsetTRelative(testarrayofstringlist[i])
1354            testarrayofstring = builder.EndVector()
1355        if self.testarrayoftables is not None:
1356            testarrayoftableslist = []
1357            for i in range(len(self.testarrayoftables)):
1358                testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
1359            MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
1360            for i in reversed(range(len(self.testarrayoftables))):
1361                builder.PrependUOffsetTRelative(testarrayoftableslist[i])
1362            testarrayoftables = builder.EndVector()
1363        if self.enemy is not None:
1364            enemy = self.enemy.Pack(builder)
1365        if self.testnestedflatbuffer is not None:
1366            if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
1367                testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
1368            else:
1369                MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
1370                for i in reversed(range(len(self.testnestedflatbuffer))):
1371                    builder.PrependUint8(self.testnestedflatbuffer[i])
1372                testnestedflatbuffer = builder.EndVector()
1373        if self.testempty is not None:
1374            testempty = self.testempty.Pack(builder)
1375        if self.testarrayofbools is not None:
1376            if np is not None and type(self.testarrayofbools) is np.ndarray:
1377                testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
1378            else:
1379                MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
1380                for i in reversed(range(len(self.testarrayofbools))):
1381                    builder.PrependBool(self.testarrayofbools[i])
1382                testarrayofbools = builder.EndVector()
1383        if self.testarrayofstring2 is not None:
1384            testarrayofstring2list = []
1385            for i in range(len(self.testarrayofstring2)):
1386                testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
1387            MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
1388            for i in reversed(range(len(self.testarrayofstring2))):
1389                builder.PrependUOffsetTRelative(testarrayofstring2list[i])
1390            testarrayofstring2 = builder.EndVector()
1391        if self.testarrayofsortedstruct is not None:
1392            MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
1393            for i in reversed(range(len(self.testarrayofsortedstruct))):
1394                self.testarrayofsortedstruct[i].Pack(builder)
1395            testarrayofsortedstruct = builder.EndVector()
1396        if self.flex is not None:
1397            if np is not None and type(self.flex) is np.ndarray:
1398                flex = builder.CreateNumpyVector(self.flex)
1399            else:
1400                MonsterStartFlexVector(builder, len(self.flex))
1401                for i in reversed(range(len(self.flex))):
1402                    builder.PrependUint8(self.flex[i])
1403                flex = builder.EndVector()
1404        if self.test5 is not None:
1405            MonsterStartTest5Vector(builder, len(self.test5))
1406            for i in reversed(range(len(self.test5))):
1407                self.test5[i].Pack(builder)
1408            test5 = builder.EndVector()
1409        if self.vectorOfLongs is not None:
1410            if np is not None and type(self.vectorOfLongs) is np.ndarray:
1411                vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
1412            else:
1413                MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
1414                for i in reversed(range(len(self.vectorOfLongs))):
1415                    builder.PrependInt64(self.vectorOfLongs[i])
1416                vectorOfLongs = builder.EndVector()
1417        if self.vectorOfDoubles is not None:
1418            if np is not None and type(self.vectorOfDoubles) is np.ndarray:
1419                vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
1420            else:
1421                MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
1422                for i in reversed(range(len(self.vectorOfDoubles))):
1423                    builder.PrependFloat64(self.vectorOfDoubles[i])
1424                vectorOfDoubles = builder.EndVector()
1425        if self.parentNamespaceTest is not None:
1426            parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
1427        if self.vectorOfReferrables is not None:
1428            vectorOfReferrableslist = []
1429            for i in range(len(self.vectorOfReferrables)):
1430                vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
1431            MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
1432            for i in reversed(range(len(self.vectorOfReferrables))):
1433                builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
1434            vectorOfReferrables = builder.EndVector()
1435        if self.vectorOfWeakReferences is not None:
1436            if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
1437                vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
1438            else:
1439                MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
1440                for i in reversed(range(len(self.vectorOfWeakReferences))):
1441                    builder.PrependUint64(self.vectorOfWeakReferences[i])
1442                vectorOfWeakReferences = builder.EndVector()
1443        if self.vectorOfStrongReferrables is not None:
1444            vectorOfStrongReferrableslist = []
1445            for i in range(len(self.vectorOfStrongReferrables)):
1446                vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
1447            MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
1448            for i in reversed(range(len(self.vectorOfStrongReferrables))):
1449                builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
1450            vectorOfStrongReferrables = builder.EndVector()
1451        if self.vectorOfCoOwningReferences is not None:
1452            if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
1453                vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
1454            else:
1455                MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
1456                for i in reversed(range(len(self.vectorOfCoOwningReferences))):
1457                    builder.PrependUint64(self.vectorOfCoOwningReferences[i])
1458                vectorOfCoOwningReferences = builder.EndVector()
1459        if self.vectorOfNonOwningReferences is not None:
1460            if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
1461                vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
1462            else:
1463                MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
1464                for i in reversed(range(len(self.vectorOfNonOwningReferences))):
1465                    builder.PrependUint64(self.vectorOfNonOwningReferences[i])
1466                vectorOfNonOwningReferences = builder.EndVector()
1467        if self.anyUnique is not None:
1468            anyUnique = self.anyUnique.Pack(builder)
1469        if self.anyAmbiguous is not None:
1470            anyAmbiguous = self.anyAmbiguous.Pack(builder)
1471        if self.vectorOfEnums is not None:
1472            if np is not None and type(self.vectorOfEnums) is np.ndarray:
1473                vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
1474            else:
1475                MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
1476                for i in reversed(range(len(self.vectorOfEnums))):
1477                    builder.PrependUint8(self.vectorOfEnums[i])
1478                vectorOfEnums = builder.EndVector()
1479        if self.testrequirednestedflatbuffer is not None:
1480            if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
1481                testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
1482            else:
1483                MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
1484                for i in reversed(range(len(self.testrequirednestedflatbuffer))):
1485                    builder.PrependUint8(self.testrequirednestedflatbuffer[i])
1486                testrequirednestedflatbuffer = builder.EndVector()
1487        if self.scalarKeySortedTables is not None:
1488            scalarKeySortedTableslist = []
1489            for i in range(len(self.scalarKeySortedTables)):
1490                scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
1491            MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
1492            for i in reversed(range(len(self.scalarKeySortedTables))):
1493                builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
1494            scalarKeySortedTables = builder.EndVector()
1495        MonsterStart(builder)
1496        if self.pos is not None:
1497            pos = self.pos.Pack(builder)
1498            MonsterAddPos(builder, pos)
1499        MonsterAddMana(builder, self.mana)
1500        MonsterAddHp(builder, self.hp)
1501        if self.name is not None:
1502            MonsterAddName(builder, name)
1503        if self.inventory is not None:
1504            MonsterAddInventory(builder, inventory)
1505        MonsterAddColor(builder, self.color)
1506        MonsterAddTestType(builder, self.testType)
1507        if self.test is not None:
1508            MonsterAddTest(builder, test)
1509        if self.test4 is not None:
1510            MonsterAddTest4(builder, test4)
1511        if self.testarrayofstring is not None:
1512            MonsterAddTestarrayofstring(builder, testarrayofstring)
1513        if self.testarrayoftables is not None:
1514            MonsterAddTestarrayoftables(builder, testarrayoftables)
1515        if self.enemy is not None:
1516            MonsterAddEnemy(builder, enemy)
1517        if self.testnestedflatbuffer is not None:
1518            MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
1519        if self.testempty is not None:
1520            MonsterAddTestempty(builder, testempty)
1521        MonsterAddTestbool(builder, self.testbool)
1522        MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
1523        MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
1524        MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
1525        MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
1526        MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
1527        MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
1528        MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
1529        MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
1530        if self.testarrayofbools is not None:
1531            MonsterAddTestarrayofbools(builder, testarrayofbools)
1532        MonsterAddTestf(builder, self.testf)
1533        MonsterAddTestf2(builder, self.testf2)
1534        MonsterAddTestf3(builder, self.testf3)
1535        if self.testarrayofstring2 is not None:
1536            MonsterAddTestarrayofstring2(builder, testarrayofstring2)
1537        if self.testarrayofsortedstruct is not None:
1538            MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
1539        if self.flex is not None:
1540            MonsterAddFlex(builder, flex)
1541        if self.test5 is not None:
1542            MonsterAddTest5(builder, test5)
1543        if self.vectorOfLongs is not None:
1544            MonsterAddVectorOfLongs(builder, vectorOfLongs)
1545        if self.vectorOfDoubles is not None:
1546            MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
1547        if self.parentNamespaceTest is not None:
1548            MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
1549        if self.vectorOfReferrables is not None:
1550            MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
1551        MonsterAddSingleWeakReference(builder, self.singleWeakReference)
1552        if self.vectorOfWeakReferences is not None:
1553            MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
1554        if self.vectorOfStrongReferrables is not None:
1555            MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
1556        MonsterAddCoOwningReference(builder, self.coOwningReference)
1557        if self.vectorOfCoOwningReferences is not None:
1558            MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
1559        MonsterAddNonOwningReference(builder, self.nonOwningReference)
1560        if self.vectorOfNonOwningReferences is not None:
1561            MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
1562        MonsterAddAnyUniqueType(builder, self.anyUniqueType)
1563        if self.anyUnique is not None:
1564            MonsterAddAnyUnique(builder, anyUnique)
1565        MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
1566        if self.anyAmbiguous is not None:
1567            MonsterAddAnyAmbiguous(builder, anyAmbiguous)
1568        if self.vectorOfEnums is not None:
1569            MonsterAddVectorOfEnums(builder, vectorOfEnums)
1570        MonsterAddSignedEnum(builder, self.signedEnum)
1571        if self.testrequirednestedflatbuffer is not None:
1572            MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
1573        if self.scalarKeySortedTables is not None:
1574            MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
1575        if self.nativeInline is not None:
1576            nativeInline = self.nativeInline.Pack(builder)
1577            MonsterAddNativeInline(builder, nativeInline)
1578        MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
1579        MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
1580        monster = MonsterEnd(builder)
1581        return monster
1582