BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-16 17:22:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Flatbuffers Python Object API (#5616)

Browse Source 
* Flatbuffers Python Object API

Implement the logic to generate the Python object API that can
unpack the data from a buf class into an object class, and pack
the data of an object class to a buf class.

* Fix the build issues

Remove unused parameters and replace auto in the for-loop statement
with std::string to make it compatible with VS2010.

* Fix the build issues.

* Add support for Array type

Added logic to handle Array type in Python Object API. Updated the
generated code accordingly.

* Fix the old style casting from int to char

* Fixed another conversion from int to char

* Fixed the import for typing

Importing typing may cause errors when a machine do not have the
moduel typing installed. This PR fixes the issue by guarding
"import typing" with the "try/except" statement.

* Fix issue of iterating the vector of import list

* Update the generated examples using generate_code.sh

* Fix the import order for typing

The import list was stored in unordered_set, so that each generated
codes may have different import order. Therefore, it failed in the
consistency test where two generated copies need to have exactly the
same apperance.

* Optimize unpack using numpy

Use numpy to unpack vector whenever it is possible to improve unpack
performance.

Also, added codegen command for Python specificly in generate_code.sh,
because --no-includes cannot be turn on for Python.

* Fix the import order

* Update generate_code.bat for windows accordingly

* Replace error message with pass

Avoid printing error message for every Python2 users about typing.
Replace it with pass.
This commit is contained in:
lu-wang-g
2019-12-02 14:11:28 -08:00
committed by Wouter van Oortmerssen
parent 75823cc275
commit 65f8703572
29 changed files with 2846 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
tests/MyGame/Example/Ability.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Ability(object):
__slots__ = ['_tab']
@@ -21,3 +23,34 @@ def CreateAbility(builder, id, distance):
builder.PrependUint32(distance)
builder.PrependUint32(id)
return builder.Offset()
class AbilityT(object):
# AbilityT
def __init__(self):
self.id = 0 # type: int
self.distance = 0 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
ability = Ability()
ability.Init(buf, pos)
return cls.InitFromObj(ability)
@classmethod
def InitFromObj(cls, ability):
x = AbilityT()
x._UnPack(ability)
return x
# AbilityT
def _UnPack(self, ability):
if ability is None:
return
self.id = ability.Id()
self.distance = ability.Distance()
# AbilityT
def Pack(self, builder):
return CreateAbility(builder, self.id, self.distance)

15
tests/MyGame/Example/Any.py
View File

@@ -8,3 +8,18 @@ class Any(object):
TestSimpleTableWithEnum = 2
MyGame_Example2_Monster = 3
def AnyCreator(unionType, table):
from flatbuffers.table import Table
if not isinstance(table, Table):
return None
if unionType == Any().Monster:
import MyGame.Example.Monster
return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
if unionType == Any().TestSimpleTableWithEnum:
import MyGame.Example.TestSimpleTableWithEnum
return MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
if unionType == Any().MyGame_Example2_Monster:
import MyGame.Example2.Monster
return MyGame.Example2.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
return None

15
tests/MyGame/Example/AnyAmbiguousAliases.py
View File

@@ -8,3 +8,18 @@ class AnyAmbiguousAliases(object):
M2 = 2
M3 = 3
def AnyAmbiguousAliasesCreator(unionType, table):
from flatbuffers.table import Table
if not isinstance(table, Table):
return None
if unionType == AnyAmbiguousAliases().M1:
import MyGame.Example.Monster
return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
if unionType == AnyAmbiguousAliases().M2:
import MyGame.Example.Monster
return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
if unionType == AnyAmbiguousAliases().M3:
import MyGame.Example.Monster
return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
return None

15
tests/MyGame/Example/AnyUniqueAliases.py
View File

@@ -8,3 +8,18 @@ class AnyUniqueAliases(object):
TS = 2
M2 = 3
def AnyUniqueAliasesCreator(unionType, table):
from flatbuffers.table import Table
if not isinstance(table, Table):
return None
if unionType == AnyUniqueAliases().M:
import MyGame.Example.Monster
return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
if unionType == AnyUniqueAliases().TS:
import MyGame.Example.TestSimpleTableWithEnum
return MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
if unionType == AnyUniqueAliases().M2:
import MyGame.Example2.Monster
return MyGame.Example2.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
return None

97
tests/MyGame/Example/ArrayStruct.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class ArrayStruct(object):
__slots__ = ['_tab']
@@ -15,6 +17,18 @@ class ArrayStruct(object):
def A(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
# ArrayStruct
def B(self): return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + i * 4)) for i in range(15)]
# ArrayStruct
def BLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.VectorLen(o)
return 0
# ArrayStruct
def BIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
return o == 0
# ArrayStruct
def C(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(64))
# ArrayStruct
@@ -22,10 +36,34 @@ class ArrayStruct(object):
obj.Init(self._tab.Bytes, self._tab.Pos + 72 + i * 32)
return obj
# ArrayStruct
def DLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
if o != 0:
return self._tab.VectorLen(o)
return 0
# ArrayStruct
def DIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
return o == 0
# ArrayStruct
def E(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(136))
# ArrayStruct
def F(self): return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + i * 8)) for i in range(2)]
# ArrayStruct
def FLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
if o != 0:
return self._tab.VectorLen(o)
return 0
# ArrayStruct
def FIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
return o == 0
def CreateArrayStruct(builder, a, b, c, d_a, d_b, d_c, d_d, e, f):
builder.Prep(8, 160)
@@ -49,3 +87,62 @@ def CreateArrayStruct(builder, a, b, c, d_a, d_b, d_c, d_d, e, f):
builder.PrependInt32(b[_idx0-1])
builder.PrependFloat32(a)
return builder.Offset()
import MyGame.Example.NestedStruct
try:
from typing import List
except:
pass
class ArrayStructT(object):
# ArrayStructT
def __init__(self):
self.a = 0.0 # type: float
self.b = None # type: List[int]
self.c = 0 # type: int
self.d = None # type: List[MyGame.Example.NestedStruct.NestedStructT]
self.e = 0 # type: int
self.f = None # type: List[int]
@classmethod
def InitFromBuf(cls, buf, pos):
arrayStruct = ArrayStruct()
arrayStruct.Init(buf, pos)
return cls.InitFromObj(arrayStruct)
@classmethod
def InitFromObj(cls, arrayStruct):
x = ArrayStructT()
x._UnPack(arrayStruct)
return x
# ArrayStructT
def _UnPack(self, arrayStruct):
if arrayStruct is None:
return
self.a = arrayStruct.A()
if not arrayStruct.BIsNone():
if np is None:
self.b = []
for i in range(arrayStruct.BLength()):
self.b.append(arrayStruct.B(i))
else:
self.b = arrayStruct.BAsNumpy()
self.c = arrayStruct.C()
if not arrayStruct.DIsNone():
self.d = []
for i in range(arrayStruct.DLength()):
self.d.append(arrayStruct.D(i))
self.e = arrayStruct.E()
if not arrayStruct.FIsNone():
if np is None:
self.f = []
for i in range(arrayStruct.FLength()):
self.f.append(arrayStruct.F(i))
else:
self.f = arrayStruct.FAsNumpy()
# ArrayStructT
def Pack(self, builder):
return CreateArrayStruct(builder, self.a, self.b, self.c, self.d.a, self.d.b, self.d.c, self.d.d, self.e, self.f)

