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

Keep methods with struct name and switch them to default (#6879)

Browse Source 
* Keep methods with struct name and switch them to default

This PR can help fix the following two issues:
1): A set of simplified API (without struct name) was added in
https://github.com/google/flatbuffers/pull/6336. It causes name
conflict when merging all generated python file into a single one
(the primary usage senario in Google).
2): Flatbuffers 2.0 generates absolute import path, which may cause
name space conflicts. See more details in
https://github.com/google/flatbuffers/issues/5840.

The solution for both is to generate the merged Python code, similar
C++. The merged code will not contain the simplied API, but only the
method with struct name. For issue (1), it will mimic the exactly
usage pattern for Google internal. For issue (2), users can generate
the merged flatbuffer code, without worrying about the imports.

The above idea will be implemented in the following steps:
Step 1 (this PR): revert changes in https://github.com/google/flatbuffers/pull/6336
that set the simplified API as default. Remove statements that the
original API will be deprecated, and reset the original API as default.
Step 2 (the following PR): create a flag to generate the merged code.
The Simplified API will be removed from the merged code, otherwise it
will cause name conflict.

* Update the generated sample code

* Update the generated example code

* Reverst the changes of GetRootAs

* Update examples from grpc/example/generate.sh
This commit is contained in:
lu-wang-g
2021-11-04 15:12:25 -07:00
committed by GitHub
parent f8b69e3308
commit fd4ff23da0
16 changed files with 730 additions and 822 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -39,18 +39,15 @@ class ArrayTable(object):
return obj
return None
def Start(builder): builder.StartObject(1)
def ArrayTableStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def ArrayTableAddA(builder, a):
"""This method is deprecated. Please switch to AddA."""
return AddA(builder, a)
def End(builder): return builder.EndObject()
def ArrayTableEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def ArrayTableStart(builder): builder.StartObject(1)
def Start(builder):
return ArrayTableStart(builder)
def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def AddA(builder, a):
return ArrayTableAddA(builder, a)
def ArrayTableEnd(builder): return builder.EndObject()
def End(builder):
return ArrayTableEnd(builder)
import MyGame.Example.ArrayStruct
try:
from typing import Optional
@@ -84,9 +81,9 @@ class ArrayTableT(object):
# ArrayTableT
def Pack(self, builder):
Start(builder)
ArrayTableStart(builder)
if self.a is not None:
a = self.a.Pack(builder)
AddA(builder, a)
arrayTable = End(builder)
ArrayTableAddA(builder, a)
arrayTable = ArrayTableEnd(builder)
return arrayTable

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

