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