44
tests/MyGame/Example/ArrayTable.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class ArrayTable(object):
__slots__ = ['_tab']
@@ -27,7 +29,7 @@ class ArrayTable(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = o + self._tab.Pos
from .ArrayStruct import ArrayStruct
from MyGame.Example.ArrayStruct import ArrayStruct
obj = ArrayStruct()
obj.Init(self._tab.Bytes, x)
return obj
@@ -36,3 +38,43 @@ class ArrayTable(object):
def ArrayTableStart(builder): builder.StartObject(1)
def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def ArrayTableEnd(builder): return builder.EndObject()
import MyGame.Example.ArrayStruct
try:
from typing import Optional
except:
pass
class ArrayTableT(object):
# ArrayTableT
def __init__(self):
self.a = None # type: Optional[MyGame.Example.ArrayStruct.ArrayStructT]
@classmethod
def InitFromBuf(cls, buf, pos):
arrayTable = ArrayTable()
arrayTable.Init(buf, pos)
return cls.InitFromObj(arrayTable)
@classmethod
def InitFromObj(cls, arrayTable):
x = ArrayTableT()
x._UnPack(arrayTable)
return x
# ArrayTableT
def _UnPack(self, arrayTable):
if arrayTable is None:
return
if arrayTable.A() is not None:
self.a = MyGame.Example.ArrayStruct.ArrayStructT.InitFromObj(arrayTable.A())
# ArrayTableT
def Pack(self, builder):
ArrayTableStart(builder)
if self.a is not None:
a = self.a.Pack(builder)
ArrayTableAddA(builder, a)
arrayTable = ArrayTableEnd(builder)
return arrayTable

558
tests/MyGame/Example/Monster.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
# an example documentation comment: monster object
class Monster(object):
@@ -28,7 +30,7 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = o + self._tab.Pos
from .Vec3 import Vec3
from MyGame.Example.Vec3 import Vec3
obj = Vec3()
obj.Init(self._tab.Bytes, x)
return obj
@@ -77,6 +79,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def InventoryIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
return o == 0
# Monster
def Color(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
@@ -107,7 +114,7 @@ class Monster(object):
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
from .Test import Test
from MyGame.Example.Test import Test
obj = Test()
obj.Init(self._tab.Bytes, x)
return obj
@@ -120,6 +127,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def Test4IsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
return o == 0
# Monster
def Testarrayofstring(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
@@ -135,6 +147,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def TestarrayofstringIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
return o == 0
# an example documentation comment: this will end up in the generated code
# multiline too
# Monster
@@ -144,7 +161,7 @@ class Monster(object):
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
x = self._tab.Indirect(x)
from .Monster import Monster
from MyGame.Example.Monster import Monster
obj = Monster()
obj.Init(self._tab.Bytes, x)
return obj
@@ -157,12 +174,17 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def TestarrayoftablesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
return o == 0
# Monster
def Enemy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from .Monster import Monster
from MyGame.Example.Monster import Monster
obj = Monster()
obj.Init(self._tab.Bytes, x)
return obj
@@ -190,12 +212,17 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def TestnestedflatbufferIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
return o == 0
# Monster
def Testempty(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from .Stat import Stat
from MyGame.Example.Stat import Stat
obj = Stat()
obj.Init(self._tab.Bytes, x)
return obj
@@ -286,6 +313,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def TestarrayofboolsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
return o == 0
# Monster
def Testf(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
@@ -322,13 +354,18 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def Testarrayofstring2IsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
return o == 0
# Monster
def Testarrayofsortedstruct(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from .Ability import Ability
from MyGame.Example.Ability import Ability
obj = Ability()
obj.Init(self._tab.Bytes, x)
return obj
@@ -341,6 +378,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def TestarrayofsortedstructIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
return o == 0
# Monster
def Flex(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
@@ -363,13 +405,18 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def FlexIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
return o == 0
# Monster
def Test5(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
from .Test import Test
from MyGame.Example.Test import Test
obj = Test()
obj.Init(self._tab.Bytes, x)
return obj
@@ -382,6 +429,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def Test5IsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
return o == 0
# Monster
def VectorOfLongs(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
@@ -404,6 +456,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfLongsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
return o == 0
# Monster
def VectorOfDoubles(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
@@ -426,12 +483,17 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfDoublesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
return o == 0
# Monster
def ParentNamespaceTest(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from .InParentNamespace import InParentNamespace
from MyGame.InParentNamespace import InParentNamespace
obj = InParentNamespace()
obj.Init(self._tab.Bytes, x)
return obj
@@ -444,7 +506,7 @@ class Monster(object):
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
x = self._tab.Indirect(x)
from .Referrable import Referrable
from MyGame.Example.Referrable import Referrable
obj = Referrable()
obj.Init(self._tab.Bytes, x)
return obj
@@ -457,6 +519,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfReferrablesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
return o == 0
# Monster
def SingleWeakReference(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
@@ -486,6 +553,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfWeakReferencesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
return o == 0
# Monster
def VectorOfStrongReferrables(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
@@ -493,7 +565,7 @@ class Monster(object):
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
x = self._tab.Indirect(x)
from .Referrable import Referrable
from MyGame.Example.Referrable import Referrable
obj = Referrable()
obj.Init(self._tab.Bytes, x)
return obj
@@ -506,6 +578,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfStrongReferrablesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
return o == 0
# Monster
def CoOwningReference(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
@@ -535,6 +612,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfCoOwningReferencesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
return o == 0
# Monster
def NonOwningReference(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
@@ -564,6 +646,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfNonOwningReferencesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
return o == 0
# Monster
def AnyUniqueType(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
@@ -620,6 +707,11 @@ class Monster(object):
return self._tab.VectorLen(o)
return 0
# Monster
def VectorOfEnumsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
return o == 0
# Monster
def SignedEnum(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
@@ -695,3 +787,449 @@ def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRela
def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
def MonsterEnd(builder): return builder.EndObject()
import MyGame.Example.Ability
import MyGame.Example.Any
import MyGame.Example.AnyAmbiguousAliases
import MyGame.Example.AnyUniqueAliases
import MyGame.Example.Referrable
import MyGame.Example.Stat
import MyGame.Example.Test
import MyGame.Example.TestSimpleTableWithEnum
import MyGame.Example.Vec3
import MyGame.Example2.Monster
import MyGame.InParentNamespace
try:
from typing import List, Optional, Union
except:
pass
class MonsterT(object):
# MonsterT
def __init__(self):
self.pos = None # type: Optional[MyGame.Example.Vec3.Vec3T]
self.mana = 150 # type: int
self.hp = 100 # type: int
self.name = None # type: str
self.inventory = None # type: List[int]
self.color = 8 # type: int
self.testType = 0 # type: int
self.test = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
self.test4 = None # type: List[MyGame.Example.Test.TestT]
self.testarrayofstring = None # type: List[str]
self.testarrayoftables = None # type: List[MyGame.Example.Monster.MonsterT]
self.enemy = None # type: Optional[MyGame.Example.Monster.MonsterT]
self.testnestedflatbuffer = None # type: List[int]
self.testempty = None # type: Optional[MyGame.Example.Stat.StatT]
self.testbool = False # type: bool
self.testhashs32Fnv1 = 0 # type: int
self.testhashu32Fnv1 = 0 # type: int
self.testhashs64Fnv1 = 0 # type: int
self.testhashu64Fnv1 = 0 # type: int
self.testhashs32Fnv1a = 0 # type: int
self.testhashu32Fnv1a = 0 # type: int
self.testhashs64Fnv1a = 0 # type: int
self.testhashu64Fnv1a = 0 # type: int
self.testarrayofbools = None # type: List[bool]
self.testf = 3.14159 # type: float
self.testf2 = 3.0 # type: float
self.testf3 = 0.0 # type: float
self.testarrayofstring2 = None # type: List[str]
self.testarrayofsortedstruct = None # type: List[MyGame.Example.Ability.AbilityT]
self.flex = None # type: List[int]
self.test5 = None # type: List[MyGame.Example.Test.TestT]
self.vectorOfLongs = None # type: List[int]
self.vectorOfDoubles = None # type: List[float]
self.parentNamespaceTest = None # type: Optional[MyGame.InParentNamespace.InParentNamespaceT]
self.vectorOfReferrables = None # type: List[MyGame.Example.Referrable.ReferrableT]
self.singleWeakReference = 0 # type: int
self.vectorOfWeakReferences = None # type: List[int]
self.vectorOfStrongReferrables = None # type: List[MyGame.Example.Referrable.ReferrableT]
self.coOwningReference = 0 # type: int
self.vectorOfCoOwningReferences = None # type: List[int]
self.nonOwningReference = 0 # type: int
self.vectorOfNonOwningReferences = None # type: List[int]
self.anyUniqueType = 0 # type: int
self.anyUnique = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
self.anyAmbiguousType = 0 # type: int
self.anyAmbiguous = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
self.vectorOfEnums = None # type: List[int]
self.signedEnum = -1 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
monster = Monster()
monster.Init(buf, pos)
return cls.InitFromObj(monster)
@classmethod
def InitFromObj(cls, monster):
x = MonsterT()
x._UnPack(monster)
return x
# MonsterT
def _UnPack(self, monster):
if monster is None:
return
if monster.Pos() is not None:
self.pos = MyGame.Example.Vec3.Vec3T.InitFromObj(monster.Pos())
self.mana = monster.Mana()
self.hp = monster.Hp()
self.name = monster.Name()
if not monster.InventoryIsNone():
if np is None:
self.inventory = []
for i in range(monster.InventoryLength()):
self.inventory.append(monster.Inventory(i))
else:
self.inventory = monster.InventoryAsNumpy()
self.color = monster.Color()
self.testType = monster.TestType()
self.test = MyGame.Example.Any.AnyCreator(self.testType, monster.Test())
if not monster.Test4IsNone():
self.test4 = []
for i in range(monster.Test4Length()):
if monster.Test4(i) is None:
self.test4.append(None)
else:
test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test4(i))
self.test4.append(test_)
if not monster.TestarrayofstringIsNone():
self.testarrayofstring = []
for i in range(monster.TestarrayofstringLength()):
self.testarrayofstring.append(monster.Testarrayofstring(i))
if not monster.TestarrayoftablesIsNone():
self.testarrayoftables = []
for i in range(monster.TestarrayoftablesLength()):
if monster.Testarrayoftables(i) is None:
self.testarrayoftables.append(None)
else:
monster_ = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Testarrayoftables(i))
self.testarrayoftables.append(monster_)
if monster.Enemy() is not None:
self.enemy = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Enemy())
if not monster.TestnestedflatbufferIsNone():
if np is None:
self.testnestedflatbuffer = []
for i in range(monster.TestnestedflatbufferLength()):
self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
else:
self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
if monster.Testempty() is not None:
self.testempty = MyGame.Example.Stat.StatT.InitFromObj(monster.Testempty())
self.testbool = monster.Testbool()
self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
if not monster.TestarrayofboolsIsNone():
if np is None:
self.testarrayofbools = []
for i in range(monster.TestarrayofboolsLength()):
self.testarrayofbools.append(monster.Testarrayofbools(i))
else:
self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
self.testf = monster.Testf()
self.testf2 = monster.Testf2()
self.testf3 = monster.Testf3()
if not monster.Testarrayofstring2IsNone():
self.testarrayofstring2 = []
for i in range(monster.Testarrayofstring2Length()):
self.testarrayofstring2.append(monster.Testarrayofstring2(i))
if not monster.TestarrayofsortedstructIsNone():
self.testarrayofsortedstruct = []
for i in range(monster.TestarrayofsortedstructLength()):
if monster.Testarrayofsortedstruct(i) is None:
self.testarrayofsortedstruct.append(None)
else:
ability_ = MyGame.Example.Ability.AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
self.testarrayofsortedstruct.append(ability_)
if not monster.FlexIsNone():
if np is None:
self.flex = []
for i in range(monster.FlexLength()):
self.flex.append(monster.Flex(i))
else:
self.flex = monster.FlexAsNumpy()
if not monster.Test5IsNone():
self.test5 = []
for i in range(monster.Test5Length()):
if monster.Test5(i) is None:
self.test5.append(None)
else:
test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test5(i))
self.test5.append(test_)
if not monster.VectorOfLongsIsNone():
if np is None:
self.vectorOfLongs = []
for i in range(monster.VectorOfLongsLength()):
self.vectorOfLongs.append(monster.VectorOfLongs(i))
else:
self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
if not monster.VectorOfDoublesIsNone():
if np is None:
self.vectorOfDoubles = []
for i in range(monster.VectorOfDoublesLength()):
self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
else:
self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
if monster.ParentNamespaceTest() is not None:
self.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
if not monster.VectorOfReferrablesIsNone():
self.vectorOfReferrables = []
for i in range(monster.VectorOfReferrablesLength()):
if monster.VectorOfReferrables(i) is None:
self.vectorOfReferrables.append(None)
else:
referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
self.vectorOfReferrables.append(referrable_)
self.singleWeakReference = monster.SingleWeakReference()
if not monster.VectorOfWeakReferencesIsNone():
if np is None:
self.vectorOfWeakReferences = []
for i in range(monster.VectorOfWeakReferencesLength()):
self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
else:
self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
if not monster.VectorOfStrongReferrablesIsNone():
self.vectorOfStrongReferrables = []
for i in range(monster.VectorOfStrongReferrablesLength()):
if monster.VectorOfStrongReferrables(i) is None:
self.vectorOfStrongReferrables.append(None)
else:
referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
self.vectorOfStrongReferrables.append(referrable_)
self.coOwningReference = monster.CoOwningReference()
if not monster.VectorOfCoOwningReferencesIsNone():
if np is None:
self.vectorOfCoOwningReferences = []
for i in range(monster.VectorOfCoOwningReferencesLength()):
self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
else:
self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
self.nonOwningReference = monster.NonOwningReference()
if not monster.VectorOfNonOwningReferencesIsNone():
if np is None:
self.vectorOfNonOwningReferences = []
for i in range(monster.VectorOfNonOwningReferencesLength()):
self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
else:
self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
self.anyUniqueType = monster.AnyUniqueType()
self.anyUnique = MyGame.Example.AnyUniqueAliases.AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
self.anyAmbiguousType = monster.AnyAmbiguousType()
self.anyAmbiguous = MyGame.Example.AnyAmbiguousAliases.AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
if not monster.VectorOfEnumsIsNone():
if np is None:
self.vectorOfEnums = []
for i in range(monster.VectorOfEnumsLength()):
self.vectorOfEnums.append(monster.VectorOfEnums(i))
else:
self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
self.signedEnum = monster.SignedEnum()
# MonsterT
def Pack(self, builder):
if self.name is not None:
name = builder.CreateString(self.name)
if self.inventory is not None:
MonsterStartInventoryVector(builder, len(self.inventory))
for i in reversed(range(len(self.inventory))):
builder.PrependUint8(self.inventory[i])
inventory = builder.EndVector(len(self.inventory))
if self.test is not None:
test = self.test.Pack(builder)
if self.test4 is not None:
MonsterStartTest4Vector(builder, len(self.test4))
for i in reversed(range(len(self.test4))):
self.test4[i].Pack(builder)
test4 = builder.EndVector(len(self.test4))
if self.testarrayofstring is not None:
testarrayofstringlist = []
for i in range(len(self.testarrayofstring)):
testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
for i in reversed(range(len(self.testarrayofstring))):
builder.PrependUOffsetTRelative(testarrayofstringlist[i])
testarrayofstring = builder.EndVector(len(self.testarrayofstring))
if self.testarrayoftables is not None:
testarrayoftableslist = []
for i in range(len(self.testarrayoftables)):
testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
for i in reversed(range(len(self.testarrayoftables))):
builder.PrependUOffsetTRelative(testarrayoftableslist[i])
testarrayoftables = builder.EndVector(len(self.testarrayoftables))
if self.enemy is not None:
enemy = self.enemy.Pack(builder)
if self.testnestedflatbuffer is not None:
MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
for i in reversed(range(len(self.testnestedflatbuffer))):
builder.PrependUint8(self.testnestedflatbuffer[i])
testnestedflatbuffer = builder.EndVector(len(self.testnestedflatbuffer))
if self.testempty is not None:
testempty = self.testempty.Pack(builder)
if self.testarrayofbools is not None:
MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
for i in reversed(range(len(self.testarrayofbools))):
builder.PrependBool(self.testarrayofbools[i])
testarrayofbools = builder.EndVector(len(self.testarrayofbools))
if self.testarrayofstring2 is not None:
testarrayofstring2list = []
for i in range(len(self.testarrayofstring2)):
testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
for i in reversed(range(len(self.testarrayofstring2))):
builder.PrependUOffsetTRelative(testarrayofstring2list[i])
testarrayofstring2 = builder.EndVector(len(self.testarrayofstring2))
if self.testarrayofsortedstruct is not None:
MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
for i in reversed(range(len(self.testarrayofsortedstruct))):
self.testarrayofsortedstruct[i].Pack(builder)
testarrayofsortedstruct = builder.EndVector(len(self.testarrayofsortedstruct))
if self.flex is not None:
MonsterStartFlexVector(builder, len(self.flex))
for i in reversed(range(len(self.flex))):
builder.PrependUint8(self.flex[i])
flex = builder.EndVector(len(self.flex))
if self.test5 is not None:
MonsterStartTest5Vector(builder, len(self.test5))
for i in reversed(range(len(self.test5))):
self.test5[i].Pack(builder)
test5 = builder.EndVector(len(self.test5))
if self.vectorOfLongs is not None:
MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
for i in reversed(range(len(self.vectorOfLongs))):
builder.PrependInt64(self.vectorOfLongs[i])
vectorOfLongs = builder.EndVector(len(self.vectorOfLongs))
if self.vectorOfDoubles is not None:
MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
for i in reversed(range(len(self.vectorOfDoubles))):
builder.PrependFloat64(self.vectorOfDoubles[i])
vectorOfDoubles = builder.EndVector(len(self.vectorOfDoubles))
if self.parentNamespaceTest is not None:
parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
if self.vectorOfReferrables is not None:
vectorOfReferrableslist = []
for i in range(len(self.vectorOfReferrables)):
vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
for i in reversed(range(len(self.vectorOfReferrables))):
builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
vectorOfReferrables = builder.EndVector(len(self.vectorOfReferrables))
if self.vectorOfWeakReferences is not None:
MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
for i in reversed(range(len(self.vectorOfWeakReferences))):
builder.PrependUint64(self.vectorOfWeakReferences[i])
vectorOfWeakReferences = builder.EndVector(len(self.vectorOfWeakReferences))
if self.vectorOfStrongReferrables is not None:
vectorOfStrongReferrableslist = []
for i in range(len(self.vectorOfStrongReferrables)):
vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
for i in reversed(range(len(self.vectorOfStrongReferrables))):
builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
vectorOfStrongReferrables = builder.EndVector(len(self.vectorOfStrongReferrables))
if self.vectorOfCoOwningReferences is not None:
MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
for i in reversed(range(len(self.vectorOfCoOwningReferences))):
builder.PrependUint64(self.vectorOfCoOwningReferences[i])
vectorOfCoOwningReferences = builder.EndVector(len(self.vectorOfCoOwningReferences))
if self.vectorOfNonOwningReferences is not None:
MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
for i in reversed(range(len(self.vectorOfNonOwningReferences))):
builder.PrependUint64(self.vectorOfNonOwningReferences[i])
vectorOfNonOwningReferences = builder.EndVector(len(self.vectorOfNonOwningReferences))
if self.anyUnique is not None:
anyUnique = self.anyUnique.Pack(builder)
if self.anyAmbiguous is not None:
anyAmbiguous = self.anyAmbiguous.Pack(builder)
if self.vectorOfEnums is not None:
MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
for i in reversed(range(len(self.vectorOfEnums))):
builder.PrependUint8(self.vectorOfEnums[i])
vectorOfEnums = builder.EndVector(len(self.vectorOfEnums))
MonsterStart(builder)
if self.pos is not None:
pos = self.pos.Pack(builder)
MonsterAddPos(builder, pos)
MonsterAddMana(builder, self.mana)
MonsterAddHp(builder, self.hp)
if self.name is not None:
MonsterAddName(builder, name)
if self.inventory is not None:
MonsterAddInventory(builder, inventory)
MonsterAddColor(builder, self.color)
MonsterAddTestType(builder, self.testType)
if self.test is not None:
MonsterAddTest(builder, test)
if self.test4 is not None:
MonsterAddTest4(builder, test4)
if self.testarrayofstring is not None:
MonsterAddTestarrayofstring(builder, testarrayofstring)
if self.testarrayoftables is not None:
MonsterAddTestarrayoftables(builder, testarrayoftables)
if self.enemy is not None:
MonsterAddEnemy(builder, enemy)
if self.testnestedflatbuffer is not None:
MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
if self.testempty is not None:
MonsterAddTestempty(builder, testempty)
MonsterAddTestbool(builder, self.testbool)
MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
if self.testarrayofbools is not None:
MonsterAddTestarrayofbools(builder, testarrayofbools)
MonsterAddTestf(builder, self.testf)
MonsterAddTestf2(builder, self.testf2)
MonsterAddTestf3(builder, self.testf3)
if self.testarrayofstring2 is not None:
MonsterAddTestarrayofstring2(builder, testarrayofstring2)
if self.testarrayofsortedstruct is not None:
MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
if self.flex is not None:
MonsterAddFlex(builder, flex)
if self.test5 is not None:
MonsterAddTest5(builder, test5)
if self.vectorOfLongs is not None:
MonsterAddVectorOfLongs(builder, vectorOfLongs)
if self.vectorOfDoubles is not None:
MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
if self.parentNamespaceTest is not None:
MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
if self.vectorOfReferrables is not None:
MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
MonsterAddSingleWeakReference(builder, self.singleWeakReference)
if self.vectorOfWeakReferences is not None:
MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
if self.vectorOfStrongReferrables is not None:
MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
MonsterAddCoOwningReference(builder, self.coOwningReference)
if self.vectorOfCoOwningReferences is not None:
MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
MonsterAddNonOwningReference(builder, self.nonOwningReference)
if self.vectorOfNonOwningReferences is not None:
MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
MonsterAddAnyUniqueType(builder, self.anyUniqueType)
if self.anyUnique is not None:
MonsterAddAnyUnique(builder, anyUnique)
MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
if self.anyAmbiguous is not None:
MonsterAddAnyAmbiguous(builder, anyAmbiguous)
if self.vectorOfEnums is not None:
MonsterAddVectorOfEnums(builder, vectorOfEnums)
MonsterAddSignedEnum(builder, self.signedEnum)
monster = MonsterEnd(builder)
return monster

95
tests/MyGame/Example/NestedStruct.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class NestedStruct(object):
__slots__ = ['_tab']
@@ -13,12 +15,48 @@ class NestedStruct(object):
# NestedStruct
def A(self): return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 4)) for i in range(2)]
# NestedStruct
def ALength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(0))
if o != 0:
return self._tab.VectorLen(o)
return 0
# NestedStruct
def AIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(0))
return o == 0
# NestedStruct
def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
# NestedStruct
def C(self): return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + i * 1)) for i in range(2)]
# NestedStruct
def CLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(9))
if o != 0:
return self._tab.VectorLen(o)
return 0
# NestedStruct
def CIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(9))
return o == 0
# NestedStruct
def D(self): return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + i * 8)) for i in range(2)]
# NestedStruct
def DLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.VectorLen(o)
return 0
# NestedStruct
def DIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
return o == 0
def CreateNestedStruct(builder, a, b, c, d):
builder.Prep(8, 32)
@@ -31,3 +69,60 @@ def CreateNestedStruct(builder, a, b, c, d):
for _idx0 in range(2 , 0, -1):
builder.PrependInt32(a[_idx0-1])
return builder.Offset()
try:
from typing import List
except:
pass
class NestedStructT(object):
# NestedStructT
def __init__(self):
self.a = None # type: List[int]
self.b = 0 # type: int
self.c = None # type: List[int]
self.d = None # type: List[int]
@classmethod
def InitFromBuf(cls, buf, pos):
nestedStruct = NestedStruct()
nestedStruct.Init(buf, pos)
return cls.InitFromObj(nestedStruct)
@classmethod
def InitFromObj(cls, nestedStruct):
x = NestedStructT()
x._UnPack(nestedStruct)
return x
# NestedStructT
def _UnPack(self, nestedStruct):
if nestedStruct is None:
return
if not nestedStruct.AIsNone():
if np is None:
self.a = []
for i in range(nestedStruct.ALength()):
self.a.append(nestedStruct.A(i))
else:
self.a = nestedStruct.AAsNumpy()
self.b = nestedStruct.B()
if not nestedStruct.CIsNone():
if np is None:
self.c = []
for i in range(nestedStruct.CLength()):
self.c.append(nestedStruct.C(i))
else:
self.c = nestedStruct.CAsNumpy()
if not nestedStruct.DIsNone():
if np is None:
self.d = []
for i in range(nestedStruct.DLength()):
self.d.append(nestedStruct.D(i))
else:
self.d = nestedStruct.DAsNumpy()
# NestedStructT
def Pack(self, builder):
return CreateNestedStruct(builder, self.a, self.b, self.c, self.d)

