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 2808