@@ -214,7 +214,7 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
from MyGame.Example.Monster import Monster
return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
return 0
# Monster
@@ -751,7 +751,7 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0:
from MyGame.Example.Monster import Monster
return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
return 0
# Monster
@@ -791,314 +791,236 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
return o == 0
def Start(builder): builder.StartObject(51)
def MonsterStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
def MonsterAddPos(builder, pos):
"""This method is deprecated. Please switch to AddPos."""
return AddPos(builder, pos)
def AddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
def MonsterAddMana(builder, mana):
"""This method is deprecated. Please switch to AddMana."""
return AddMana(builder, mana)
def AddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
def MonsterAddHp(builder, hp):
"""This method is deprecated. Please switch to AddHp."""
return AddHp(builder, hp)
def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def MonsterAddName(builder, name):
"""This method is deprecated. Please switch to AddName."""
return AddName(builder, name)
def AddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
def MonsterAddInventory(builder, inventory):
"""This method is deprecated. Please switch to AddInventory."""
return AddInventory(builder, inventory)
def StartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartInventoryVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartInventoryVector(builder, numElems)
def AddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
def MonsterAddColor(builder, color):
"""This method is deprecated. Please switch to AddColor."""
return AddColor(builder, color)
def AddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
def MonsterAddTestType(builder, testType):
"""This method is deprecated. Please switch to AddTestType."""
return AddTestType(builder, testType)
def AddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
def MonsterAddTest(builder, test):
"""This method is deprecated. Please switch to AddTest."""
return AddTest(builder, test)
def AddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
def MonsterAddTest4(builder, test4):
"""This method is deprecated. Please switch to AddTest4."""
return AddTest4(builder, test4)
def StartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
def MonsterStartTest4Vector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTest4Vector(builder, numElems)
def AddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
def MonsterAddTestarrayofstring(builder, testarrayofstring):
"""This method is deprecated. Please switch to AddTestarrayofstring."""
return AddTestarrayofstring(builder, testarrayofstring)
def StartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterStartTestarrayofstringVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestarrayofstringVector(builder, numElems)
def AddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
def MonsterAddTestarrayoftables(builder, testarrayoftables):
"""This method is deprecated. Please switch to AddTestarrayoftables."""
return AddTestarrayoftables(builder, testarrayoftables)
def StartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterStartTestarrayoftablesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestarrayoftablesVector(builder, numElems)
def AddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
def MonsterAddEnemy(builder, enemy):
"""This method is deprecated. Please switch to AddEnemy."""
return AddEnemy(builder, enemy)
def AddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
"""This method is deprecated. Please switch to AddTestnestedflatbuffer."""
return AddTestnestedflatbuffer(builder, testnestedflatbuffer)
def StartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartTestnestedflatbufferVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestnestedflatbufferVector(builder, numElems)
def MakeVectorFromBytes(builder, bytes):
def MonsterStart(builder): builder.StartObject(51)
def Start(builder):
return MonsterStart(builder)
def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
def AddPos(builder, pos):
return MonsterAddPos(builder, pos)
def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
def AddMana(builder, mana):
return MonsterAddMana(builder, mana)
def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
def AddHp(builder, hp):
return MonsterAddHp(builder, hp)
def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def AddName(builder, name):
return MonsterAddName(builder, name)
def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
def AddInventory(builder, inventory):
return MonsterAddInventory(builder, inventory)
def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartInventoryVector(builder, numElems):
return MonsterStartInventoryVector(builder, numElems)
def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
def AddColor(builder, color):
return MonsterAddColor(builder, color)
def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
def AddTestType(builder, testType):
return MonsterAddTestType(builder, testType)
def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
def AddTest(builder, test):
return MonsterAddTest(builder, test)
def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
def AddTest4(builder, test4):
return MonsterAddTest4(builder, test4)
def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
def StartTest4Vector(builder, numElems):
return MonsterStartTest4Vector(builder, numElems)
def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
def AddTestarrayofstring(builder, testarrayofstring):
return MonsterAddTestarrayofstring(builder, testarrayofstring)
def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartTestarrayofstringVector(builder, numElems):
return MonsterStartTestarrayofstringVector(builder, numElems)
def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
def AddTestarrayoftables(builder, testarrayoftables):
return MonsterAddTestarrayoftables(builder, testarrayoftables)
def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartTestarrayoftablesVector(builder, numElems):
return MonsterStartTestarrayoftablesVector(builder, numElems)
def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
def AddEnemy(builder, enemy):
return MonsterAddEnemy(builder, enemy)
def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartTestnestedflatbufferVector(builder, numElems):
return MonsterStartTestnestedflatbufferVector(builder, numElems)
def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector()
def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector()
def AddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
def MonsterAddTestempty(builder, testempty):
"""This method is deprecated. Please switch to AddTestempty."""
return AddTestempty(builder, testempty)
def AddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
def MonsterAddTestbool(builder, testbool):
"""This method is deprecated. Please switch to AddTestbool."""
return AddTestbool(builder, testbool)
def AddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
"""This method is deprecated. Please switch to AddTesthashs32Fnv1."""
return AddTesthashs32Fnv1(builder, testhashs32Fnv1)
def AddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
"""This method is deprecated. Please switch to AddTesthashu32Fnv1."""
return AddTesthashu32Fnv1(builder, testhashu32Fnv1)
def AddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
"""This method is deprecated. Please switch to AddTesthashs64Fnv1."""
return AddTesthashs64Fnv1(builder, testhashs64Fnv1)
def AddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
"""This method is deprecated. Please switch to AddTesthashu64Fnv1."""
return AddTesthashu64Fnv1(builder, testhashu64Fnv1)
def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
"""This method is deprecated. Please switch to AddTesthashs32Fnv1a."""
return AddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
"""This method is deprecated. Please switch to AddTesthashu32Fnv1a."""
return AddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
"""This method is deprecated. Please switch to AddTesthashs64Fnv1a."""
return AddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
"""This method is deprecated. Please switch to AddTesthashu64Fnv1a."""
return AddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
def AddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
def MonsterAddTestarrayofbools(builder, testarrayofbools):
"""This method is deprecated. Please switch to AddTestarrayofbools."""
return AddTestarrayofbools(builder, testarrayofbools)
def StartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartTestarrayofboolsVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestarrayofboolsVector(builder, numElems)
def AddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
def MonsterAddTestf(builder, testf):
"""This method is deprecated. Please switch to AddTestf."""
return AddTestf(builder, testf)
def AddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
def MonsterAddTestf2(builder, testf2):
"""This method is deprecated. Please switch to AddTestf2."""
return AddTestf2(builder, testf2)
def AddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
def MonsterAddTestf3(builder, testf3):
"""This method is deprecated. Please switch to AddTestf3."""
return AddTestf3(builder, testf3)
def AddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
"""This method is deprecated. Please switch to AddTestarrayofstring2."""
return AddTestarrayofstring2(builder, testarrayofstring2)
def StartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterStartTestarrayofstring2Vector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestarrayofstring2Vector(builder, numElems)
def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
"""This method is deprecated. Please switch to AddTestarrayofsortedstruct."""
return AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
def StartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
def MonsterStartTestarrayofsortedstructVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestarrayofsortedstructVector(builder, numElems)
def AddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
def MonsterAddFlex(builder, flex):
"""This method is deprecated. Please switch to AddFlex."""
return AddFlex(builder, flex)
def StartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartFlexVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartFlexVector(builder, numElems)
def AddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
def MonsterAddTest5(builder, test5):
"""This method is deprecated. Please switch to AddTest5."""
return AddTest5(builder, test5)
def StartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
def MonsterStartTest5Vector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTest5Vector(builder, numElems)
def AddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
def MonsterAddVectorOfLongs(builder, vectorOfLongs):
"""This method is deprecated. Please switch to AddVectorOfLongs."""
return AddVectorOfLongs(builder, vectorOfLongs)
def StartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterStartVectorOfLongsVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfLongsVector(builder, numElems)
def AddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
"""This method is deprecated. Please switch to AddVectorOfDoubles."""
return AddVectorOfDoubles(builder, vectorOfDoubles)
def StartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterStartVectorOfDoublesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfDoublesVector(builder, numElems)
def AddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
"""This method is deprecated. Please switch to AddParentNamespaceTest."""
return AddParentNamespaceTest(builder, parentNamespaceTest)
def AddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
"""This method is deprecated. Please switch to AddVectorOfReferrables."""
return AddVectorOfReferrables(builder, vectorOfReferrables)
def StartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterStartVectorOfReferrablesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfReferrablesVector(builder, numElems)
def AddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
def MonsterAddSingleWeakReference(builder, singleWeakReference):
"""This method is deprecated. Please switch to AddSingleWeakReference."""
return AddSingleWeakReference(builder, singleWeakReference)
def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
"""This method is deprecated. Please switch to AddVectorOfWeakReferences."""
return AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
def StartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfWeakReferencesVector(builder, numElems)
def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
"""This method is deprecated. Please switch to AddVectorOfStrongReferrables."""
return AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
def StartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfStrongReferrablesVector(builder, numElems)
def AddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
def MonsterAddCoOwningReference(builder, coOwningReference):
"""This method is deprecated. Please switch to AddCoOwningReference."""
return AddCoOwningReference(builder, coOwningReference)
def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
"""This method is deprecated. Please switch to AddVectorOfCoOwningReferences."""
return AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
def StartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfCoOwningReferencesVector(builder, numElems)
def AddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
def MonsterAddNonOwningReference(builder, nonOwningReference):
"""This method is deprecated. Please switch to AddNonOwningReference."""
return AddNonOwningReference(builder, nonOwningReference)
def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
"""This method is deprecated. Please switch to AddVectorOfNonOwningReferences."""
return AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
def StartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfNonOwningReferencesVector(builder, numElems)
def AddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
def MonsterAddAnyUniqueType(builder, anyUniqueType):
"""This method is deprecated. Please switch to AddAnyUniqueType."""
return AddAnyUniqueType(builder, anyUniqueType)
def AddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
def MonsterAddAnyUnique(builder, anyUnique):
"""This method is deprecated. Please switch to AddAnyUnique."""
return AddAnyUnique(builder, anyUnique)
def AddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
"""This method is deprecated. Please switch to AddAnyAmbiguousType."""
return AddAnyAmbiguousType(builder, anyAmbiguousType)
def AddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
"""This method is deprecated. Please switch to AddAnyAmbiguous."""
return AddAnyAmbiguous(builder, anyAmbiguous)
def AddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
def MonsterAddVectorOfEnums(builder, vectorOfEnums):
"""This method is deprecated. Please switch to AddVectorOfEnums."""
return AddVectorOfEnums(builder, vectorOfEnums)
def StartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartVectorOfEnumsVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfEnumsVector(builder, numElems)
def AddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
def MonsterAddSignedEnum(builder, signedEnum):
"""This method is deprecated. Please switch to AddSignedEnum."""
return AddSignedEnum(builder, signedEnum)
def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
"""This method is deprecated. Please switch to AddTestrequirednestedflatbuffer."""
return AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
def StartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestrequirednestedflatbufferVector(builder, numElems)
def MakeVectorFromBytes(builder, bytes):
return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes)
def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
def AddTestempty(builder, testempty):
return MonsterAddTestempty(builder, testempty)
def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
def AddTestbool(builder, testbool):
return MonsterAddTestbool(builder, testbool)
def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
def AddTestarrayofbools(builder, testarrayofbools):
return MonsterAddTestarrayofbools(builder, testarrayofbools)
def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartTestarrayofboolsVector(builder, numElems):
return MonsterStartTestarrayofboolsVector(builder, numElems)
def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
def AddTestf(builder, testf):
return MonsterAddTestf(builder, testf)
def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
def AddTestf2(builder, testf2):
return MonsterAddTestf2(builder, testf2)
def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
def AddTestf3(builder, testf3):
return MonsterAddTestf3(builder, testf3)
def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
def AddTestarrayofstring2(builder, testarrayofstring2):
return MonsterAddTestarrayofstring2(builder, testarrayofstring2)
def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartTestarrayofstring2Vector(builder, numElems):
return MonsterStartTestarrayofstring2Vector(builder, numElems)
def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
def StartTestarrayofsortedstructVector(builder, numElems):
return MonsterStartTestarrayofsortedstructVector(builder, numElems)
def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
def AddFlex(builder, flex):
return MonsterAddFlex(builder, flex)
def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartFlexVector(builder, numElems):
return MonsterStartFlexVector(builder, numElems)
def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
def AddTest5(builder, test5):
return MonsterAddTest5(builder, test5)
def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
def StartTest5Vector(builder, numElems):
return MonsterStartTest5Vector(builder, numElems)
def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
def AddVectorOfLongs(builder, vectorOfLongs):
return MonsterAddVectorOfLongs(builder, vectorOfLongs)
def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfLongsVector(builder, numElems):
return MonsterStartVectorOfLongsVector(builder, numElems)
def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
def AddVectorOfDoubles(builder, vectorOfDoubles):
return MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfDoublesVector(builder, numElems):
return MonsterStartVectorOfDoublesVector(builder, numElems)
def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
def AddParentNamespaceTest(builder, parentNamespaceTest):
return MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
def AddVectorOfReferrables(builder, vectorOfReferrables):
return MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartVectorOfReferrablesVector(builder, numElems):
return MonsterStartVectorOfReferrablesVector(builder, numElems)
def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
def AddSingleWeakReference(builder, singleWeakReference):
return MonsterAddSingleWeakReference(builder, singleWeakReference)
def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfWeakReferencesVector(builder, numElems):
return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartVectorOfStrongReferrablesVector(builder, numElems):
return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
def AddCoOwningReference(builder, coOwningReference):
return MonsterAddCoOwningReference(builder, coOwningReference)
def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfCoOwningReferencesVector(builder, numElems):
return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
def AddNonOwningReference(builder, nonOwningReference):
return MonsterAddNonOwningReference(builder, nonOwningReference)
def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfNonOwningReferencesVector(builder, numElems):
return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
def AddAnyUniqueType(builder, anyUniqueType):
return MonsterAddAnyUniqueType(builder, anyUniqueType)
def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
def AddAnyUnique(builder, anyUnique):
return MonsterAddAnyUnique(builder, anyUnique)
def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
def AddAnyAmbiguousType(builder, anyAmbiguousType):
return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
def AddAnyAmbiguous(builder, anyAmbiguous):
return MonsterAddAnyAmbiguous(builder, anyAmbiguous)
def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
def AddVectorOfEnums(builder, vectorOfEnums):
return MonsterAddVectorOfEnums(builder, vectorOfEnums)
def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartVectorOfEnumsVector(builder, numElems):
return MonsterStartVectorOfEnumsVector(builder, numElems)
def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
def AddSignedEnum(builder, signedEnum):
return MonsterAddSignedEnum(builder, signedEnum)
def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartTestrequirednestedflatbufferVector(builder, numElems):
return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector()
def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector()
def AddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
"""This method is deprecated. Please switch to AddScalarKeySortedTables."""
return AddScalarKeySortedTables(builder, scalarKeySortedTables)
def StartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterStartScalarKeySortedTablesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartScalarKeySortedTablesVector(builder, numElems)
def End(builder): return builder.EndObject()
def MonsterEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes)
def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
def AddScalarKeySortedTables(builder, scalarKeySortedTables):
return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartScalarKeySortedTablesVector(builder, numElems):
return MonsterStartScalarKeySortedTablesVector(builder, numElems)
def MonsterEnd(builder): return builder.EndObject()
def End(builder):
return MonsterEnd(builder)
import MyGame.Example.Ability
import MyGame.Example.Any
import MyGame.Example.AnyAmbiguousAliases
@@ -1370,14 +1292,14 @@ class MonsterT(object):
if np is not None and type(self.inventory) is np.ndarray:
inventory = builder.CreateNumpyVector(self.inventory)
else:
StartInventoryVector(builder, len(self.inventory))
MonsterStartInventoryVector(builder, len(self.inventory))
for i in reversed(range(len(self.inventory))):
builder.PrependUint8(self.inventory[i])
inventory = builder.EndVector()
if self.test is not None:
test = self.test.Pack(builder)
if self.test4 is not None:
StartTest4Vector(builder, len(self.test4))
MonsterStartTest4Vector(builder, len(self.test4))
for i in reversed(range(len(self.test4))):
self.test4[i].Pack(builder)
test4 = builder.EndVector()
@@ -1385,7 +1307,7 @@ class MonsterT(object):
testarrayofstringlist = []
for i in range(len(self.testarrayofstring)):
testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
StartTestarrayofstringVector(builder, len(self.testarrayofstring))
MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
for i in reversed(range(len(self.testarrayofstring))):
builder.PrependUOffsetTRelative(testarrayofstringlist[i])
testarrayofstring = builder.EndVector()
@@ -1393,7 +1315,7 @@ class MonsterT(object):
testarrayoftableslist = []
for i in range(len(self.testarrayoftables)):
testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
StartTestarrayoftablesVector(builder, len(self.testarrayoftables))
MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
for i in reversed(range(len(self.testarrayoftables))):
builder.PrependUOffsetTRelative(testarrayoftableslist[i])
testarrayoftables = builder.EndVector()
@@ -1403,7 +1325,7 @@ class MonsterT(object):
if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
else:
StartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
for i in reversed(range(len(self.testnestedflatbuffer))):
builder.PrependUint8(self.testnestedflatbuffer[i])
testnestedflatbuffer = builder.EndVector()
@@ -1413,7 +1335,7 @@ class MonsterT(object):
if np is not None and type(self.testarrayofbools) is np.ndarray:
testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
else:
StartTestarrayofboolsVector(builder, len(self.testarrayofbools))
MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
for i in reversed(range(len(self.testarrayofbools))):
builder.PrependBool(self.testarrayofbools[i])
testarrayofbools = builder.EndVector()
@@ -1421,12 +1343,12 @@ class MonsterT(object):
testarrayofstring2list = []
for i in range(len(self.testarrayofstring2)):
testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
StartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
for i in reversed(range(len(self.testarrayofstring2))):
builder.PrependUOffsetTRelative(testarrayofstring2list[i])
testarrayofstring2 = builder.EndVector()
if self.testarrayofsortedstruct is not None:
StartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
for i in reversed(range(len(self.testarrayofsortedstruct))):
self.testarrayofsortedstruct[i].Pack(builder)
testarrayofsortedstruct = builder.EndVector()
@@ -1434,12 +1356,12 @@ class MonsterT(object):
if np is not None and type(self.flex) is np.ndarray:
flex = builder.CreateNumpyVector(self.flex)
else:
StartFlexVector(builder, len(self.flex))
MonsterStartFlexVector(builder, len(self.flex))
for i in reversed(range(len(self.flex))):
builder.PrependUint8(self.flex[i])
flex = builder.EndVector()
if self.test5 is not None:
StartTest5Vector(builder, len(self.test5))
MonsterStartTest5Vector(builder, len(self.test5))
for i in reversed(range(len(self.test5))):
self.test5[i].Pack(builder)
test5 = builder.EndVector()
@@ -1447,7 +1369,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfLongs) is np.ndarray:
vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
else:
StartVectorOfLongsVector(builder, len(self.vectorOfLongs))
MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
for i in reversed(range(len(self.vectorOfLongs))):
builder.PrependInt64(self.vectorOfLongs[i])
vectorOfLongs = builder.EndVector()
@@ -1455,7 +1377,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfDoubles) is np.ndarray:
vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
else:
StartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
for i in reversed(range(len(self.vectorOfDoubles))):
builder.PrependFloat64(self.vectorOfDoubles[i])
vectorOfDoubles = builder.EndVector()
@@ -1465,7 +1387,7 @@ class MonsterT(object):
vectorOfReferrableslist = []
for i in range(len(self.vectorOfReferrables)):
vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
StartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
for i in reversed(range(len(self.vectorOfReferrables))):
builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
vectorOfReferrables = builder.EndVector()
@@ -1473,7 +1395,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
else:
StartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
for i in reversed(range(len(self.vectorOfWeakReferences))):
builder.PrependUint64(self.vectorOfWeakReferences[i])
vectorOfWeakReferences = builder.EndVector()
@@ -1481,7 +1403,7 @@ class MonsterT(object):
vectorOfStrongReferrableslist = []
for i in range(len(self.vectorOfStrongReferrables)):
vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
StartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
for i in reversed(range(len(self.vectorOfStrongReferrables))):
builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
vectorOfStrongReferrables = builder.EndVector()
@@ -1489,7 +1411,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
else:
StartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
for i in reversed(range(len(self.vectorOfCoOwningReferences))):
builder.PrependUint64(self.vectorOfCoOwningReferences[i])
vectorOfCoOwningReferences = builder.EndVector()
@@ -1497,7 +1419,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
else:
StartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
for i in reversed(range(len(self.vectorOfNonOwningReferences))):
builder.PrependUint64(self.vectorOfNonOwningReferences[i])
vectorOfNonOwningReferences = builder.EndVector()
@@ -1509,7 +1431,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfEnums) is np.ndarray:
vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
else:
StartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
for i in reversed(range(len(self.vectorOfEnums))):
builder.PrependUint8(self.vectorOfEnums[i])
vectorOfEnums = builder.EndVector()
@@ -1517,7 +1439,7 @@ class MonsterT(object):
if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
else:
StartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
for i in reversed(range(len(self.testrequirednestedflatbuffer))):
builder.PrependUint8(self.testrequirednestedflatbuffer[i])
testrequirednestedflatbuffer = builder.EndVector()
@@ -1525,89 +1447,89 @@ class MonsterT(object):
scalarKeySortedTableslist = []
for i in range(len(self.scalarKeySortedTables)):
scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
StartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
for i in reversed(range(len(self.scalarKeySortedTables))):
builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
scalarKeySortedTables = builder.EndVector()
Start(builder)
MonsterStart(builder)
if self.pos is not None:
pos = self.pos.Pack(builder)
AddPos(builder, pos)
AddMana(builder, self.mana)
AddHp(builder, self.hp)
MonsterAddPos(builder, pos)
MonsterAddMana(builder, self.mana)
MonsterAddHp(builder, self.hp)
if self.name is not None:
AddName(builder, name)
MonsterAddName(builder, name)
if self.inventory is not None:
AddInventory(builder, inventory)
AddColor(builder, self.color)
AddTestType(builder, self.testType)
MonsterAddInventory(builder, inventory)
MonsterAddColor(builder, self.color)
MonsterAddTestType(builder, self.testType)
if self.test is not None:
AddTest(builder, test)
MonsterAddTest(builder, test)
if self.test4 is not None:
AddTest4(builder, test4)
MonsterAddTest4(builder, test4)
if self.testarrayofstring is not None:
AddTestarrayofstring(builder, testarrayofstring)
MonsterAddTestarrayofstring(builder, testarrayofstring)
if self.testarrayoftables is not None:
AddTestarrayoftables(builder, testarrayoftables)
MonsterAddTestarrayoftables(builder, testarrayoftables)
if self.enemy is not None:
AddEnemy(builder, enemy)
MonsterAddEnemy(builder, enemy)
if self.testnestedflatbuffer is not None:
AddTestnestedflatbuffer(builder, testnestedflatbuffer)
MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
if self.testempty is not None:
AddTestempty(builder, testempty)
AddTestbool(builder, self.testbool)
AddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
AddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
AddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
AddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
AddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
AddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
AddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
AddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
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:
AddTestarrayofbools(builder, testarrayofbools)
AddTestf(builder, self.testf)
AddTestf2(builder, self.testf2)
AddTestf3(builder, self.testf3)
MonsterAddTestarrayofbools(builder, testarrayofbools)
MonsterAddTestf(builder, self.testf)
MonsterAddTestf2(builder, self.testf2)
MonsterAddTestf3(builder, self.testf3)
if self.testarrayofstring2 is not None:
AddTestarrayofstring2(builder, testarrayofstring2)
MonsterAddTestarrayofstring2(builder, testarrayofstring2)
if self.testarrayofsortedstruct is not None:
AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
if self.flex is not None:
AddFlex(builder, flex)
MonsterAddFlex(builder, flex)
if self.test5 is not None:
AddTest5(builder, test5)
MonsterAddTest5(builder, test5)
if self.vectorOfLongs is not None:
AddVectorOfLongs(builder, vectorOfLongs)
MonsterAddVectorOfLongs(builder, vectorOfLongs)
if self.vectorOfDoubles is not None:
AddVectorOfDoubles(builder, vectorOfDoubles)
MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
if self.parentNamespaceTest is not None:
AddParentNamespaceTest(builder, parentNamespaceTest)
MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
if self.vectorOfReferrables is not None:
AddVectorOfReferrables(builder, vectorOfReferrables)
AddSingleWeakReference(builder, self.singleWeakReference)
MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
MonsterAddSingleWeakReference(builder, self.singleWeakReference)
if self.vectorOfWeakReferences is not None:
AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
if self.vectorOfStrongReferrables is not None:
AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
AddCoOwningReference(builder, self.coOwningReference)
MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
MonsterAddCoOwningReference(builder, self.coOwningReference)
if self.vectorOfCoOwningReferences is not None:
AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
AddNonOwningReference(builder, self.nonOwningReference)
MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
MonsterAddNonOwningReference(builder, self.nonOwningReference)
if self.vectorOfNonOwningReferences is not None:
AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
AddAnyUniqueType(builder, self.anyUniqueType)
MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
MonsterAddAnyUniqueType(builder, self.anyUniqueType)
if self.anyUnique is not None:
AddAnyUnique(builder, anyUnique)
AddAnyAmbiguousType(builder, self.anyAmbiguousType)
MonsterAddAnyUnique(builder, anyUnique)
MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
if self.anyAmbiguous is not None:
AddAnyAmbiguous(builder, anyAmbiguous)
MonsterAddAnyAmbiguous(builder, anyAmbiguous)
if self.vectorOfEnums is not None:
AddVectorOfEnums(builder, vectorOfEnums)
AddSignedEnum(builder, self.signedEnum)
MonsterAddVectorOfEnums(builder, vectorOfEnums)
MonsterAddSignedEnum(builder, self.signedEnum)
if self.testrequirednestedflatbuffer is not None:
AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
if self.scalarKeySortedTables is not None:
AddScalarKeySortedTables(builder, scalarKeySortedTables)
monster = End(builder)
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
monster = MonsterEnd(builder)
return monster

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