34
tests/MyGame/Example/Referrable.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Referrable(object):
__slots__ = ['_tab']
@@ -32,3 +34,35 @@ class Referrable(object):
def ReferrableStart(builder): builder.StartObject(1)
def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
def ReferrableEnd(builder): return builder.EndObject()
class ReferrableT(object):
# ReferrableT
def __init__(self):
self.id = 0 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
referrable = Referrable()
referrable.Init(buf, pos)
return cls.InitFromObj(referrable)
@classmethod
def InitFromObj(cls, referrable):
x = ReferrableT()
x._UnPack(referrable)
return x
# ReferrableT
def _UnPack(self, referrable):
if referrable is None:
return
self.id = referrable.Id()
# ReferrableT
def Pack(self, builder):
ReferrableStart(builder)
ReferrableAddId(builder, self.id)
referrable = ReferrableEnd(builder)
return referrable

43
tests/MyGame/Example/Stat.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Stat(object):
__slots__ = ['_tab']
@@ -48,3 +50,44 @@ def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.n
def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
def StatEnd(builder): return builder.EndObject()
class StatT(object):
# StatT
def __init__(self):
self.id = None # type: str
self.val = 0 # type: int
self.count = 0 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
stat = Stat()
stat.Init(buf, pos)
return cls.InitFromObj(stat)
@classmethod
def InitFromObj(cls, stat):
x = StatT()
x._UnPack(stat)
return x
# StatT
def _UnPack(self, stat):
if stat is None:
return
self.id = stat.Id()
self.val = stat.Val()
self.count = stat.Count()
# StatT
def Pack(self, builder):
if self.id is not None:
id = builder.CreateString(self.id)
StatStart(builder)
if self.id is not None:
StatAddId(builder, id)
StatAddVal(builder, self.val)
StatAddCount(builder, self.count)
stat = StatEnd(builder)
return stat

