mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-02 20:15:34 +00:00
413115858c
* feat: Added support for fixed sized arrays to python Problem: We encountered that using fixed arrays from C++ to python that python would not read those arrays correctly due to no size information being encoded in the byte array itself. Fix: Encode the sizes within the generated python file during code generation. Specfically we add GetArrayAsNumpy to the python version of table, which takes as input the length of the vector. When generating the python message files we include this length from the VectorType().fixed_length. * fix: added digit support for camel case to snake case conversion Problem: When including a number in the message name we would encounter cases where SnakeCase would not add the appropirate breaks. e.g. Int32Stamped -> int_32stamped rather than int_32_stamped. Fix: To fix this we can add the condition that we check if the current character is not lower and not a digit, that we check if the previous character was a lower or digit. If it was a lower or digit then we add the break. * fix: Array support for structures Problem: The python generated code for handling non-struct and struct vectors and arrays was inconsistent. The calls to populate the obj api was creating incorrect code. Solution: To fix this the VectorOfStruct and VectorOfNonStruct was rewritten to handle array cases and bring the two methods in line which each other. Testing: PythonTesting.sh now correctly runs and generates the code for array_test.fbs. Minor modifications were done on the test to use the new index accessor for struct arrays and the script correctly sources the location of the python code. * chore: clang format changes * Added code generated by scripts/generate_code. Modified GetArrayOfNonStruct slightly to allow for function overloading allowing the user to get a single element of an array or the whole array. * Added new_line parameter to OffsetPrefix to allow optional new lines to be added. This allows us to use the GenIndents method that automatically adds new lines instead. * Reupload of generated code from the scripts/generate_code.py * Removed new line in GetVectorAsNumpy. * Updated Array lengths to use Length methods where possible. Added fallthrough for GenTypePointer. Added digit check to CamelToSnake method. Added and modified tests for ToSnakeCase and CamelToSnake. * Added range check on the getter methods for vector and array types. Renamed == as is for python
1583 lines
74 KiB
Python
1583 lines
74 KiB
Python
# automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
# namespace: Example
|
|
|
|
import flatbuffers
|
|
from flatbuffers.compat import import_numpy
|
|
np = import_numpy()
|
|
|
|
# an example documentation comment: "monster object"
|
|
class Monster(object):
|
|
__slots__ = ['_tab']
|
|
|
|
@classmethod
|
|
def GetRootAs(cls, buf, offset=0):
|
|
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
|
|
x = Monster()
|
|
x.Init(buf, n + offset)
|
|
return x
|
|
|
|
@classmethod
|
|
def GetRootAsMonster(cls, buf, offset=0):
|
|
"""This method is deprecated. Please switch to GetRootAs."""
|
|
return cls.GetRootAs(buf, offset)
|
|
@classmethod
|
|
def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
|
|
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
|
|
|
|
# Monster
|
|
def Init(self, buf, pos):
|
|
self._tab = flatbuffers.table.Table(buf, pos)
|
|
|
|
# Monster
|
|
def Pos(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
|
|
if o != 0:
|
|
x = o + self._tab.Pos
|
|
from MyGame.Example.Vec3 import Vec3
|
|
obj = Vec3()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Mana(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 150
|
|
|
|
# Monster
|
|
def Hp(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 100
|
|
|
|
# Monster
|
|
def Name(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
|
|
if o != 0:
|
|
return self._tab.String(o + self._tab.Pos)
|
|
return None
|
|
|
|
# Monster
|
|
def Inventory(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
|
|
return 0
|
|
|
|
# Monster
|
|
def InventoryAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def InventoryLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 8
|
|
|
|
# Monster
|
|
def TestType(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Test(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
|
|
if o != 0:
|
|
from flatbuffers.table import Table
|
|
obj = Table(bytearray(), 0)
|
|
self._tab.Union(obj, o)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Test4(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
from MyGame.Example.Test import Test
|
|
obj = Test()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Test4Length(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
|
|
return ""
|
|
|
|
# Monster
|
|
def TestarrayofstringLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
|
|
if o != 0:
|
|
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
|
|
def Testarrayoftables(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Monster import Monster
|
|
obj = Monster()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def TestarrayoftablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
|
if o != 0:
|
|
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 MyGame.Example.Monster import Monster
|
|
obj = Monster()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Testnestedflatbuffer(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestnestedflatbufferAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestnestedflatbufferNestedRoot(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
from MyGame.Example.Monster import Monster
|
|
return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestnestedflatbufferLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
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 MyGame.Example.Stat import Stat
|
|
obj = Stat()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Testbool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return False
|
|
|
|
# Monster
|
|
def Testhashs32Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu32Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashs64Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu64Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashs32Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu32Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashs64Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu64Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testarrayofbools(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayofboolsAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayofboolsLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 3.14159
|
|
|
|
# Monster
|
|
def Testf2(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 3.0
|
|
|
|
# Monster
|
|
def Testf3(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 0.0
|
|
|
|
# Monster
|
|
def Testarrayofstring2(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
|
|
return ""
|
|
|
|
# Monster
|
|
def Testarrayofstring2Length(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
|
if o != 0:
|
|
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 MyGame.Example.Ability import Ability
|
|
obj = Ability()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def TestarrayofsortedstructLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
|
|
return 0
|
|
|
|
# Monster
|
|
def FlexAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def FlexLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
if o != 0:
|
|
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 MyGame.Example.Test import Test
|
|
obj = Test()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Test5Length(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfLongsAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfLongsLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfDoublesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfDoublesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
if o != 0:
|
|
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 MyGame.InParentNamespace import InParentNamespace
|
|
obj = InParentNamespace()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfReferrables(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Referrable import Referrable
|
|
obj = Referrable()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfReferrablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfWeakReferences(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfWeakReferencesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfWeakReferencesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Referrable import Referrable
|
|
obj = Referrable()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfStrongReferrablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfCoOwningReferences(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfCoOwningReferencesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfCoOwningReferencesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfNonOwningReferences(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfNonOwningReferencesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfNonOwningReferencesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def AnyUnique(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
|
|
if o != 0:
|
|
from flatbuffers.table import Table
|
|
obj = Table(bytearray(), 0)
|
|
self._tab.Union(obj, o)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def AnyAmbiguousType(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def AnyAmbiguous(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
|
|
if o != 0:
|
|
from flatbuffers.table import Table
|
|
obj = Table(bytearray(), 0)
|
|
self._tab.Union(obj, o)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfEnums(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfEnumsAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfEnumsLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
|
|
if o != 0:
|
|
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))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return -1
|
|
|
|
# Monster
|
|
def Testrequirednestedflatbuffer(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferNestedRoot(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
if o != 0:
|
|
from MyGame.Example.Monster import Monster
|
|
return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def ScalarKeySortedTables(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Stat import Stat
|
|
obj = Stat()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def ScalarKeySortedTablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def ScalarKeySortedTablesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def NativeInline(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
|
|
if o != 0:
|
|
x = o + self._tab.Pos
|
|
from MyGame.Example.Test import Test
|
|
obj = Test()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def LongEnumNonEnumDefault(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def LongEnumNormalDefault(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 2
|
|
|
|
def MonsterStart(builder): builder.StartObject(54)
|
|
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):
|
|
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):
|
|
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 MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
|
|
def AddNativeInline(builder, nativeInline):
|
|
return MonsterAddNativeInline(builder, nativeInline)
|
|
def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
|
|
def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
|
|
return MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
|
|
def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
|
|
def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
|
|
return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
|
|
def MonsterEnd(builder): return builder.EndObject()
|
|
def End(builder):
|
|
return MonsterEnd(builder)
|
|
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
|
|
self.testrequirednestedflatbuffer = None # type: List[int]
|
|
self.scalarKeySortedTables = None # type: List[MyGame.Example.Stat.StatT]
|
|
self.nativeInline = None # type: Optional[MyGame.Example.Test.TestT]
|
|
self.longEnumNonEnumDefault = 0 # type: int
|
|
self.longEnumNormalDefault = 2 # type: int
|
|
|
|
@classmethod
|
|
def InitFromBuf(cls, buf, pos):
|
|
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
|
|
monster = Monster()
|
|
monster.Init(buf, pos+n)
|
|
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()
|
|
if not monster.TestrequirednestedflatbufferIsNone():
|
|
if np is None:
|
|
self.testrequirednestedflatbuffer = []
|
|
for i in range(monster.TestrequirednestedflatbufferLength()):
|
|
self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
|
|
else:
|
|
self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
|
|
if not monster.ScalarKeySortedTablesIsNone():
|
|
self.scalarKeySortedTables = []
|
|
for i in range(monster.ScalarKeySortedTablesLength()):
|
|
if monster.ScalarKeySortedTables(i) is None:
|
|
self.scalarKeySortedTables.append(None)
|
|
else:
|
|
stat_ = MyGame.Example.Stat.StatT.InitFromObj(monster.ScalarKeySortedTables(i))
|
|
self.scalarKeySortedTables.append(stat_)
|
|
if monster.NativeInline() is not None:
|
|
self.nativeInline = MyGame.Example.Test.TestT.InitFromObj(monster.NativeInline())
|
|
self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
|
|
self.longEnumNormalDefault = monster.LongEnumNormalDefault()
|
|
|
|
# MonsterT
|
|
def Pack(self, builder):
|
|
if self.name is not None:
|
|
name = builder.CreateString(self.name)
|
|
if self.inventory is not None:
|
|
if np is not None and type(self.inventory) is np.ndarray:
|
|
inventory = builder.CreateNumpyVector(self.inventory)
|
|
else:
|
|
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:
|
|
MonsterStartTest4Vector(builder, len(self.test4))
|
|
for i in reversed(range(len(self.test4))):
|
|
self.test4[i].Pack(builder)
|
|
test4 = builder.EndVector()
|
|
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()
|
|
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()
|
|
if self.enemy is not None:
|
|
enemy = self.enemy.Pack(builder)
|
|
if self.testnestedflatbuffer is not None:
|
|
if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
|
|
testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
|
|
else:
|
|
MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
|
|
for i in reversed(range(len(self.testnestedflatbuffer))):
|
|
builder.PrependUint8(self.testnestedflatbuffer[i])
|
|
testnestedflatbuffer = builder.EndVector()
|
|
if self.testempty is not None:
|
|
testempty = self.testempty.Pack(builder)
|
|
if self.testarrayofbools is not None:
|
|
if np is not None and type(self.testarrayofbools) is np.ndarray:
|
|
testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
|
|
else:
|
|
MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
|
|
for i in reversed(range(len(self.testarrayofbools))):
|
|
builder.PrependBool(self.testarrayofbools[i])
|
|
testarrayofbools = builder.EndVector()
|
|
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()
|
|
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()
|
|
if self.flex is not None:
|
|
if np is not None and type(self.flex) is np.ndarray:
|
|
flex = builder.CreateNumpyVector(self.flex)
|
|
else:
|
|
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:
|
|
MonsterStartTest5Vector(builder, len(self.test5))
|
|
for i in reversed(range(len(self.test5))):
|
|
self.test5[i].Pack(builder)
|
|
test5 = builder.EndVector()
|
|
if self.vectorOfLongs is not None:
|
|
if np is not None and type(self.vectorOfLongs) is np.ndarray:
|
|
vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
|
|
else:
|
|
MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
|
|
for i in reversed(range(len(self.vectorOfLongs))):
|
|
builder.PrependInt64(self.vectorOfLongs[i])
|
|
vectorOfLongs = builder.EndVector()
|
|
if self.vectorOfDoubles is not None:
|
|
if np is not None and type(self.vectorOfDoubles) is np.ndarray:
|
|
vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
|
|
else:
|
|
MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
|
|
for i in reversed(range(len(self.vectorOfDoubles))):
|
|
builder.PrependFloat64(self.vectorOfDoubles[i])
|
|
vectorOfDoubles = builder.EndVector()
|
|
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()
|
|
if self.vectorOfWeakReferences is not None:
|
|
if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
|
|
vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
|
|
else:
|
|
MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
|
|
for i in reversed(range(len(self.vectorOfWeakReferences))):
|
|
builder.PrependUint64(self.vectorOfWeakReferences[i])
|
|
vectorOfWeakReferences = builder.EndVector()
|
|
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()
|
|
if self.vectorOfCoOwningReferences is not None:
|
|
if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
|
|
vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
|
|
else:
|
|
MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
|
|
for i in reversed(range(len(self.vectorOfCoOwningReferences))):
|
|
builder.PrependUint64(self.vectorOfCoOwningReferences[i])
|
|
vectorOfCoOwningReferences = builder.EndVector()
|
|
if self.vectorOfNonOwningReferences is not None:
|
|
if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
|
|
vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
|
|
else:
|
|
MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
|
|
for i in reversed(range(len(self.vectorOfNonOwningReferences))):
|
|
builder.PrependUint64(self.vectorOfNonOwningReferences[i])
|
|
vectorOfNonOwningReferences = builder.EndVector()
|
|
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:
|
|
if np is not None and type(self.vectorOfEnums) is np.ndarray:
|
|
vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
|
|
else:
|
|
MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
|
|
for i in reversed(range(len(self.vectorOfEnums))):
|
|
builder.PrependUint8(self.vectorOfEnums[i])
|
|
vectorOfEnums = builder.EndVector()
|
|
if self.testrequirednestedflatbuffer is not None:
|
|
if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
|
|
testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
|
|
else:
|
|
MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
|
|
for i in reversed(range(len(self.testrequirednestedflatbuffer))):
|
|
builder.PrependUint8(self.testrequirednestedflatbuffer[i])
|
|
testrequirednestedflatbuffer = builder.EndVector()
|
|
if self.scalarKeySortedTables is not None:
|
|
scalarKeySortedTableslist = []
|
|
for i in range(len(self.scalarKeySortedTables)):
|
|
scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
|
|
MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
|
|
for i in reversed(range(len(self.scalarKeySortedTables))):
|
|
builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
|
|
scalarKeySortedTables = builder.EndVector()
|
|
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)
|
|
if self.testrequirednestedflatbuffer is not None:
|
|
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
|
|
if self.scalarKeySortedTables is not None:
|
|
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
|
|
if self.nativeInline is not None:
|
|
nativeInline = self.nativeInline.Pack(builder)
|
|
MonsterAddNativeInline(builder, nativeInline)
|
|
MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
|
|
MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
|
|
monster = MonsterEnd(builder)
|
|
return monster
|