@@ -35,18 +35,15 @@ class Referrable(object):
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def Start(builder): builder.StartObject(1)
def ReferrableStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddId(builder, id): builder.PrependUint64Slot(0, id, 0)
def ReferrableAddId(builder, id):
"""This method is deprecated. Please switch to AddId."""
return AddId(builder, id)
def End(builder): return builder.EndObject()
def ReferrableEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def ReferrableStart(builder): builder.StartObject(1)
def Start(builder):
return ReferrableStart(builder)
def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
def AddId(builder, id):
return ReferrableAddId(builder, id)
def ReferrableEnd(builder): return builder.EndObject()
def End(builder):
return ReferrableEnd(builder)
class ReferrableT(object):
@@ -74,7 +71,7 @@ class ReferrableT(object):
# ReferrableT
def Pack(self, builder):
Start(builder)
AddId(builder, self.id)
referrable = End(builder)
ReferrableStart(builder)
ReferrableAddId(builder, self.id)
referrable = ReferrableEnd(builder)
return referrable

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

@@ -49,26 +49,21 @@ class Stat(object):
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
return 0
def Start(builder): builder.StartObject(3)
def StatStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
def StatAddId(builder, id):
"""This method is deprecated. Please switch to AddId."""
return AddId(builder, id)
def AddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
def StatAddVal(builder, val):
"""This method is deprecated. Please switch to AddVal."""
return AddVal(builder, val)
def AddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
def StatAddCount(builder, count):
"""This method is deprecated. Please switch to AddCount."""
return AddCount(builder, count)
def End(builder): return builder.EndObject()
def StatEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def StatStart(builder): builder.StartObject(3)
def Start(builder):
return StatStart(builder)
def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
def AddId(builder, id):
return StatAddId(builder, id)
def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
def AddVal(builder, val):
return StatAddVal(builder, val)
def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
def AddCount(builder, count):
return StatAddCount(builder, count)
def StatEnd(builder): return builder.EndObject()
def End(builder):
return StatEnd(builder)
class StatT(object):
@@ -102,10 +97,10 @@ class StatT(object):
def Pack(self, builder):
if self.id is not None:
id = builder.CreateString(self.id)
Start(builder)
StatStart(builder)
if self.id is not None:
AddId(builder, id)
AddVal(builder, self.val)
AddCount(builder, self.count)
stat = End(builder)
StatAddId(builder, id)
StatAddVal(builder, self.val)
StatAddCount(builder, self.count)
stat = StatEnd(builder)
return stat

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