33
tests/MyGame/Example/Test.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Test(object):
__slots__ = ['_tab']
@@ -22,3 +24,34 @@ def CreateTest(builder, a, b):
builder.PrependInt8(b)
builder.PrependInt16(a)
return builder.Offset()
class TestT(object):
# TestT
def __init__(self):
self.a = 0 # type: int
self.b = 0 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
test = Test()
test.Init(buf, pos)
return cls.InitFromObj(test)
@classmethod
def InitFromObj(cls, test):
x = TestT()
x._UnPack(test)
return x
# TestT
def _UnPack(self, test):
if test is None:
return
self.a = test.A()
self.b = test.B()
# TestT
def Pack(self, builder):
return CreateTest(builder, self.a, self.b)

34
tests/MyGame/Example/TestSimpleTableWithEnum.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class TestSimpleTableWithEnum(object):
__slots__ = ['_tab']
@@ -32,3 +34,35 @@ class TestSimpleTableWithEnum(object):
def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
class TestSimpleTableWithEnumT(object):
# TestSimpleTableWithEnumT
def __init__(self):
self.color = 2 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
testSimpleTableWithEnum = TestSimpleTableWithEnum()
testSimpleTableWithEnum.Init(buf, pos)
return cls.InitFromObj(testSimpleTableWithEnum)
@classmethod
def InitFromObj(cls, testSimpleTableWithEnum):
x = TestSimpleTableWithEnumT()
x._UnPack(testSimpleTableWithEnum)
return x
# TestSimpleTableWithEnumT
def _UnPack(self, testSimpleTableWithEnum):
if testSimpleTableWithEnum is None:
return
self.color = testSimpleTableWithEnum.Color()
# TestSimpleTableWithEnumT
def Pack(self, builder):
TestSimpleTableWithEnumStart(builder)
TestSimpleTableWithEnumAddColor(builder, self.color)
testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
return testSimpleTableWithEnum

