| # 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): |
| scalarStuff = ScalarStuff() |
| scalarStuff.Init(buf, pos) |
| return cls.InitFromObj(scalarStuff) |
| |
| @classmethod |
| def InitFromPackedBuf(cls, buf, pos=0): |
| n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) |
| return cls.InitFromBuf(buf, pos+n) |
| |
| @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 |
