xref: /aosp_15_r20/external/flatbuffers/tests/monster_test_generated.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# Composite components of Monster color.
10class Color(object):
11    Red = 1
12    # \brief color Green
13    # Green is bit_flag with value (1u << 1)
14    Green = 2
15    # \brief color Blue (1u << 3)
16    Blue = 8
17
18
19class Race(object):
20    None_ = -1
21    Human = 0
22    Dwarf = 1
23    Elf = 2
24
25
26class LongEnum(object):
27    LongOne = 2
28    LongTwo = 4
29    LongBig = 1099511627776
30
31
32class Any(object):
33    NONE = 0
34    Monster = 1
35    TestSimpleTableWithEnum = 2
36    MyGame_Example2_Monster = 3
37
38def AnyCreator(unionType, table):
39    from flatbuffers.table import Table
40    if not isinstance(table, Table):
41        return None
42    if unionType == Any().Monster:
43        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
44    if unionType == Any().TestSimpleTableWithEnum:
45        return TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
46    if unionType == Any().MyGame_Example2_Monster:
47        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
48    return None
49
50
51class AnyUniqueAliases(object):
52    NONE = 0
53    M = 1
54    TS = 2
55    M2 = 3
56
57def AnyUniqueAliasesCreator(unionType, table):
58    from flatbuffers.table import Table
59    if not isinstance(table, Table):
60        return None
61    if unionType == AnyUniqueAliases().M:
62        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
63    if unionType == AnyUniqueAliases().TS:
64        return TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
65    if unionType == AnyUniqueAliases().M2:
66        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
67    return None
68
69
70class AnyAmbiguousAliases(object):
71    NONE = 0
72    M1 = 1
73    M2 = 2
74    M3 = 3
75
76def AnyAmbiguousAliasesCreator(unionType, table):
77    from flatbuffers.table import Table
78    if not isinstance(table, Table):
79        return None
80    if unionType == AnyAmbiguousAliases().M1:
81        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
82    if unionType == AnyAmbiguousAliases().M2:
83        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
84    if unionType == AnyAmbiguousAliases().M3:
85        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
86    return None
87
88
89class InParentNamespace(object):
90    __slots__ = ['_tab']
91
92    @classmethod
93    def GetRootAs(cls, buf, offset=0):
94        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
95        x = InParentNamespace()
96        x.Init(buf, n + offset)
97        return x
98
99    @classmethod
100    def GetRootAsInParentNamespace(cls, buf, offset=0):
101        """This method is deprecated. Please switch to GetRootAs."""
102        return cls.GetRootAs(buf, offset)
103    @classmethod
104    def InParentNamespaceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
105        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
106
107    # InParentNamespace
108    def Init(self, buf, pos):
109        self._tab = flatbuffers.table.Table(buf, pos)
110
111def InParentNamespaceStart(builder): builder.StartObject(0)
112def InParentNamespaceEnd(builder): return builder.EndObject()
113
114
115class InParentNamespaceT(object):
116
117    # InParentNamespaceT
118    def __init__(self):
119        pass
120
121    @classmethod
122    def InitFromBuf(cls, buf, pos):
123        inParentNamespace = InParentNamespace()
124        inParentNamespace.Init(buf, pos)
125        return cls.InitFromObj(inParentNamespace)
126
127    @classmethod
128    def InitFromObj(cls, inParentNamespace):
129        x = InParentNamespaceT()
130        x._UnPack(inParentNamespace)
131        return x
132
133    # InParentNamespaceT
134    def _UnPack(self, inParentNamespace):
135        if inParentNamespace is None:
136            return
137
138    # InParentNamespaceT
139    def Pack(self, builder):
140        InParentNamespaceStart(builder)
141        inParentNamespace = InParentNamespaceEnd(builder)
142        return inParentNamespace
143
144
145class Monster(object):
146    __slots__ = ['_tab']
147
148    @classmethod
149    def GetRootAs(cls, buf, offset=0):
150        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
151        x = Monster()
152        x.Init(buf, n + offset)
153        return x
154
155    @classmethod
156    def GetRootAsMonster(cls, buf, offset=0):
157        """This method is deprecated. Please switch to GetRootAs."""
158        return cls.GetRootAs(buf, offset)
159    @classmethod
160    def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
161        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
162
163    # Monster
164    def Init(self, buf, pos):
165        self._tab = flatbuffers.table.Table(buf, pos)
166
167def MonsterStart(builder): builder.StartObject(0)
168def MonsterEnd(builder): return builder.EndObject()
169
170
171class MonsterT(object):
172
173    # MonsterT
174    def __init__(self):
175        pass
176
177    @classmethod
178    def InitFromBuf(cls, buf, pos):
179        monster = Monster()
180        monster.Init(buf, pos)
181        return cls.InitFromObj(monster)
182
183    @classmethod
184    def InitFromObj(cls, monster):
185        x = MonsterT()
186        x._UnPack(monster)
187        return x
188
189    # MonsterT
190    def _UnPack(self, monster):
191        if monster is None:
192            return
193
194    # MonsterT
195    def Pack(self, builder):
196        MonsterStart(builder)
197        monster = MonsterEnd(builder)
198        return monster
199
200
201class Test(object):
202    __slots__ = ['_tab']
203
204    @classmethod
205    def SizeOf(cls):
206        return 4
207
208    # Test
209    def Init(self, buf, pos):
210        self._tab = flatbuffers.table.Table(buf, pos)
211
212    # Test
213    def A(self): return self._tab.Get(flatbuffers.number_types.Int16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
214    # Test
215    def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2))
216
217def CreateTest(builder, a, b):
218    builder.Prep(2, 4)
219    builder.Pad(1)
220    builder.PrependInt8(b)
221    builder.PrependInt16(a)
222    return builder.Offset()
223
224
225class TestT(object):
226
227    # TestT
228    def __init__(self):
229        self.a = 0  # type: int
230        self.b = 0  # type: int
231
232    @classmethod
233    def InitFromBuf(cls, buf, pos):
234        test = Test()
235        test.Init(buf, pos)
236        return cls.InitFromObj(test)
237
238    @classmethod
239    def InitFromObj(cls, test):
240        x = TestT()
241        x._UnPack(test)
242        return x
243
244    # TestT
245    def _UnPack(self, test):
246        if test is None:
247            return
248        self.a = test.A()
249        self.b = test.B()
250
251    # TestT
252    def Pack(self, builder):
253        return CreateTest(builder, self.a, self.b)
254
255
256class TestSimpleTableWithEnum(object):
257    __slots__ = ['_tab']
258
259    @classmethod
260    def GetRootAs(cls, buf, offset=0):
261        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
262        x = TestSimpleTableWithEnum()
263        x.Init(buf, n + offset)
264        return x
265
266    @classmethod
267    def GetRootAsTestSimpleTableWithEnum(cls, buf, offset=0):
268        """This method is deprecated. Please switch to GetRootAs."""
269        return cls.GetRootAs(buf, offset)
270    @classmethod
271    def TestSimpleTableWithEnumBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
272        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
273
274    # TestSimpleTableWithEnum
275    def Init(self, buf, pos):
276        self._tab = flatbuffers.table.Table(buf, pos)
277
278    # TestSimpleTableWithEnum
279    def Color(self):
280        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
281        if o != 0:
282            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
283        return 2
284
285def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
286def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
287def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
288
289
290class TestSimpleTableWithEnumT(object):
291
292    # TestSimpleTableWithEnumT
293    def __init__(self):
294        self.color = 2  # type: int
295
296    @classmethod
297    def InitFromBuf(cls, buf, pos):
298        testSimpleTableWithEnum = TestSimpleTableWithEnum()
299        testSimpleTableWithEnum.Init(buf, pos)
300        return cls.InitFromObj(testSimpleTableWithEnum)
301
302    @classmethod
303    def InitFromObj(cls, testSimpleTableWithEnum):
304        x = TestSimpleTableWithEnumT()
305        x._UnPack(testSimpleTableWithEnum)
306        return x
307
308    # TestSimpleTableWithEnumT
309    def _UnPack(self, testSimpleTableWithEnum):
310        if testSimpleTableWithEnum is None:
311            return
312        self.color = testSimpleTableWithEnum.Color()
313
314    # TestSimpleTableWithEnumT
315    def Pack(self, builder):
316        TestSimpleTableWithEnumStart(builder)
317        TestSimpleTableWithEnumAddColor(builder, self.color)
318        testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
319        return testSimpleTableWithEnum
320
321
322class Vec3(object):
323    __slots__ = ['_tab']
324
325    @classmethod
326    def SizeOf(cls):
327        return 32
328
329    # Vec3
330    def Init(self, buf, pos):
331        self._tab = flatbuffers.table.Table(buf, pos)
332
333    # Vec3
334    def X(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
335    # Vec3
336    def Y(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
337    # Vec3
338    def Z(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
339    # Vec3
340    def Test1(self): return self._tab.Get(flatbuffers.number_types.Float64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16))
341    # Vec3
342    def Test2(self): return self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(24))
343    # Vec3
344    def Test3(self, obj):
345        obj.Init(self._tab.Bytes, self._tab.Pos + 26)
346        return obj
347
348
349def CreateVec3(builder, x, y, z, test1, test2, test3_a, test3_b):
350    builder.Prep(8, 32)
351    builder.Pad(2)
352    builder.Prep(2, 4)
353    builder.Pad(1)
354    builder.PrependInt8(test3_b)
355    builder.PrependInt16(test3_a)
356    builder.Pad(1)
357    builder.PrependUint8(test2)
358    builder.PrependFloat64(test1)
359    builder.Pad(4)
360    builder.PrependFloat32(z)
361    builder.PrependFloat32(y)
362    builder.PrependFloat32(x)
363    return builder.Offset()
364
365try:
366    from typing import Optional
367except:
368    pass
369
370class Vec3T(object):
371
372    # Vec3T
373    def __init__(self):
374        self.x = 0.0  # type: float
375        self.y = 0.0  # type: float
376        self.z = 0.0  # type: float
377        self.test1 = 0.0  # type: float
378        self.test2 = 0  # type: int
379        self.test3 = None  # type: Optional[TestT]
380
381    @classmethod
382    def InitFromBuf(cls, buf, pos):
383        vec3 = Vec3()
384        vec3.Init(buf, pos)
385        return cls.InitFromObj(vec3)
386
387    @classmethod
388    def InitFromObj(cls, vec3):
389        x = Vec3T()
390        x._UnPack(vec3)
391        return x
392
393    # Vec3T
394    def _UnPack(self, vec3):
395        if vec3 is None:
396            return
397        self.x = vec3.X()
398        self.y = vec3.Y()
399        self.z = vec3.Z()
400        self.test1 = vec3.Test1()
401        self.test2 = vec3.Test2()
402        if vec3.Test3(Test()) is not None:
403            self.test3 = TestT.InitFromObj(vec3.Test3(Test()))
404
405    # Vec3T
406    def Pack(self, builder):
407        return CreateVec3(builder, self.x, self.y, self.z, self.test1, self.test2, self.test3.a, self.test3.b)
408
409
410class Ability(object):
411    __slots__ = ['_tab']
412
413    @classmethod
414    def SizeOf(cls):
415        return 8
416
417    # Ability
418    def Init(self, buf, pos):
419        self._tab = flatbuffers.table.Table(buf, pos)
420
421    # Ability
422    def Id(self): return self._tab.Get(flatbuffers.number_types.Uint32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
423    # Ability
424    def Distance(self): return self._tab.Get(flatbuffers.number_types.Uint32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
425
426def CreateAbility(builder, id, distance):
427    builder.Prep(4, 8)
428    builder.PrependUint32(distance)
429    builder.PrependUint32(id)
430    return builder.Offset()
431
432
433class AbilityT(object):
434
435    # AbilityT
436    def __init__(self):
437        self.id = 0  # type: int
438        self.distance = 0  # type: int
439
440    @classmethod
441    def InitFromBuf(cls, buf, pos):
442        ability = Ability()
443        ability.Init(buf, pos)
444        return cls.InitFromObj(ability)
445
446    @classmethod
447    def InitFromObj(cls, ability):
448        x = AbilityT()
449        x._UnPack(ability)
450        return x
451
452    # AbilityT
453    def _UnPack(self, ability):
454        if ability is None:
455            return
456        self.id = ability.Id()
457        self.distance = ability.Distance()
458
459    # AbilityT
460    def Pack(self, builder):
461        return CreateAbility(builder, self.id, self.distance)
462
463
464class StructOfStructs(object):
465    __slots__ = ['_tab']
466
467    @classmethod
468    def SizeOf(cls):
469        return 20
470
471    # StructOfStructs
472    def Init(self, buf, pos):
473        self._tab = flatbuffers.table.Table(buf, pos)
474
475    # StructOfStructs
476    def A(self, obj):
477        obj.Init(self._tab.Bytes, self._tab.Pos + 0)
478        return obj
479
480    # StructOfStructs
481    def B(self, obj):
482        obj.Init(self._tab.Bytes, self._tab.Pos + 8)
483        return obj
484
485    # StructOfStructs
486    def C(self, obj):
487        obj.Init(self._tab.Bytes, self._tab.Pos + 12)
488        return obj
489
490
491def CreateStructOfStructs(builder, a_id, a_distance, b_a, b_b, c_id, c_distance):
492    builder.Prep(4, 20)
493    builder.Prep(4, 8)
494    builder.PrependUint32(c_distance)
495    builder.PrependUint32(c_id)
496    builder.Prep(2, 4)
497    builder.Pad(1)
498    builder.PrependInt8(b_b)
499    builder.PrependInt16(b_a)
500    builder.Prep(4, 8)
501    builder.PrependUint32(a_distance)
502    builder.PrependUint32(a_id)
503    return builder.Offset()
504
505try:
506    from typing import Optional
507except:
508    pass
509
510class StructOfStructsT(object):
511
512    # StructOfStructsT
513    def __init__(self):
514        self.a = None  # type: Optional[AbilityT]
515        self.b = None  # type: Optional[TestT]
516        self.c = None  # type: Optional[AbilityT]
517
518    @classmethod
519    def InitFromBuf(cls, buf, pos):
520        structOfStructs = StructOfStructs()
521        structOfStructs.Init(buf, pos)
522        return cls.InitFromObj(structOfStructs)
523
524    @classmethod
525    def InitFromObj(cls, structOfStructs):
526        x = StructOfStructsT()
527        x._UnPack(structOfStructs)
528        return x
529
530    # StructOfStructsT
531    def _UnPack(self, structOfStructs):
532        if structOfStructs is None:
533            return
534        if structOfStructs.A(Ability()) is not None:
535            self.a = AbilityT.InitFromObj(structOfStructs.A(Ability()))
536        if structOfStructs.B(Test()) is not None:
537            self.b = TestT.InitFromObj(structOfStructs.B(Test()))
538        if structOfStructs.C(Ability()) is not None:
539            self.c = AbilityT.InitFromObj(structOfStructs.C(Ability()))
540
541    # StructOfStructsT
542    def Pack(self, builder):
543        return CreateStructOfStructs(builder, self.a.id, self.a.distance, self.b.a, self.b.b, self.c.id, self.c.distance)
544
545
546class StructOfStructsOfStructs(object):
547    __slots__ = ['_tab']
548
549    @classmethod
550    def SizeOf(cls):
551        return 20
552
553    # StructOfStructsOfStructs
554    def Init(self, buf, pos):
555        self._tab = flatbuffers.table.Table(buf, pos)
556
557    # StructOfStructsOfStructs
558    def A(self, obj):
559        obj.Init(self._tab.Bytes, self._tab.Pos + 0)
560        return obj
561
562
563def CreateStructOfStructsOfStructs(builder, a_a_id, a_a_distance, a_b_a, a_b_b, a_c_id, a_c_distance):
564    builder.Prep(4, 20)
565    builder.Prep(4, 20)
566    builder.Prep(4, 8)
567    builder.PrependUint32(a_c_distance)
568    builder.PrependUint32(a_c_id)
569    builder.Prep(2, 4)
570    builder.Pad(1)
571    builder.PrependInt8(a_b_b)
572    builder.PrependInt16(a_b_a)
573    builder.Prep(4, 8)
574    builder.PrependUint32(a_a_distance)
575    builder.PrependUint32(a_a_id)
576    return builder.Offset()
577
578try:
579    from typing import Optional
580except:
581    pass
582
583class StructOfStructsOfStructsT(object):
584
585    # StructOfStructsOfStructsT
586    def __init__(self):
587        self.a = None  # type: Optional[StructOfStructsT]
588
589    @classmethod
590    def InitFromBuf(cls, buf, pos):
591        structOfStructsOfStructs = StructOfStructsOfStructs()
592        structOfStructsOfStructs.Init(buf, pos)
593        return cls.InitFromObj(structOfStructsOfStructs)
594
595    @classmethod
596    def InitFromObj(cls, structOfStructsOfStructs):
597        x = StructOfStructsOfStructsT()
598        x._UnPack(structOfStructsOfStructs)
599        return x
600
601    # StructOfStructsOfStructsT
602    def _UnPack(self, structOfStructsOfStructs):
603        if structOfStructsOfStructs is None:
604            return
605        if structOfStructsOfStructs.A(StructOfStructs()) is not None:
606            self.a = StructOfStructsT.InitFromObj(structOfStructsOfStructs.A(StructOfStructs()))
607
608    # StructOfStructsOfStructsT
609    def Pack(self, builder):
610        return CreateStructOfStructsOfStructs(builder, self.a.a.id, self.a.a.distance, self.a.b.a, self.a.b.b, self.a.c.id, self.a.c.distance)
611
612
613class Stat(object):
614    __slots__ = ['_tab']
615
616    @classmethod
617    def GetRootAs(cls, buf, offset=0):
618        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
619        x = Stat()
620        x.Init(buf, n + offset)
621        return x
622
623    @classmethod
624    def GetRootAsStat(cls, buf, offset=0):
625        """This method is deprecated. Please switch to GetRootAs."""
626        return cls.GetRootAs(buf, offset)
627    @classmethod
628    def StatBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
629        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
630
631    # Stat
632    def Init(self, buf, pos):
633        self._tab = flatbuffers.table.Table(buf, pos)
634
635    # Stat
636    def Id(self):
637        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
638        if o != 0:
639            return self._tab.String(o + self._tab.Pos)
640        return None
641
642    # Stat
643    def Val(self):
644        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
645        if o != 0:
646            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
647        return 0
648
649    # Stat
650    def Count(self):
651        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
652        if o != 0:
653            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
654        return 0
655
656def StatStart(builder): builder.StartObject(3)
657def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
658def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
659def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
660def StatEnd(builder): return builder.EndObject()
661
662
663class StatT(object):
664
665    # StatT
666    def __init__(self):
667        self.id = None  # type: str
668        self.val = 0  # type: int
669        self.count = 0  # type: int
670
671    @classmethod
672    def InitFromBuf(cls, buf, pos):
673        stat = Stat()
674        stat.Init(buf, pos)
675        return cls.InitFromObj(stat)
676
677    @classmethod
678    def InitFromObj(cls, stat):
679        x = StatT()
680        x._UnPack(stat)
681        return x
682
683    # StatT
684    def _UnPack(self, stat):
685        if stat is None:
686            return
687        self.id = stat.Id()
688        self.val = stat.Val()
689        self.count = stat.Count()
690
691    # StatT
692    def Pack(self, builder):
693        if self.id is not None:
694            id = builder.CreateString(self.id)
695        StatStart(builder)
696        if self.id is not None:
697            StatAddId(builder, id)
698        StatAddVal(builder, self.val)
699        StatAddCount(builder, self.count)
700        stat = StatEnd(builder)
701        return stat
702
703
704class Referrable(object):
705    __slots__ = ['_tab']
706
707    @classmethod
708    def GetRootAs(cls, buf, offset=0):
709        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
710        x = Referrable()
711        x.Init(buf, n + offset)
712        return x
713
714    @classmethod
715    def GetRootAsReferrable(cls, buf, offset=0):
716        """This method is deprecated. Please switch to GetRootAs."""
717        return cls.GetRootAs(buf, offset)
718    @classmethod
719    def ReferrableBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
720        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
721
722    # Referrable
723    def Init(self, buf, pos):
724        self._tab = flatbuffers.table.Table(buf, pos)
725
726    # Referrable
727    def Id(self):
728        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
729        if o != 0:
730            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
731        return 0
732
733def ReferrableStart(builder): builder.StartObject(1)
734def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
735def ReferrableEnd(builder): return builder.EndObject()
736
737
738class ReferrableT(object):
739
740    # ReferrableT
741    def __init__(self):
742        self.id = 0  # type: int
743
744    @classmethod
745    def InitFromBuf(cls, buf, pos):
746        referrable = Referrable()
747        referrable.Init(buf, pos)
748        return cls.InitFromObj(referrable)
749
750    @classmethod
751    def InitFromObj(cls, referrable):
752        x = ReferrableT()
753        x._UnPack(referrable)
754        return x
755
756    # ReferrableT
757    def _UnPack(self, referrable):
758        if referrable is None:
759            return
760        self.id = referrable.Id()
761
762    # ReferrableT
763    def Pack(self, builder):
764        ReferrableStart(builder)
765        ReferrableAddId(builder, self.id)
766        referrable = ReferrableEnd(builder)
767        return referrable
768
769
770# an example documentation comment: "monster object"
771class Monster(object):
772    __slots__ = ['_tab']
773
774    @classmethod
775    def GetRootAs(cls, buf, offset=0):
776        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
777        x = Monster()
778        x.Init(buf, n + offset)
779        return x
780
781    @classmethod
782    def GetRootAsMonster(cls, buf, offset=0):
783        """This method is deprecated. Please switch to GetRootAs."""
784        return cls.GetRootAs(buf, offset)
785    @classmethod
786    def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
787        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
788
789    # Monster
790    def Init(self, buf, pos):
791        self._tab = flatbuffers.table.Table(buf, pos)
792
793    # Monster
794    def Pos(self):
795        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
796        if o != 0:
797            x = o + self._tab.Pos
798            obj = Vec3()
799            obj.Init(self._tab.Bytes, x)
800            return obj
801        return None
802
803    # Monster
804    def Mana(self):
805        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
806        if o != 0:
807            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
808        return 150
809
810    # Monster
811    def Hp(self):
812        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
813        if o != 0:
814            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
815        return 100
816
817    # Monster
818    def Name(self):
819        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
820        if o != 0:
821            return self._tab.String(o + self._tab.Pos)
822        return None
823
824    # Monster
825    def Inventory(self, j):
826        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
827        if o != 0:
828            a = self._tab.Vector(o)
829            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
830        return 0
831
832    # Monster
833    def InventoryAsNumpy(self):
834        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
835        if o != 0:
836            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
837        return 0
838
839    # Monster
840    def InventoryLength(self):
841        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
842        if o != 0:
843            return self._tab.VectorLen(o)
844        return 0
845
846    # Monster
847    def InventoryIsNone(self):
848        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
849        return o == 0
850
851    # Monster
852    def Color(self):
853        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
854        if o != 0:
855            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
856        return 8
857
858    # Monster
859    def TestType(self):
860        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
861        if o != 0:
862            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
863        return 0
864
865    # Monster
866    def Test(self):
867        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
868        if o != 0:
869            from flatbuffers.table import Table
870            obj = Table(bytearray(), 0)
871            self._tab.Union(obj, o)
872            return obj
873        return None
874
875    # Monster
876    def Test4(self, j):
877        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
878        if o != 0:
879            x = self._tab.Vector(o)
880            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
881            obj = Test()
882            obj.Init(self._tab.Bytes, x)
883            return obj
884        return None
885
886    # Monster
887    def Test4Length(self):
888        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
889        if o != 0:
890            return self._tab.VectorLen(o)
891        return 0
892
893    # Monster
894    def Test4IsNone(self):
895        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
896        return o == 0
897
898    # Monster
899    def Testarrayofstring(self, j):
900        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
901        if o != 0:
902            a = self._tab.Vector(o)
903            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
904        return ""
905
906    # Monster
907    def TestarrayofstringLength(self):
908        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
909        if o != 0:
910            return self._tab.VectorLen(o)
911        return 0
912
913    # Monster
914    def TestarrayofstringIsNone(self):
915        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
916        return o == 0
917
918    # an example documentation comment: this will end up in the generated code
919    # multiline too
920    # Monster
921    def Testarrayoftables(self, j):
922        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
923        if o != 0:
924            x = self._tab.Vector(o)
925            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
926            x = self._tab.Indirect(x)
927            obj = Monster()
928            obj.Init(self._tab.Bytes, x)
929            return obj
930        return None
931
932    # Monster
933    def TestarrayoftablesLength(self):
934        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
935        if o != 0:
936            return self._tab.VectorLen(o)
937        return 0
938
939    # Monster
940    def TestarrayoftablesIsNone(self):
941        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
942        return o == 0
943
944    # Monster
945    def Enemy(self):
946        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
947        if o != 0:
948            x = self._tab.Indirect(o + self._tab.Pos)
949            obj = Monster()
950            obj.Init(self._tab.Bytes, x)
951            return obj
952        return None
953
954    # Monster
955    def Testnestedflatbuffer(self, j):
956        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
957        if o != 0:
958            a = self._tab.Vector(o)
959            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
960        return 0
961
962    # Monster
963    def TestnestedflatbufferAsNumpy(self):
964        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
965        if o != 0:
966            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
967        return 0
968
969    # Monster
970    def TestnestedflatbufferNestedRoot(self):
971        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
972        if o != 0:
973            from MyGame.Example.Monster import Monster
974            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
975        return 0
976
977    # Monster
978    def TestnestedflatbufferLength(self):
979        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
980        if o != 0:
981            return self._tab.VectorLen(o)
982        return 0
983
984    # Monster
985    def TestnestedflatbufferIsNone(self):
986        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
987        return o == 0
988
989    # Monster
990    def Testempty(self):
991        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
992        if o != 0:
993            x = self._tab.Indirect(o + self._tab.Pos)
994            obj = Stat()
995            obj.Init(self._tab.Bytes, x)
996            return obj
997        return None
998
999    # Monster
1000    def Testbool(self):
1001        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
1002        if o != 0:
1003            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
1004        return False
1005
1006    # Monster
1007    def Testhashs32Fnv1(self):
1008        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
1009        if o != 0:
1010            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
1011        return 0
1012
1013    # Monster
1014    def Testhashu32Fnv1(self):
1015        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
1016        if o != 0:
1017            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
1018        return 0
1019
1020    # Monster
1021    def Testhashs64Fnv1(self):
1022        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
1023        if o != 0:
1024            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
1025        return 0
1026
1027    # Monster
1028    def Testhashu64Fnv1(self):
1029        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
1030        if o != 0:
1031            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
1032        return 0
1033
1034    # Monster
1035    def Testhashs32Fnv1a(self):
1036        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
1037        if o != 0:
1038            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
1039        return 0
1040
1041    # Monster
1042    def Testhashu32Fnv1a(self):
1043        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
1044        if o != 0:
1045            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
1046        return 0
1047
1048    # Monster
1049    def Testhashs64Fnv1a(self):
1050        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
1051        if o != 0:
1052            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
1053        return 0
1054
1055    # Monster
1056    def Testhashu64Fnv1a(self):
1057        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
1058        if o != 0:
1059            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
1060        return 0
1061
1062    # Monster
1063    def Testarrayofbools(self, j):
1064        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
1065        if o != 0:
1066            a = self._tab.Vector(o)
1067            return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
1068        return 0
1069
1070    # Monster
1071    def TestarrayofboolsAsNumpy(self):
1072        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
1073        if o != 0:
1074            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
1075        return 0
1076
1077    # Monster
1078    def TestarrayofboolsLength(self):
1079        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
1080        if o != 0:
1081            return self._tab.VectorLen(o)
1082        return 0
1083
1084    # Monster
1085    def TestarrayofboolsIsNone(self):
1086        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
1087        return o == 0
1088
1089    # Monster
1090    def Testf(self):
1091        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
1092        if o != 0:
1093            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
1094        return 3.14159
1095
1096    # Monster
1097    def Testf2(self):
1098        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
1099        if o != 0:
1100            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
1101        return 3.0
1102
1103    # Monster
1104    def Testf3(self):
1105        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
1106        if o != 0:
1107            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
1108        return 0.0
1109
1110    # Monster
1111    def Testarrayofstring2(self, j):
1112        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
1113        if o != 0:
1114            a = self._tab.Vector(o)
1115            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
1116        return ""
1117
1118    # Monster
1119    def Testarrayofstring2Length(self):
1120        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
1121        if o != 0:
1122            return self._tab.VectorLen(o)
1123        return 0
1124
1125    # Monster
1126    def Testarrayofstring2IsNone(self):
1127        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
1128        return o == 0
1129
1130    # Monster
1131    def Testarrayofsortedstruct(self, j):
1132        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
1133        if o != 0:
1134            x = self._tab.Vector(o)
1135            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
1136            obj = Ability()
1137            obj.Init(self._tab.Bytes, x)
1138            return obj
1139        return None
1140
1141    # Monster
1142    def TestarrayofsortedstructLength(self):
1143        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
1144        if o != 0:
1145            return self._tab.VectorLen(o)
1146        return 0
1147
1148    # Monster
1149    def TestarrayofsortedstructIsNone(self):
1150        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
1151        return o == 0
1152
1153    # Monster
1154    def Flex(self, j):
1155        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
1156        if o != 0:
1157            a = self._tab.Vector(o)
1158            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
1159        return 0
1160
1161    # Monster
1162    def FlexAsNumpy(self):
1163        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
1164        if o != 0:
1165            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
1166        return 0
1167
1168    # Monster
1169    def FlexLength(self):
1170        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
1171        if o != 0:
1172            return self._tab.VectorLen(o)
1173        return 0
1174
1175    # Monster
1176    def FlexIsNone(self):
1177        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
1178        return o == 0
1179
1180    # Monster
1181    def Test5(self, j):
1182        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
1183        if o != 0:
1184            x = self._tab.Vector(o)
1185            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
1186            obj = Test()
1187            obj.Init(self._tab.Bytes, x)
1188            return obj
1189        return None
1190
1191    # Monster
1192    def Test5Length(self):
1193        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
1194        if o != 0:
1195            return self._tab.VectorLen(o)
1196        return 0
1197
1198    # Monster
1199    def Test5IsNone(self):
1200        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
1201        return o == 0
1202
1203    # Monster
1204    def VectorOfLongs(self, j):
1205        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
1206        if o != 0:
1207            a = self._tab.Vector(o)
1208            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
1209        return 0
1210
1211    # Monster
1212    def VectorOfLongsAsNumpy(self):
1213        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
1214        if o != 0:
1215            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
1216        return 0
1217
1218    # Monster
1219    def VectorOfLongsLength(self):
1220        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
1221        if o != 0:
1222            return self._tab.VectorLen(o)
1223        return 0
1224
1225    # Monster
1226    def VectorOfLongsIsNone(self):
1227        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
1228        return o == 0
1229
1230    # Monster
1231    def VectorOfDoubles(self, j):
1232        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
1233        if o != 0:
1234            a = self._tab.Vector(o)
1235            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
1236        return 0
1237
1238    # Monster
1239    def VectorOfDoublesAsNumpy(self):
1240        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
1241        if o != 0:
1242            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
1243        return 0
1244
1245    # Monster
1246    def VectorOfDoublesLength(self):
1247        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
1248        if o != 0:
1249            return self._tab.VectorLen(o)
1250        return 0
1251
1252    # Monster
1253    def VectorOfDoublesIsNone(self):
1254        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
1255        return o == 0
1256
1257    # Monster
1258    def ParentNamespaceTest(self):
1259        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
1260        if o != 0:
1261            x = self._tab.Indirect(o + self._tab.Pos)
1262            obj = InParentNamespace()
1263            obj.Init(self._tab.Bytes, x)
1264            return obj
1265        return None
1266
1267    # Monster
1268    def VectorOfReferrables(self, j):
1269        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
1270        if o != 0:
1271            x = self._tab.Vector(o)
1272            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
1273            x = self._tab.Indirect(x)
1274            obj = Referrable()
1275            obj.Init(self._tab.Bytes, x)
1276            return obj
1277        return None
1278
1279    # Monster
1280    def VectorOfReferrablesLength(self):
1281        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
1282        if o != 0:
1283            return self._tab.VectorLen(o)
1284        return 0
1285
1286    # Monster
1287    def VectorOfReferrablesIsNone(self):
1288        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
1289        return o == 0
1290
1291    # Monster
1292    def SingleWeakReference(self):
1293        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
1294        if o != 0:
1295            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
1296        return 0
1297
1298    # Monster
1299    def VectorOfWeakReferences(self, j):
1300        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
1301        if o != 0:
1302            a = self._tab.Vector(o)
1303            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
1304        return 0
1305
1306    # Monster
1307    def VectorOfWeakReferencesAsNumpy(self):
1308        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
1309        if o != 0:
1310            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
1311        return 0
1312
1313    # Monster
1314    def VectorOfWeakReferencesLength(self):
1315        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
1316        if o != 0:
1317            return self._tab.VectorLen(o)
1318        return 0
1319
1320    # Monster
1321    def VectorOfWeakReferencesIsNone(self):
1322        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
1323        return o == 0
1324
1325    # Monster
1326    def VectorOfStrongReferrables(self, j):
1327        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
1328        if o != 0:
1329            x = self._tab.Vector(o)
1330            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
1331            x = self._tab.Indirect(x)
1332            obj = Referrable()
1333            obj.Init(self._tab.Bytes, x)
1334            return obj
1335        return None
1336
1337    # Monster
1338    def VectorOfStrongReferrablesLength(self):
1339        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
1340        if o != 0:
1341            return self._tab.VectorLen(o)
1342        return 0
1343
1344    # Monster
1345    def VectorOfStrongReferrablesIsNone(self):
1346        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
1347        return o == 0
1348
1349    # Monster
1350    def CoOwningReference(self):
1351        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
1352        if o != 0:
1353            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
1354        return 0
1355
1356    # Monster
1357    def VectorOfCoOwningReferences(self, j):
1358        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
1359        if o != 0:
1360            a = self._tab.Vector(o)
1361            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
1362        return 0
1363
1364    # Monster
1365    def VectorOfCoOwningReferencesAsNumpy(self):
1366        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
1367        if o != 0:
1368            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
1369        return 0
1370
1371    # Monster
1372    def VectorOfCoOwningReferencesLength(self):
1373        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
1374        if o != 0:
1375            return self._tab.VectorLen(o)
1376        return 0
1377
1378    # Monster
1379    def VectorOfCoOwningReferencesIsNone(self):
1380        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
1381        return o == 0
1382
1383    # Monster
1384    def NonOwningReference(self):
1385        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
1386        if o != 0:
1387            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
1388        return 0
1389
1390    # Monster
1391    def VectorOfNonOwningReferences(self, j):
1392        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
1393        if o != 0:
1394            a = self._tab.Vector(o)
1395            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
1396        return 0
1397
1398    # Monster
1399    def VectorOfNonOwningReferencesAsNumpy(self):
1400        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
1401        if o != 0:
1402            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
1403        return 0
1404
1405    # Monster
1406    def VectorOfNonOwningReferencesLength(self):
1407        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
1408        if o != 0:
1409            return self._tab.VectorLen(o)
1410        return 0
1411
1412    # Monster
1413    def VectorOfNonOwningReferencesIsNone(self):
1414        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
1415        return o == 0
1416
1417    # Monster
1418    def AnyUniqueType(self):
1419        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
1420        if o != 0:
1421            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
1422        return 0
1423
1424    # Monster
1425    def AnyUnique(self):
1426        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
1427        if o != 0:
1428            from flatbuffers.table import Table
1429            obj = Table(bytearray(), 0)
1430            self._tab.Union(obj, o)
1431            return obj
1432        return None
1433
1434    # Monster
1435    def AnyAmbiguousType(self):
1436        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
1437        if o != 0:
1438            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
1439        return 0
1440
1441    # Monster
1442    def AnyAmbiguous(self):
1443        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
1444        if o != 0:
1445            from flatbuffers.table import Table
1446            obj = Table(bytearray(), 0)
1447            self._tab.Union(obj, o)
1448            return obj
1449        return None
1450
1451    # Monster
1452    def VectorOfEnums(self, j):
1453        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
1454        if o != 0:
1455            a = self._tab.Vector(o)
1456            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
1457        return 0
1458
1459    # Monster
1460    def VectorOfEnumsAsNumpy(self):
1461        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
1462        if o != 0:
1463            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
1464        return 0
1465
1466    # Monster
1467    def VectorOfEnumsLength(self):
1468        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
1469        if o != 0:
1470            return self._tab.VectorLen(o)
1471        return 0
1472
1473    # Monster
1474    def VectorOfEnumsIsNone(self):
1475        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
1476        return o == 0
1477
1478    # Monster
1479    def SignedEnum(self):
1480        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
1481        if o != 0:
1482            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
1483        return -1
1484
1485    # Monster
1486    def Testrequirednestedflatbuffer(self, j):
1487        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
1488        if o != 0:
1489            a = self._tab.Vector(o)
1490            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
1491        return 0
1492
1493    # Monster
1494    def TestrequirednestedflatbufferAsNumpy(self):
1495        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
1496        if o != 0:
1497            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
1498        return 0
1499
1500    # Monster
1501    def TestrequirednestedflatbufferNestedRoot(self):
1502        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
1503        if o != 0:
1504            from MyGame.Example.Monster import Monster
1505            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
1506        return 0
1507
1508    # Monster
1509    def TestrequirednestedflatbufferLength(self):
1510        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
1511        if o != 0:
1512            return self._tab.VectorLen(o)
1513        return 0
1514
1515    # Monster
1516    def TestrequirednestedflatbufferIsNone(self):
1517        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
1518        return o == 0
1519
1520    # Monster
1521    def ScalarKeySortedTables(self, j):
1522        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
1523        if o != 0:
1524            x = self._tab.Vector(o)
1525            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
1526            x = self._tab.Indirect(x)
1527            obj = Stat()
1528            obj.Init(self._tab.Bytes, x)
1529            return obj
1530        return None
1531
1532    # Monster
1533    def ScalarKeySortedTablesLength(self):
1534        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
1535        if o != 0:
1536            return self._tab.VectorLen(o)
1537        return 0
1538
1539    # Monster
1540    def ScalarKeySortedTablesIsNone(self):
1541        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
1542        return o == 0
1543
1544    # Monster
1545    def NativeInline(self):
1546        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
1547        if o != 0:
1548            x = o + self._tab.Pos
1549            obj = Test()
1550            obj.Init(self._tab.Bytes, x)
1551            return obj
1552        return None
1553
1554    # Monster
1555    def LongEnumNonEnumDefault(self):
1556        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
1557        if o != 0:
1558            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
1559        return 0
1560
1561    # Monster
1562    def LongEnumNormalDefault(self):
1563        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
1564        if o != 0:
1565            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
1566        return 2
1567
1568def MonsterStart(builder): builder.StartObject(54)
1569def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
1570def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
1571def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
1572def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
1573def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
1574def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1575def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
1576def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
1577def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
1578def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
1579def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
1580def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
1581def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1582def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
1583def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1584def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
1585def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
1586def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1587def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
1588    builder.StartVector(1, len(bytes), 1)
1589    builder.head = builder.head - len(bytes)
1590    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
1591    return builder.EndVector()
1592def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
1593def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
1594def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
1595def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
1596def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
1597def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
1598def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
1599def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
1600def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
1601def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
1602def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
1603def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1604def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
1605def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
1606def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
1607def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
1608def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
1609def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
1610def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
1611def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
1612def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1613def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
1614def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
1615def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
1616def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1617def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
1618def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1619def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
1620def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
1621def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1622def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
1623def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
1624def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1625def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
1626def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1627def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
1628def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
1629def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1630def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
1631def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
1632def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1633def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
1634def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
1635def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
1636def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
1637def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
1638def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1639def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
1640def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
1641def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1642def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
1643    builder.StartVector(1, len(bytes), 1)
1644    builder.head = builder.head - len(bytes)
1645    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
1646    return builder.EndVector()
1647def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
1648def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1649def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
1650def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
1651def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
1652def MonsterEnd(builder): return builder.EndObject()
1653
1654try:
1655    from typing import List, Optional, Union
1656except:
1657    pass
1658
1659class MonsterT(object):
1660
1661    # MonsterT
1662    def __init__(self):
1663        self.pos = None  # type: Optional[Vec3T]
1664        self.mana = 150  # type: int
1665        self.hp = 100  # type: int
1666        self.name = None  # type: str
1667        self.inventory = None  # type: List[int]
1668        self.color = 8  # type: int
1669        self.testType = 0  # type: int
1670        self.test = None  # type: Union[None, MonsterT, TestSimpleTableWithEnumT, MonsterT]
1671        self.test4 = None  # type: List[TestT]
1672        self.testarrayofstring = None  # type: List[str]
1673        self.testarrayoftables = None  # type: List[MonsterT]
1674        self.enemy = None  # type: Optional[MonsterT]
1675        self.testnestedflatbuffer = None  # type: List[int]
1676        self.testempty = None  # type: Optional[StatT]
1677        self.testbool = False  # type: bool
1678        self.testhashs32Fnv1 = 0  # type: int
1679        self.testhashu32Fnv1 = 0  # type: int
1680        self.testhashs64Fnv1 = 0  # type: int
1681        self.testhashu64Fnv1 = 0  # type: int
1682        self.testhashs32Fnv1a = 0  # type: int
1683        self.testhashu32Fnv1a = 0  # type: int
1684        self.testhashs64Fnv1a = 0  # type: int
1685        self.testhashu64Fnv1a = 0  # type: int
1686        self.testarrayofbools = None  # type: List[bool]
1687        self.testf = 3.14159  # type: float
1688        self.testf2 = 3.0  # type: float
1689        self.testf3 = 0.0  # type: float
1690        self.testarrayofstring2 = None  # type: List[str]
1691        self.testarrayofsortedstruct = None  # type: List[AbilityT]
1692        self.flex = None  # type: List[int]
1693        self.test5 = None  # type: List[TestT]
1694        self.vectorOfLongs = None  # type: List[int]
1695        self.vectorOfDoubles = None  # type: List[float]
1696        self.parentNamespaceTest = None  # type: Optional[InParentNamespaceT]
1697        self.vectorOfReferrables = None  # type: List[ReferrableT]
1698        self.singleWeakReference = 0  # type: int
1699        self.vectorOfWeakReferences = None  # type: List[int]
1700        self.vectorOfStrongReferrables = None  # type: List[ReferrableT]
1701        self.coOwningReference = 0  # type: int
1702        self.vectorOfCoOwningReferences = None  # type: List[int]
1703        self.nonOwningReference = 0  # type: int
1704        self.vectorOfNonOwningReferences = None  # type: List[int]
1705        self.anyUniqueType = 0  # type: int
1706        self.anyUnique = None  # type: Union[None, MonsterT, TestSimpleTableWithEnumT, MonsterT]
1707        self.anyAmbiguousType = 0  # type: int
1708        self.anyAmbiguous = None  # type: Union[None, MonsterT, MonsterT, MonsterT]
1709        self.vectorOfEnums = None  # type: List[int]
1710        self.signedEnum = -1  # type: int
1711        self.testrequirednestedflatbuffer = None  # type: List[int]
1712        self.scalarKeySortedTables = None  # type: List[StatT]
1713        self.nativeInline = None  # type: Optional[TestT]
1714        self.longEnumNonEnumDefault = 0  # type: int
1715        self.longEnumNormalDefault = 2  # type: int
1716
1717    @classmethod
1718    def InitFromBuf(cls, buf, pos):
1719        monster = Monster()
1720        monster.Init(buf, pos)
1721        return cls.InitFromObj(monster)
1722
1723    @classmethod
1724    def InitFromObj(cls, monster):
1725        x = MonsterT()
1726        x._UnPack(monster)
1727        return x
1728
1729    # MonsterT
1730    def _UnPack(self, monster):
1731        if monster is None:
1732            return
1733        if monster.Pos() is not None:
1734            self.pos = Vec3T.InitFromObj(monster.Pos())
1735        self.mana = monster.Mana()
1736        self.hp = monster.Hp()
1737        self.name = monster.Name()
1738        if not monster.InventoryIsNone():
1739            if np is None:
1740                self.inventory = []
1741                for i in range(monster.InventoryLength()):
1742                    self.inventory.append(monster.Inventory(i))
1743            else:
1744                self.inventory = monster.InventoryAsNumpy()
1745        self.color = monster.Color()
1746        self.testType = monster.TestType()
1747        self.test = AnyCreator(self.testType, monster.Test())
1748        if not monster.Test4IsNone():
1749            self.test4 = []
1750            for i in range(monster.Test4Length()):
1751                if monster.Test4(i) is None:
1752                    self.test4.append(None)
1753                else:
1754                    test_ = TestT.InitFromObj(monster.Test4(i))
1755                    self.test4.append(test_)
1756        if not monster.TestarrayofstringIsNone():
1757            self.testarrayofstring = []
1758            for i in range(monster.TestarrayofstringLength()):
1759                self.testarrayofstring.append(monster.Testarrayofstring(i))
1760        if not monster.TestarrayoftablesIsNone():
1761            self.testarrayoftables = []
1762            for i in range(monster.TestarrayoftablesLength()):
1763                if monster.Testarrayoftables(i) is None:
1764                    self.testarrayoftables.append(None)
1765                else:
1766                    monster_ = MonsterT.InitFromObj(monster.Testarrayoftables(i))
1767                    self.testarrayoftables.append(monster_)
1768        if monster.Enemy() is not None:
1769            self.enemy = MonsterT.InitFromObj(monster.Enemy())
1770        if not monster.TestnestedflatbufferIsNone():
1771            if np is None:
1772                self.testnestedflatbuffer = []
1773                for i in range(monster.TestnestedflatbufferLength()):
1774                    self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
1775            else:
1776                self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
1777        if monster.Testempty() is not None:
1778            self.testempty = StatT.InitFromObj(monster.Testempty())
1779        self.testbool = monster.Testbool()
1780        self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
1781        self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
1782        self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
1783        self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
1784        self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
1785        self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
1786        self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
1787        self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
1788        if not monster.TestarrayofboolsIsNone():
1789            if np is None:
1790                self.testarrayofbools = []
1791                for i in range(monster.TestarrayofboolsLength()):
1792                    self.testarrayofbools.append(monster.Testarrayofbools(i))
1793            else:
1794                self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
1795        self.testf = monster.Testf()
1796        self.testf2 = monster.Testf2()
1797        self.testf3 = monster.Testf3()
1798        if not monster.Testarrayofstring2IsNone():
1799            self.testarrayofstring2 = []
1800            for i in range(monster.Testarrayofstring2Length()):
1801                self.testarrayofstring2.append(monster.Testarrayofstring2(i))
1802        if not monster.TestarrayofsortedstructIsNone():
1803            self.testarrayofsortedstruct = []
1804            for i in range(monster.TestarrayofsortedstructLength()):
1805                if monster.Testarrayofsortedstruct(i) is None:
1806                    self.testarrayofsortedstruct.append(None)
1807                else:
1808                    ability_ = AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
1809                    self.testarrayofsortedstruct.append(ability_)
1810        if not monster.FlexIsNone():
1811            if np is None:
1812                self.flex = []
1813                for i in range(monster.FlexLength()):
1814                    self.flex.append(monster.Flex(i))
1815            else:
1816                self.flex = monster.FlexAsNumpy()
1817        if not monster.Test5IsNone():
1818            self.test5 = []
1819            for i in range(monster.Test5Length()):
1820                if monster.Test5(i) is None:
1821                    self.test5.append(None)
1822                else:
1823                    test_ = TestT.InitFromObj(monster.Test5(i))
1824                    self.test5.append(test_)
1825        if not monster.VectorOfLongsIsNone():
1826            if np is None:
1827                self.vectorOfLongs = []
1828                for i in range(monster.VectorOfLongsLength()):
1829                    self.vectorOfLongs.append(monster.VectorOfLongs(i))
1830            else:
1831                self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
1832        if not monster.VectorOfDoublesIsNone():
1833            if np is None:
1834                self.vectorOfDoubles = []
1835                for i in range(monster.VectorOfDoublesLength()):
1836                    self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
1837            else:
1838                self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
1839        if monster.ParentNamespaceTest() is not None:
1840            self.parentNamespaceTest = InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
1841        if not monster.VectorOfReferrablesIsNone():
1842            self.vectorOfReferrables = []
1843            for i in range(monster.VectorOfReferrablesLength()):
1844                if monster.VectorOfReferrables(i) is None:
1845                    self.vectorOfReferrables.append(None)
1846                else:
1847                    referrable_ = ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
1848                    self.vectorOfReferrables.append(referrable_)
1849        self.singleWeakReference = monster.SingleWeakReference()
1850        if not monster.VectorOfWeakReferencesIsNone():
1851            if np is None:
1852                self.vectorOfWeakReferences = []
1853                for i in range(monster.VectorOfWeakReferencesLength()):
1854                    self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
1855            else:
1856                self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
1857        if not monster.VectorOfStrongReferrablesIsNone():
1858            self.vectorOfStrongReferrables = []
1859            for i in range(monster.VectorOfStrongReferrablesLength()):
1860                if monster.VectorOfStrongReferrables(i) is None:
1861                    self.vectorOfStrongReferrables.append(None)
1862                else:
1863                    referrable_ = ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
1864                    self.vectorOfStrongReferrables.append(referrable_)
1865        self.coOwningReference = monster.CoOwningReference()
1866        if not monster.VectorOfCoOwningReferencesIsNone():
1867            if np is None:
1868                self.vectorOfCoOwningReferences = []
1869                for i in range(monster.VectorOfCoOwningReferencesLength()):
1870                    self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
1871            else:
1872                self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
1873        self.nonOwningReference = monster.NonOwningReference()
1874        if not monster.VectorOfNonOwningReferencesIsNone():
1875            if np is None:
1876                self.vectorOfNonOwningReferences = []
1877                for i in range(monster.VectorOfNonOwningReferencesLength()):
1878                    self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
1879            else:
1880                self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
1881        self.anyUniqueType = monster.AnyUniqueType()
1882        self.anyUnique = AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
1883        self.anyAmbiguousType = monster.AnyAmbiguousType()
1884        self.anyAmbiguous = AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
1885        if not monster.VectorOfEnumsIsNone():
1886            if np is None:
1887                self.vectorOfEnums = []
1888                for i in range(monster.VectorOfEnumsLength()):
1889                    self.vectorOfEnums.append(monster.VectorOfEnums(i))
1890            else:
1891                self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
1892        self.signedEnum = monster.SignedEnum()
1893        if not monster.TestrequirednestedflatbufferIsNone():
1894            if np is None:
1895                self.testrequirednestedflatbuffer = []
1896                for i in range(monster.TestrequirednestedflatbufferLength()):
1897                    self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
1898            else:
1899                self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
1900        if not monster.ScalarKeySortedTablesIsNone():
1901            self.scalarKeySortedTables = []
1902            for i in range(monster.ScalarKeySortedTablesLength()):
1903                if monster.ScalarKeySortedTables(i) is None:
1904                    self.scalarKeySortedTables.append(None)
1905                else:
1906                    stat_ = StatT.InitFromObj(monster.ScalarKeySortedTables(i))
1907                    self.scalarKeySortedTables.append(stat_)
1908        if monster.NativeInline() is not None:
1909            self.nativeInline = TestT.InitFromObj(monster.NativeInline())
1910        self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
1911        self.longEnumNormalDefault = monster.LongEnumNormalDefault()
1912
1913    # MonsterT
1914    def Pack(self, builder):
1915        if self.name is not None:
1916            name = builder.CreateString(self.name)
1917        if self.inventory is not None:
1918            if np is not None and type(self.inventory) is np.ndarray:
1919                inventory = builder.CreateNumpyVector(self.inventory)
1920            else:
1921                MonsterStartInventoryVector(builder, len(self.inventory))
1922                for i in reversed(range(len(self.inventory))):
1923                    builder.PrependUint8(self.inventory[i])
1924                inventory = builder.EndVector()
1925        if self.test is not None:
1926            test = self.test.Pack(builder)
1927        if self.test4 is not None:
1928            MonsterStartTest4Vector(builder, len(self.test4))
1929            for i in reversed(range(len(self.test4))):
1930                self.test4[i].Pack(builder)
1931            test4 = builder.EndVector()
1932        if self.testarrayofstring is not None:
1933            testarrayofstringlist = []
1934            for i in range(len(self.testarrayofstring)):
1935                testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
1936            MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
1937            for i in reversed(range(len(self.testarrayofstring))):
1938                builder.PrependUOffsetTRelative(testarrayofstringlist[i])
1939            testarrayofstring = builder.EndVector()
1940        if self.testarrayoftables is not None:
1941            testarrayoftableslist = []
1942            for i in range(len(self.testarrayoftables)):
1943                testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
1944            MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
1945            for i in reversed(range(len(self.testarrayoftables))):
1946                builder.PrependUOffsetTRelative(testarrayoftableslist[i])
1947            testarrayoftables = builder.EndVector()
1948        if self.enemy is not None:
1949            enemy = self.enemy.Pack(builder)
1950        if self.testnestedflatbuffer is not None:
1951            if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
1952                testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
1953            else:
1954                MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
1955                for i in reversed(range(len(self.testnestedflatbuffer))):
1956                    builder.PrependUint8(self.testnestedflatbuffer[i])
1957                testnestedflatbuffer = builder.EndVector()
1958        if self.testempty is not None:
1959            testempty = self.testempty.Pack(builder)
1960        if self.testarrayofbools is not None:
1961            if np is not None and type(self.testarrayofbools) is np.ndarray:
1962                testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
1963            else:
1964                MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
1965                for i in reversed(range(len(self.testarrayofbools))):
1966                    builder.PrependBool(self.testarrayofbools[i])
1967                testarrayofbools = builder.EndVector()
1968        if self.testarrayofstring2 is not None:
1969            testarrayofstring2list = []
1970            for i in range(len(self.testarrayofstring2)):
1971                testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
1972            MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
1973            for i in reversed(range(len(self.testarrayofstring2))):
1974                builder.PrependUOffsetTRelative(testarrayofstring2list[i])
1975            testarrayofstring2 = builder.EndVector()
1976        if self.testarrayofsortedstruct is not None:
1977            MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
1978            for i in reversed(range(len(self.testarrayofsortedstruct))):
1979                self.testarrayofsortedstruct[i].Pack(builder)
1980            testarrayofsortedstruct = builder.EndVector()
1981        if self.flex is not None:
1982            if np is not None and type(self.flex) is np.ndarray:
1983                flex = builder.CreateNumpyVector(self.flex)
1984            else:
1985                MonsterStartFlexVector(builder, len(self.flex))
1986                for i in reversed(range(len(self.flex))):
1987                    builder.PrependUint8(self.flex[i])
1988                flex = builder.EndVector()
1989        if self.test5 is not None:
1990            MonsterStartTest5Vector(builder, len(self.test5))
1991            for i in reversed(range(len(self.test5))):
1992                self.test5[i].Pack(builder)
1993            test5 = builder.EndVector()
1994        if self.vectorOfLongs is not None:
1995            if np is not None and type(self.vectorOfLongs) is np.ndarray:
1996                vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
1997            else:
1998                MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
1999                for i in reversed(range(len(self.vectorOfLongs))):
2000                    builder.PrependInt64(self.vectorOfLongs[i])
2001                vectorOfLongs = builder.EndVector()
2002        if self.vectorOfDoubles is not None:
2003            if np is not None and type(self.vectorOfDoubles) is np.ndarray:
2004                vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
2005            else:
2006                MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
2007                for i in reversed(range(len(self.vectorOfDoubles))):
2008                    builder.PrependFloat64(self.vectorOfDoubles[i])
2009                vectorOfDoubles = builder.EndVector()
2010        if self.parentNamespaceTest is not None:
2011            parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
2012        if self.vectorOfReferrables is not None:
2013            vectorOfReferrableslist = []
2014            for i in range(len(self.vectorOfReferrables)):
2015                vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
2016            MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
2017            for i in reversed(range(len(self.vectorOfReferrables))):
2018                builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
2019            vectorOfReferrables = builder.EndVector()
2020        if self.vectorOfWeakReferences is not None:
2021            if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
2022                vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
2023            else:
2024                MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
2025                for i in reversed(range(len(self.vectorOfWeakReferences))):
2026                    builder.PrependUint64(self.vectorOfWeakReferences[i])
2027                vectorOfWeakReferences = builder.EndVector()
2028        if self.vectorOfStrongReferrables is not None:
2029            vectorOfStrongReferrableslist = []
2030            for i in range(len(self.vectorOfStrongReferrables)):
2031                vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
2032            MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
2033            for i in reversed(range(len(self.vectorOfStrongReferrables))):
2034                builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
2035            vectorOfStrongReferrables = builder.EndVector()
2036        if self.vectorOfCoOwningReferences is not None:
2037            if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
2038                vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
2039            else:
2040                MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
2041                for i in reversed(range(len(self.vectorOfCoOwningReferences))):
2042                    builder.PrependUint64(self.vectorOfCoOwningReferences[i])
2043                vectorOfCoOwningReferences = builder.EndVector()
2044        if self.vectorOfNonOwningReferences is not None:
2045            if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
2046                vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
2047            else:
2048                MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
2049                for i in reversed(range(len(self.vectorOfNonOwningReferences))):
2050                    builder.PrependUint64(self.vectorOfNonOwningReferences[i])
2051                vectorOfNonOwningReferences = builder.EndVector()
2052        if self.anyUnique is not None:
2053            anyUnique = self.anyUnique.Pack(builder)
2054        if self.anyAmbiguous is not None:
2055            anyAmbiguous = self.anyAmbiguous.Pack(builder)
2056        if self.vectorOfEnums is not None:
2057            if np is not None and type(self.vectorOfEnums) is np.ndarray:
2058                vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
2059            else:
2060                MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
2061                for i in reversed(range(len(self.vectorOfEnums))):
2062                    builder.PrependUint8(self.vectorOfEnums[i])
2063                vectorOfEnums = builder.EndVector()
2064        if self.testrequirednestedflatbuffer is not None:
2065            if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
2066                testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
2067            else:
2068                MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
2069                for i in reversed(range(len(self.testrequirednestedflatbuffer))):
2070                    builder.PrependUint8(self.testrequirednestedflatbuffer[i])
2071                testrequirednestedflatbuffer = builder.EndVector()
2072        if self.scalarKeySortedTables is not None:
2073            scalarKeySortedTableslist = []
2074            for i in range(len(self.scalarKeySortedTables)):
2075                scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
2076            MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
2077            for i in reversed(range(len(self.scalarKeySortedTables))):
2078                builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
2079            scalarKeySortedTables = builder.EndVector()
2080        MonsterStart(builder)
2081        if self.pos is not None:
2082            pos = self.pos.Pack(builder)
2083            MonsterAddPos(builder, pos)
2084        MonsterAddMana(builder, self.mana)
2085        MonsterAddHp(builder, self.hp)
2086        if self.name is not None:
2087            MonsterAddName(builder, name)
2088        if self.inventory is not None:
2089            MonsterAddInventory(builder, inventory)
2090        MonsterAddColor(builder, self.color)
2091        MonsterAddTestType(builder, self.testType)
2092        if self.test is not None:
2093            MonsterAddTest(builder, test)
2094        if self.test4 is not None:
2095            MonsterAddTest4(builder, test4)
2096        if self.testarrayofstring is not None:
2097            MonsterAddTestarrayofstring(builder, testarrayofstring)
2098        if self.testarrayoftables is not None:
2099            MonsterAddTestarrayoftables(builder, testarrayoftables)
2100        if self.enemy is not None:
2101            MonsterAddEnemy(builder, enemy)
2102        if self.testnestedflatbuffer is not None:
2103            MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
2104        if self.testempty is not None:
2105            MonsterAddTestempty(builder, testempty)
2106        MonsterAddTestbool(builder, self.testbool)
2107        MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
2108        MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
2109        MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
2110        MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
2111        MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
2112        MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
2113        MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
2114        MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
2115        if self.testarrayofbools is not None:
2116            MonsterAddTestarrayofbools(builder, testarrayofbools)
2117        MonsterAddTestf(builder, self.testf)
2118        MonsterAddTestf2(builder, self.testf2)
2119        MonsterAddTestf3(builder, self.testf3)
2120        if self.testarrayofstring2 is not None:
2121            MonsterAddTestarrayofstring2(builder, testarrayofstring2)
2122        if self.testarrayofsortedstruct is not None:
2123            MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
2124        if self.flex is not None:
2125            MonsterAddFlex(builder, flex)
2126        if self.test5 is not None:
2127            MonsterAddTest5(builder, test5)
2128        if self.vectorOfLongs is not None:
2129            MonsterAddVectorOfLongs(builder, vectorOfLongs)
2130        if self.vectorOfDoubles is not None:
2131            MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
2132        if self.parentNamespaceTest is not None:
2133            MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
2134        if self.vectorOfReferrables is not None:
2135            MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
2136        MonsterAddSingleWeakReference(builder, self.singleWeakReference)
2137        if self.vectorOfWeakReferences is not None:
2138            MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
2139        if self.vectorOfStrongReferrables is not None:
2140            MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
2141        MonsterAddCoOwningReference(builder, self.coOwningReference)
2142        if self.vectorOfCoOwningReferences is not None:
2143            MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
2144        MonsterAddNonOwningReference(builder, self.nonOwningReference)
2145        if self.vectorOfNonOwningReferences is not None:
2146            MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
2147        MonsterAddAnyUniqueType(builder, self.anyUniqueType)
2148        if self.anyUnique is not None:
2149            MonsterAddAnyUnique(builder, anyUnique)
2150        MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
2151        if self.anyAmbiguous is not None:
2152            MonsterAddAnyAmbiguous(builder, anyAmbiguous)
2153        if self.vectorOfEnums is not None:
2154            MonsterAddVectorOfEnums(builder, vectorOfEnums)
2155        MonsterAddSignedEnum(builder, self.signedEnum)
2156        if self.testrequirednestedflatbuffer is not None:
2157            MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
2158        if self.scalarKeySortedTables is not None:
2159            MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
2160        if self.nativeInline is not None:
2161            nativeInline = self.nativeInline.Pack(builder)
2162            MonsterAddNativeInline(builder, nativeInline)
2163        MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
2164        MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
2165        monster = MonsterEnd(builder)
2166        return monster
2167
2168
2169class TypeAliases(object):
2170    __slots__ = ['_tab']
2171
2172    @classmethod
2173    def GetRootAs(cls, buf, offset=0):
2174        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
2175        x = TypeAliases()
2176        x.Init(buf, n + offset)
2177        return x
2178
2179    @classmethod
2180    def GetRootAsTypeAliases(cls, buf, offset=0):
2181        """This method is deprecated. Please switch to GetRootAs."""
2182        return cls.GetRootAs(buf, offset)
2183    @classmethod
2184    def TypeAliasesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
2185        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
2186
2187    # TypeAliases
2188    def Init(self, buf, pos):
2189        self._tab = flatbuffers.table.Table(buf, pos)
2190
2191    # TypeAliases
2192    def I8(self):
2193        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
2194        if o != 0:
2195            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
2196        return 0
2197
2198    # TypeAliases
2199    def U8(self):
2200        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
2201        if o != 0:
2202            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
2203        return 0
2204
2205    # TypeAliases
2206    def I16(self):
2207        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
2208        if o != 0:
2209            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
2210        return 0
2211
2212    # TypeAliases
2213    def U16(self):
2214        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
2215        if o != 0:
2216            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
2217        return 0
2218
2219    # TypeAliases
2220    def I32(self):
2221        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
2222        if o != 0:
2223            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
2224        return 0
2225
2226    # TypeAliases
2227    def U32(self):
2228        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
2229        if o != 0:
2230            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
2231        return 0
2232
2233    # TypeAliases
2234    def I64(self):
2235        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
2236        if o != 0:
2237            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
2238        return 0
2239
2240    # TypeAliases
2241    def U64(self):
2242        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
2243        if o != 0:
2244            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
2245        return 0
2246
2247    # TypeAliases
2248    def F32(self):
2249        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
2250        if o != 0:
2251            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
2252        return 0.0
2253
2254    # TypeAliases
2255    def F64(self):
2256        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
2257        if o != 0:
2258            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
2259        return 0.0
2260
2261    # TypeAliases
2262    def V8(self, j):
2263        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
2264        if o != 0:
2265            a = self._tab.Vector(o)
2266            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
2267        return 0
2268
2269    # TypeAliases
2270    def V8AsNumpy(self):
2271        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
2272        if o != 0:
2273            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
2274        return 0
2275
2276    # TypeAliases
2277    def V8Length(self):
2278        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
2279        if o != 0:
2280            return self._tab.VectorLen(o)
2281        return 0
2282
2283    # TypeAliases
2284    def V8IsNone(self):
2285        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
2286        return o == 0
2287
2288    # TypeAliases
2289    def Vf64(self, j):
2290        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
2291        if o != 0:
2292            a = self._tab.Vector(o)
2293            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
2294        return 0
2295
2296    # TypeAliases
2297    def Vf64AsNumpy(self):
2298        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
2299        if o != 0:
2300            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
2301        return 0
2302
2303    # TypeAliases
2304    def Vf64Length(self):
2305        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
2306        if o != 0:
2307            return self._tab.VectorLen(o)
2308        return 0
2309
2310    # TypeAliases
2311    def Vf64IsNone(self):
2312        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
2313        return o == 0
2314
2315def TypeAliasesStart(builder): builder.StartObject(12)
2316def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
2317def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
2318def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
2319def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
2320def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
2321def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
2322def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
2323def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
2324def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
2325def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
2326def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
2327def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
2328def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
2329def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
2330def TypeAliasesEnd(builder): return builder.EndObject()
2331
2332try:
2333    from typing import List
2334except:
2335    pass
2336
2337class TypeAliasesT(object):
2338
2339    # TypeAliasesT
2340    def __init__(self):
2341        self.i8 = 0  # type: int
2342        self.u8 = 0  # type: int
2343        self.i16 = 0  # type: int
2344        self.u16 = 0  # type: int
2345        self.i32 = 0  # type: int
2346        self.u32 = 0  # type: int
2347        self.i64 = 0  # type: int
2348        self.u64 = 0  # type: int
2349        self.f32 = 0.0  # type: float
2350        self.f64 = 0.0  # type: float
2351        self.v8 = None  # type: List[int]
2352        self.vf64 = None  # type: List[float]
2353
2354    @classmethod
2355    def InitFromBuf(cls, buf, pos):
2356        typeAliases = TypeAliases()
2357        typeAliases.Init(buf, pos)
2358        return cls.InitFromObj(typeAliases)
2359
2360    @classmethod
2361    def InitFromObj(cls, typeAliases):
2362        x = TypeAliasesT()
2363        x._UnPack(typeAliases)
2364        return x
2365
2366    # TypeAliasesT
2367    def _UnPack(self, typeAliases):
2368        if typeAliases is None:
2369            return
2370        self.i8 = typeAliases.I8()
2371        self.u8 = typeAliases.U8()
2372        self.i16 = typeAliases.I16()
2373        self.u16 = typeAliases.U16()
2374        self.i32 = typeAliases.I32()
2375        self.u32 = typeAliases.U32()
2376        self.i64 = typeAliases.I64()
2377        self.u64 = typeAliases.U64()
2378        self.f32 = typeAliases.F32()
2379        self.f64 = typeAliases.F64()
2380        if not typeAliases.V8IsNone():
2381            if np is None:
2382                self.v8 = []
2383                for i in range(typeAliases.V8Length()):
2384                    self.v8.append(typeAliases.V8(i))
2385            else:
2386                self.v8 = typeAliases.V8AsNumpy()
2387        if not typeAliases.Vf64IsNone():
2388            if np is None:
2389                self.vf64 = []
2390                for i in range(typeAliases.Vf64Length()):
2391                    self.vf64.append(typeAliases.Vf64(i))
2392            else:
2393                self.vf64 = typeAliases.Vf64AsNumpy()
2394
2395    # TypeAliasesT
2396    def Pack(self, builder):
2397        if self.v8 is not None:
2398            if np is not None and type(self.v8) is np.ndarray:
2399                v8 = builder.CreateNumpyVector(self.v8)
2400            else:
2401                TypeAliasesStartV8Vector(builder, len(self.v8))
2402                for i in reversed(range(len(self.v8))):
2403                    builder.PrependByte(self.v8[i])
2404                v8 = builder.EndVector()
2405        if self.vf64 is not None:
2406            if np is not None and type(self.vf64) is np.ndarray:
2407                vf64 = builder.CreateNumpyVector(self.vf64)
2408            else:
2409                TypeAliasesStartVf64Vector(builder, len(self.vf64))
2410                for i in reversed(range(len(self.vf64))):
2411                    builder.PrependFloat64(self.vf64[i])
2412                vf64 = builder.EndVector()
2413        TypeAliasesStart(builder)
2414        TypeAliasesAddI8(builder, self.i8)
2415        TypeAliasesAddU8(builder, self.u8)
2416        TypeAliasesAddI16(builder, self.i16)
2417        TypeAliasesAddU16(builder, self.u16)
2418        TypeAliasesAddI32(builder, self.i32)
2419        TypeAliasesAddU32(builder, self.u32)
2420        TypeAliasesAddI64(builder, self.i64)
2421        TypeAliasesAddU64(builder, self.u64)
2422        TypeAliasesAddF32(builder, self.f32)
2423        TypeAliasesAddF64(builder, self.f64)
2424        if self.v8 is not None:
2425            TypeAliasesAddV8(builder, v8)
2426        if self.vf64 is not None:
2427            TypeAliasesAddVf64(builder, vf64)
2428        typeAliases = TypeAliasesEnd(builder)
2429        return typeAliases
2430
2431
2432