105
tests/MyGame/Example/TypeAliases.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class TypeAliases(object):
__slots__ = ['_tab']
@@ -114,6 +116,11 @@ class TypeAliases(object):
return self._tab.VectorLen(o)
return 0
# TypeAliases
def V8IsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
return o == 0
# TypeAliases
def Vf64(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
@@ -136,6 +143,11 @@ class TypeAliases(object):
return self._tab.VectorLen(o)
return 0
# TypeAliases
def Vf64IsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
return o == 0
def TypeAliasesStart(builder): builder.StartObject(12)
def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
@@ -152,3 +164,96 @@ def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, n
def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
def TypeAliasesEnd(builder): return builder.EndObject()
try:
from typing import List
except:
pass
class TypeAliasesT(object):
# TypeAliasesT
def __init__(self):
self.i8 = 0 # type: int
self.u8 = 0 # type: int
self.i16 = 0 # type: int
self.u16 = 0 # type: int
self.i32 = 0 # type: int
self.u32 = 0 # type: int
self.i64 = 0 # type: int
self.u64 = 0 # type: int
self.f32 = 0.0 # type: float
self.f64 = 0.0 # type: float
self.v8 = None # type: List[int]
self.vf64 = None # type: List[float]
@classmethod
def InitFromBuf(cls, buf, pos):
typeAliases = TypeAliases()
typeAliases.Init(buf, pos)
return cls.InitFromObj(typeAliases)
@classmethod
def InitFromObj(cls, typeAliases):
x = TypeAliasesT()
x._UnPack(typeAliases)
return x
# TypeAliasesT
def _UnPack(self, typeAliases):
if typeAliases is None:
return
self.i8 = typeAliases.I8()
self.u8 = typeAliases.U8()
self.i16 = typeAliases.I16()
self.u16 = typeAliases.U16()
self.i32 = typeAliases.I32()
self.u32 = typeAliases.U32()
self.i64 = typeAliases.I64()
self.u64 = typeAliases.U64()
self.f32 = typeAliases.F32()
self.f64 = typeAliases.F64()
if not typeAliases.V8IsNone():
if np is None:
self.v8 = []
for i in range(typeAliases.V8Length()):
self.v8.append(typeAliases.V8(i))
else:
self.v8 = typeAliases.V8AsNumpy()
if not typeAliases.Vf64IsNone():
if np is None:
self.vf64 = []
for i in range(typeAliases.Vf64Length()):
self.vf64.append(typeAliases.Vf64(i))
else:
self.vf64 = typeAliases.Vf64AsNumpy()
# TypeAliasesT
def Pack(self, builder):
if self.v8 is not None:
TypeAliasesStartV8Vector(builder, len(self.v8))
for i in reversed(range(len(self.v8))):
builder.PrependByte(self.v8[i])
v8 = builder.EndVector(len(self.v8))
if self.vf64 is not None:
TypeAliasesStartVf64Vector(builder, len(self.vf64))
for i in reversed(range(len(self.vf64))):
builder.PrependFloat64(self.vf64[i])
vf64 = builder.EndVector(len(self.vf64))
TypeAliasesStart(builder)
TypeAliasesAddI8(builder, self.i8)
TypeAliasesAddU8(builder, self.u8)
TypeAliasesAddI16(builder, self.i16)
TypeAliasesAddU16(builder, self.u16)
TypeAliasesAddI32(builder, self.i32)
TypeAliasesAddU32(builder, self.u32)
TypeAliasesAddI64(builder, self.i64)
TypeAliasesAddU64(builder, self.u64)
TypeAliasesAddF32(builder, self.f32)
TypeAliasesAddF64(builder, self.f64)
if self.v8 is not None:
TypeAliasesAddV8(builder, v8)
if self.vf64 is not None:
TypeAliasesAddVf64(builder, vf64)
typeAliases = TypeAliasesEnd(builder)
return typeAliases

47
tests/MyGame/Example/Vec3.py
View File

@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Vec3(object):
__slots__ = ['_tab']
@@ -42,3 +44,48 @@ def CreateVec3(builder, x, y, z, test1, test2, test3_a, test3_b):
builder.PrependFloat32(y)
builder.PrependFloat32(x)
return builder.Offset()
import MyGame.Example.Test
try:
from typing import Optional
except:
pass
class Vec3T(object):
# Vec3T
def __init__(self):
self.x = 0.0 # type: float
self.y = 0.0 # type: float
self.z = 0.0 # type: float
self.test1 = 0.0 # type: float
self.test2 = 0 # type: int
self.test3 = None # type: Optional[MyGame.Example.Test.TestT]
@classmethod
def InitFromBuf(cls, buf, pos):
vec3 = Vec3()
vec3.Init(buf, pos)
return cls.InitFromObj(vec3)
@classmethod
def InitFromObj(cls, vec3):
x = Vec3T()
x._UnPack(vec3)
return x
# Vec3T
def _UnPack(self, vec3):
if vec3 is None:
return
self.x = vec3.X()
self.y = vec3.Y()
self.z = vec3.Z()
self.test1 = vec3.Test1()
self.test2 = vec3.Test2()
if vec3.Test3(MyGame.Example.Test.Test()) is not None:
self.test3 = MyGame.Example.Test.TestT.InitFromObj(vec3.Test3(MyGame.Example.Test.Test()))
# Vec3T
def Pack(self, builder):
return CreateVec3(builder, self.x, self.y, self.z, self.test1, self.test2, self.test3.a, self.test3.b)