@@ -35,18 +35,15 @@ class TestSimpleTableWithEnum(object):
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 2
def Start(builder): builder.StartObject(1)
def TestSimpleTableWithEnumStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
def TestSimpleTableWithEnumAddColor(builder, color):
"""This method is deprecated. Please switch to AddColor."""
return AddColor(builder, color)
def End(builder): return builder.EndObject()
def TestSimpleTableWithEnumEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
def Start(builder):
return TestSimpleTableWithEnumStart(builder)
def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
def AddColor(builder, color):
return TestSimpleTableWithEnumAddColor(builder, color)
def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
def End(builder):
return TestSimpleTableWithEnumEnd(builder)
class TestSimpleTableWithEnumT(object):
@@ -74,7 +71,7 @@ class TestSimpleTableWithEnumT(object):
# TestSimpleTableWithEnumT
def Pack(self, builder):
Start(builder)
AddColor(builder, self.color)
testSimpleTableWithEnum = End(builder)
TestSimpleTableWithEnumStart(builder)
TestSimpleTableWithEnumAddColor(builder, self.color)
testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
return testSimpleTableWithEnum

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

@@ -152,70 +152,54 @@ class TypeAliases(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
return o == 0
def Start(builder): builder.StartObject(12)
def TypeAliasesStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
def TypeAliasesAddI8(builder, i8):
"""This method is deprecated. Please switch to AddI8."""
return AddI8(builder, i8)
def AddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
def TypeAliasesAddU8(builder, u8):
"""This method is deprecated. Please switch to AddU8."""
return AddU8(builder, u8)
def AddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
def TypeAliasesAddI16(builder, i16):
"""This method is deprecated. Please switch to AddI16."""
return AddI16(builder, i16)
def AddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
def TypeAliasesAddU16(builder, u16):
"""This method is deprecated. Please switch to AddU16."""
return AddU16(builder, u16)
def AddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
def TypeAliasesAddI32(builder, i32):
"""This method is deprecated. Please switch to AddI32."""
return AddI32(builder, i32)
def AddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
def TypeAliasesAddU32(builder, u32):
"""This method is deprecated. Please switch to AddU32."""
return AddU32(builder, u32)
def AddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
def TypeAliasesAddI64(builder, i64):
"""This method is deprecated. Please switch to AddI64."""
return AddI64(builder, i64)
def AddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
def TypeAliasesAddU64(builder, u64):
"""This method is deprecated. Please switch to AddU64."""
return AddU64(builder, u64)
def AddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
def TypeAliasesAddF32(builder, f32):
"""This method is deprecated. Please switch to AddF32."""
return AddF32(builder, f32)
def AddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
def TypeAliasesAddF64(builder, f64):
"""This method is deprecated. Please switch to AddF64."""
return AddF64(builder, f64)
def AddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
def TypeAliasesAddV8(builder, v8):
"""This method is deprecated. Please switch to AddV8."""
return AddV8(builder, v8)
def StartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
def TypeAliasesStartV8Vector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartV8Vector(builder, numElems)
def AddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
def TypeAliasesAddVf64(builder, vf64):
"""This method is deprecated. Please switch to AddVf64."""
return AddVf64(builder, vf64)
def StartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
def TypeAliasesStartVf64Vector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVf64Vector(builder, numElems)
def End(builder): return builder.EndObject()
def TypeAliasesEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def TypeAliasesStart(builder): builder.StartObject(12)
def Start(builder):
return TypeAliasesStart(builder)
def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
def AddI8(builder, i8):
return TypeAliasesAddI8(builder, i8)
def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
def AddU8(builder, u8):
return TypeAliasesAddU8(builder, u8)
def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
def AddI16(builder, i16):
return TypeAliasesAddI16(builder, i16)
def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
def AddU16(builder, u16):
return TypeAliasesAddU16(builder, u16)
def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
def AddI32(builder, i32):
return TypeAliasesAddI32(builder, i32)
def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
def AddU32(builder, u32):
return TypeAliasesAddU32(builder, u32)
def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
def AddI64(builder, i64):
return TypeAliasesAddI64(builder, i64)
def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
def AddU64(builder, u64):
return TypeAliasesAddU64(builder, u64)
def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
def AddF32(builder, f32):
return TypeAliasesAddF32(builder, f32)
def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
def AddF64(builder, f64):
return TypeAliasesAddF64(builder, f64)
def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
def AddV8(builder, v8):
return TypeAliasesAddV8(builder, v8)
def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartV8Vector(builder, numElems):
return TypeAliasesStartV8Vector(builder, numElems)
def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
def AddVf64(builder, vf64):
return TypeAliasesAddVf64(builder, vf64)
def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVf64Vector(builder, numElems):
return TypeAliasesStartVf64Vector(builder, numElems)
def TypeAliasesEnd(builder): return builder.EndObject()
def End(builder):
return TypeAliasesEnd(builder)
try:
from typing import List
except:
@@ -285,7 +269,7 @@ class TypeAliasesT(object):
if np is not None and type(self.v8) is np.ndarray:
v8 = builder.CreateNumpyVector(self.v8)
else:
StartV8Vector(builder, len(self.v8))
TypeAliasesStartV8Vector(builder, len(self.v8))
for i in reversed(range(len(self.v8))):
builder.PrependByte(self.v8[i])
v8 = builder.EndVector()
@@ -293,24 +277,24 @@ class TypeAliasesT(object):
if np is not None and type(self.vf64) is np.ndarray:
vf64 = builder.CreateNumpyVector(self.vf64)
else:
StartVf64Vector(builder, len(self.vf64))
TypeAliasesStartVf64Vector(builder, len(self.vf64))
for i in reversed(range(len(self.vf64))):
builder.PrependFloat64(self.vf64[i])
vf64 = builder.EndVector()
Start(builder)
AddI8(builder, self.i8)
AddU8(builder, self.u8)
AddI16(builder, self.i16)
AddU16(builder, self.u16)
AddI32(builder, self.i32)
AddU32(builder, self.u32)
AddI64(builder, self.i64)
AddU64(builder, self.u64)
AddF32(builder, self.f32)
AddF64(builder, self.f64)
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:
AddV8(builder, v8)
TypeAliasesAddV8(builder, v8)
if self.vf64 is not None:
AddVf64(builder, vf64)
typeAliases = End(builder)
TypeAliasesAddVf64(builder, vf64)
typeAliases = TypeAliasesEnd(builder)
return typeAliases