mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-08 22:20:56 +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
534 lines
22 KiB
Python
534 lines
22 KiB
Python
# automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
# namespace: optional_scalars
|
|
|
|
import flatbuffers
|
|
from flatbuffers.compat import import_numpy
|
|
np = import_numpy()
|
|
|
|
class ScalarStuff(object):
|
|
__slots__ = ['_tab']
|
|
|
|
@classmethod
|
|
def GetRootAs(cls, buf, offset=0):
|
|
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
|
|
x = ScalarStuff()
|
|
x.Init(buf, n + offset)
|
|
return x
|
|
|
|
@classmethod
|
|
def GetRootAsScalarStuff(cls, buf, offset=0):
|
|
"""This method is deprecated. Please switch to GetRootAs."""
|
|
return cls.GetRootAs(buf, offset)
|
|
@classmethod
|
|
def ScalarStuffBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
|
|
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4E\x55\x4C\x4C", size_prefixed=size_prefixed)
|
|
|
|
# ScalarStuff
|
|
def Init(self, buf, pos):
|
|
self._tab = flatbuffers.table.Table(buf, pos)
|
|
|
|
# ScalarStuff
|
|
def JustI8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeI8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustI16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeI16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustI32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeI32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU32(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 42
|
|
|
|
# ScalarStuff
|
|
def JustI64(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
|
|
|
|
# ScalarStuff
|
|
def MaybeI64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU64(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 42
|
|
|
|
# ScalarStuff
|
|
def JustF32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 0.0
|
|
|
|
# ScalarStuff
|
|
def MaybeF32(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 None
|
|
|
|
# ScalarStuff
|
|
def DefaultF32(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 42.0
|
|
|
|
# ScalarStuff
|
|
def JustF64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
|
return 0.0
|
|
|
|
# ScalarStuff
|
|
def MaybeF64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultF64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
|
return 42.0
|
|
|
|
# ScalarStuff
|
|
def JustBool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return False
|
|
|
|
# ScalarStuff
|
|
def MaybeBool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultBool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return True
|
|
|
|
# ScalarStuff
|
|
def JustEnum(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeEnum(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultEnum(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return 1
|
|
|
|
def ScalarStuffStart(builder): builder.StartObject(36)
|
|
def Start(builder):
|
|
return ScalarStuffStart(builder)
|
|
def ScalarStuffAddJustI8(builder, justI8): builder.PrependInt8Slot(0, justI8, 0)
|
|
def AddJustI8(builder, justI8):
|
|
return ScalarStuffAddJustI8(builder, justI8)
|
|
def ScalarStuffAddMaybeI8(builder, maybeI8): builder.PrependInt8Slot(1, maybeI8, None)
|
|
def AddMaybeI8(builder, maybeI8):
|
|
return ScalarStuffAddMaybeI8(builder, maybeI8)
|
|
def ScalarStuffAddDefaultI8(builder, defaultI8): builder.PrependInt8Slot(2, defaultI8, 42)
|
|
def AddDefaultI8(builder, defaultI8):
|
|
return ScalarStuffAddDefaultI8(builder, defaultI8)
|
|
def ScalarStuffAddJustU8(builder, justU8): builder.PrependUint8Slot(3, justU8, 0)
|
|
def AddJustU8(builder, justU8):
|
|
return ScalarStuffAddJustU8(builder, justU8)
|
|
def ScalarStuffAddMaybeU8(builder, maybeU8): builder.PrependUint8Slot(4, maybeU8, None)
|
|
def AddMaybeU8(builder, maybeU8):
|
|
return ScalarStuffAddMaybeU8(builder, maybeU8)
|
|
def ScalarStuffAddDefaultU8(builder, defaultU8): builder.PrependUint8Slot(5, defaultU8, 42)
|
|
def AddDefaultU8(builder, defaultU8):
|
|
return ScalarStuffAddDefaultU8(builder, defaultU8)
|
|
def ScalarStuffAddJustI16(builder, justI16): builder.PrependInt16Slot(6, justI16, 0)
|
|
def AddJustI16(builder, justI16):
|
|
return ScalarStuffAddJustI16(builder, justI16)
|
|
def ScalarStuffAddMaybeI16(builder, maybeI16): builder.PrependInt16Slot(7, maybeI16, None)
|
|
def AddMaybeI16(builder, maybeI16):
|
|
return ScalarStuffAddMaybeI16(builder, maybeI16)
|
|
def ScalarStuffAddDefaultI16(builder, defaultI16): builder.PrependInt16Slot(8, defaultI16, 42)
|
|
def AddDefaultI16(builder, defaultI16):
|
|
return ScalarStuffAddDefaultI16(builder, defaultI16)
|
|
def ScalarStuffAddJustU16(builder, justU16): builder.PrependUint16Slot(9, justU16, 0)
|
|
def AddJustU16(builder, justU16):
|
|
return ScalarStuffAddJustU16(builder, justU16)
|
|
def ScalarStuffAddMaybeU16(builder, maybeU16): builder.PrependUint16Slot(10, maybeU16, None)
|
|
def AddMaybeU16(builder, maybeU16):
|
|
return ScalarStuffAddMaybeU16(builder, maybeU16)
|
|
def ScalarStuffAddDefaultU16(builder, defaultU16): builder.PrependUint16Slot(11, defaultU16, 42)
|
|
def AddDefaultU16(builder, defaultU16):
|
|
return ScalarStuffAddDefaultU16(builder, defaultU16)
|
|
def ScalarStuffAddJustI32(builder, justI32): builder.PrependInt32Slot(12, justI32, 0)
|
|
def AddJustI32(builder, justI32):
|
|
return ScalarStuffAddJustI32(builder, justI32)
|
|
def ScalarStuffAddMaybeI32(builder, maybeI32): builder.PrependInt32Slot(13, maybeI32, None)
|
|
def AddMaybeI32(builder, maybeI32):
|
|
return ScalarStuffAddMaybeI32(builder, maybeI32)
|
|
def ScalarStuffAddDefaultI32(builder, defaultI32): builder.PrependInt32Slot(14, defaultI32, 42)
|
|
def AddDefaultI32(builder, defaultI32):
|
|
return ScalarStuffAddDefaultI32(builder, defaultI32)
|
|
def ScalarStuffAddJustU32(builder, justU32): builder.PrependUint32Slot(15, justU32, 0)
|
|
def AddJustU32(builder, justU32):
|
|
return ScalarStuffAddJustU32(builder, justU32)
|
|
def ScalarStuffAddMaybeU32(builder, maybeU32): builder.PrependUint32Slot(16, maybeU32, None)
|
|
def AddMaybeU32(builder, maybeU32):
|
|
return ScalarStuffAddMaybeU32(builder, maybeU32)
|
|
def ScalarStuffAddDefaultU32(builder, defaultU32): builder.PrependUint32Slot(17, defaultU32, 42)
|
|
def AddDefaultU32(builder, defaultU32):
|
|
return ScalarStuffAddDefaultU32(builder, defaultU32)
|
|
def ScalarStuffAddJustI64(builder, justI64): builder.PrependInt64Slot(18, justI64, 0)
|
|
def AddJustI64(builder, justI64):
|
|
return ScalarStuffAddJustI64(builder, justI64)
|
|
def ScalarStuffAddMaybeI64(builder, maybeI64): builder.PrependInt64Slot(19, maybeI64, None)
|
|
def AddMaybeI64(builder, maybeI64):
|
|
return ScalarStuffAddMaybeI64(builder, maybeI64)
|
|
def ScalarStuffAddDefaultI64(builder, defaultI64): builder.PrependInt64Slot(20, defaultI64, 42)
|
|
def AddDefaultI64(builder, defaultI64):
|
|
return ScalarStuffAddDefaultI64(builder, defaultI64)
|
|
def ScalarStuffAddJustU64(builder, justU64): builder.PrependUint64Slot(21, justU64, 0)
|
|
def AddJustU64(builder, justU64):
|
|
return ScalarStuffAddJustU64(builder, justU64)
|
|
def ScalarStuffAddMaybeU64(builder, maybeU64): builder.PrependUint64Slot(22, maybeU64, None)
|
|
def AddMaybeU64(builder, maybeU64):
|
|
return ScalarStuffAddMaybeU64(builder, maybeU64)
|
|
def ScalarStuffAddDefaultU64(builder, defaultU64): builder.PrependUint64Slot(23, defaultU64, 42)
|
|
def AddDefaultU64(builder, defaultU64):
|
|
return ScalarStuffAddDefaultU64(builder, defaultU64)
|
|
def ScalarStuffAddJustF32(builder, justF32): builder.PrependFloat32Slot(24, justF32, 0.0)
|
|
def AddJustF32(builder, justF32):
|
|
return ScalarStuffAddJustF32(builder, justF32)
|
|
def ScalarStuffAddMaybeF32(builder, maybeF32): builder.PrependFloat32Slot(25, maybeF32, None)
|
|
def AddMaybeF32(builder, maybeF32):
|
|
return ScalarStuffAddMaybeF32(builder, maybeF32)
|
|
def ScalarStuffAddDefaultF32(builder, defaultF32): builder.PrependFloat32Slot(26, defaultF32, 42.0)
|
|
def AddDefaultF32(builder, defaultF32):
|
|
return ScalarStuffAddDefaultF32(builder, defaultF32)
|
|
def ScalarStuffAddJustF64(builder, justF64): builder.PrependFloat64Slot(27, justF64, 0.0)
|
|
def AddJustF64(builder, justF64):
|
|
return ScalarStuffAddJustF64(builder, justF64)
|
|
def ScalarStuffAddMaybeF64(builder, maybeF64): builder.PrependFloat64Slot(28, maybeF64, None)
|
|
def AddMaybeF64(builder, maybeF64):
|
|
return ScalarStuffAddMaybeF64(builder, maybeF64)
|
|
def ScalarStuffAddDefaultF64(builder, defaultF64): builder.PrependFloat64Slot(29, defaultF64, 42.0)
|
|
def AddDefaultF64(builder, defaultF64):
|
|
return ScalarStuffAddDefaultF64(builder, defaultF64)
|
|
def ScalarStuffAddJustBool(builder, justBool): builder.PrependBoolSlot(30, justBool, 0)
|
|
def AddJustBool(builder, justBool):
|
|
return ScalarStuffAddJustBool(builder, justBool)
|
|
def ScalarStuffAddMaybeBool(builder, maybeBool): builder.PrependBoolSlot(31, maybeBool, None)
|
|
def AddMaybeBool(builder, maybeBool):
|
|
return ScalarStuffAddMaybeBool(builder, maybeBool)
|
|
def ScalarStuffAddDefaultBool(builder, defaultBool): builder.PrependBoolSlot(32, defaultBool, 1)
|
|
def AddDefaultBool(builder, defaultBool):
|
|
return ScalarStuffAddDefaultBool(builder, defaultBool)
|
|
def ScalarStuffAddJustEnum(builder, justEnum): builder.PrependInt8Slot(33, justEnum, 0)
|
|
def AddJustEnum(builder, justEnum):
|
|
return ScalarStuffAddJustEnum(builder, justEnum)
|
|
def ScalarStuffAddMaybeEnum(builder, maybeEnum): builder.PrependInt8Slot(34, maybeEnum, None)
|
|
def AddMaybeEnum(builder, maybeEnum):
|
|
return ScalarStuffAddMaybeEnum(builder, maybeEnum)
|
|
def ScalarStuffAddDefaultEnum(builder, defaultEnum): builder.PrependInt8Slot(35, defaultEnum, 1)
|
|
def AddDefaultEnum(builder, defaultEnum):
|
|
return ScalarStuffAddDefaultEnum(builder, defaultEnum)
|
|
def ScalarStuffEnd(builder): return builder.EndObject()
|
|
def End(builder):
|
|
return ScalarStuffEnd(builder)
|
|
|
|
class ScalarStuffT(object):
|
|
|
|
# ScalarStuffT
|
|
def __init__(self):
|
|
self.justI8 = 0 # type: int
|
|
self.maybeI8 = None # type: Optional[int]
|
|
self.defaultI8 = 42 # type: int
|
|
self.justU8 = 0 # type: int
|
|
self.maybeU8 = None # type: Optional[int]
|
|
self.defaultU8 = 42 # type: int
|
|
self.justI16 = 0 # type: int
|
|
self.maybeI16 = None # type: Optional[int]
|
|
self.defaultI16 = 42 # type: int
|
|
self.justU16 = 0 # type: int
|
|
self.maybeU16 = None # type: Optional[int]
|
|
self.defaultU16 = 42 # type: int
|
|
self.justI32 = 0 # type: int
|
|
self.maybeI32 = None # type: Optional[int]
|
|
self.defaultI32 = 42 # type: int
|
|
self.justU32 = 0 # type: int
|
|
self.maybeU32 = None # type: Optional[int]
|
|
self.defaultU32 = 42 # type: int
|
|
self.justI64 = 0 # type: int
|
|
self.maybeI64 = None # type: Optional[int]
|
|
self.defaultI64 = 42 # type: int
|
|
self.justU64 = 0 # type: int
|
|
self.maybeU64 = None # type: Optional[int]
|
|
self.defaultU64 = 42 # type: int
|
|
self.justF32 = 0.0 # type: float
|
|
self.maybeF32 = None # type: Optional[float]
|
|
self.defaultF32 = 42.0 # type: float
|
|
self.justF64 = 0.0 # type: float
|
|
self.maybeF64 = None # type: Optional[float]
|
|
self.defaultF64 = 42.0 # type: float
|
|
self.justBool = False # type: bool
|
|
self.maybeBool = None # type: Optional[bool]
|
|
self.defaultBool = True # type: bool
|
|
self.justEnum = 0 # type: int
|
|
self.maybeEnum = None # type: Optional[int]
|
|
self.defaultEnum = 1 # type: int
|
|
|
|
@classmethod
|
|
def InitFromBuf(cls, buf, pos):
|
|
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
|
|
scalarStuff = ScalarStuff()
|
|
scalarStuff.Init(buf, pos+n)
|
|
return cls.InitFromObj(scalarStuff)
|
|
|
|
@classmethod
|
|
def InitFromObj(cls, scalarStuff):
|
|
x = ScalarStuffT()
|
|
x._UnPack(scalarStuff)
|
|
return x
|
|
|
|
# ScalarStuffT
|
|
def _UnPack(self, scalarStuff):
|
|
if scalarStuff is None:
|
|
return
|
|
self.justI8 = scalarStuff.JustI8()
|
|
self.maybeI8 = scalarStuff.MaybeI8()
|
|
self.defaultI8 = scalarStuff.DefaultI8()
|
|
self.justU8 = scalarStuff.JustU8()
|
|
self.maybeU8 = scalarStuff.MaybeU8()
|
|
self.defaultU8 = scalarStuff.DefaultU8()
|
|
self.justI16 = scalarStuff.JustI16()
|
|
self.maybeI16 = scalarStuff.MaybeI16()
|
|
self.defaultI16 = scalarStuff.DefaultI16()
|
|
self.justU16 = scalarStuff.JustU16()
|
|
self.maybeU16 = scalarStuff.MaybeU16()
|
|
self.defaultU16 = scalarStuff.DefaultU16()
|
|
self.justI32 = scalarStuff.JustI32()
|
|
self.maybeI32 = scalarStuff.MaybeI32()
|
|
self.defaultI32 = scalarStuff.DefaultI32()
|
|
self.justU32 = scalarStuff.JustU32()
|
|
self.maybeU32 = scalarStuff.MaybeU32()
|
|
self.defaultU32 = scalarStuff.DefaultU32()
|
|
self.justI64 = scalarStuff.JustI64()
|
|
self.maybeI64 = scalarStuff.MaybeI64()
|
|
self.defaultI64 = scalarStuff.DefaultI64()
|
|
self.justU64 = scalarStuff.JustU64()
|
|
self.maybeU64 = scalarStuff.MaybeU64()
|
|
self.defaultU64 = scalarStuff.DefaultU64()
|
|
self.justF32 = scalarStuff.JustF32()
|
|
self.maybeF32 = scalarStuff.MaybeF32()
|
|
self.defaultF32 = scalarStuff.DefaultF32()
|
|
self.justF64 = scalarStuff.JustF64()
|
|
self.maybeF64 = scalarStuff.MaybeF64()
|
|
self.defaultF64 = scalarStuff.DefaultF64()
|
|
self.justBool = scalarStuff.JustBool()
|
|
self.maybeBool = scalarStuff.MaybeBool()
|
|
self.defaultBool = scalarStuff.DefaultBool()
|
|
self.justEnum = scalarStuff.JustEnum()
|
|
self.maybeEnum = scalarStuff.MaybeEnum()
|
|
self.defaultEnum = scalarStuff.DefaultEnum()
|
|
|
|
# ScalarStuffT
|
|
def Pack(self, builder):
|
|
ScalarStuffStart(builder)
|
|
ScalarStuffAddJustI8(builder, self.justI8)
|
|
ScalarStuffAddMaybeI8(builder, self.maybeI8)
|
|
ScalarStuffAddDefaultI8(builder, self.defaultI8)
|
|
ScalarStuffAddJustU8(builder, self.justU8)
|
|
ScalarStuffAddMaybeU8(builder, self.maybeU8)
|
|
ScalarStuffAddDefaultU8(builder, self.defaultU8)
|
|
ScalarStuffAddJustI16(builder, self.justI16)
|
|
ScalarStuffAddMaybeI16(builder, self.maybeI16)
|
|
ScalarStuffAddDefaultI16(builder, self.defaultI16)
|
|
ScalarStuffAddJustU16(builder, self.justU16)
|
|
ScalarStuffAddMaybeU16(builder, self.maybeU16)
|
|
ScalarStuffAddDefaultU16(builder, self.defaultU16)
|
|
ScalarStuffAddJustI32(builder, self.justI32)
|
|
ScalarStuffAddMaybeI32(builder, self.maybeI32)
|
|
ScalarStuffAddDefaultI32(builder, self.defaultI32)
|
|
ScalarStuffAddJustU32(builder, self.justU32)
|
|
ScalarStuffAddMaybeU32(builder, self.maybeU32)
|
|
ScalarStuffAddDefaultU32(builder, self.defaultU32)
|
|
ScalarStuffAddJustI64(builder, self.justI64)
|
|
ScalarStuffAddMaybeI64(builder, self.maybeI64)
|
|
ScalarStuffAddDefaultI64(builder, self.defaultI64)
|
|
ScalarStuffAddJustU64(builder, self.justU64)
|
|
ScalarStuffAddMaybeU64(builder, self.maybeU64)
|
|
ScalarStuffAddDefaultU64(builder, self.defaultU64)
|
|
ScalarStuffAddJustF32(builder, self.justF32)
|
|
ScalarStuffAddMaybeF32(builder, self.maybeF32)
|
|
ScalarStuffAddDefaultF32(builder, self.defaultF32)
|
|
ScalarStuffAddJustF64(builder, self.justF64)
|
|
ScalarStuffAddMaybeF64(builder, self.maybeF64)
|
|
ScalarStuffAddDefaultF64(builder, self.defaultF64)
|
|
ScalarStuffAddJustBool(builder, self.justBool)
|
|
ScalarStuffAddMaybeBool(builder, self.maybeBool)
|
|
ScalarStuffAddDefaultBool(builder, self.defaultBool)
|
|
ScalarStuffAddJustEnum(builder, self.justEnum)
|
|
ScalarStuffAddMaybeEnum(builder, self.maybeEnum)
|
|
ScalarStuffAddDefaultEnum(builder, self.defaultEnum)
|
|
scalarStuff = ScalarStuffEnd(builder)
|
|
return scalarStuff
|