1# automatically generated by the FlatBuffers compiler, do not modify
2
3# namespace: Example
4
5import flatbuffers
6from flatbuffers.compat import import_numpy
7np = import_numpy()
8
9class TypeAliases(object):
10    __slots__ = ['_tab']
11
12    @classmethod
13    def GetRootAs(cls, buf, offset=0):
14        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
15        x = TypeAliases()
16        x.Init(buf, n + offset)
17        return x
18
19    @classmethod
20    def GetRootAsTypeAliases(cls, buf, offset=0):
21        """This method is deprecated. Please switch to GetRootAs."""
22        return cls.GetRootAs(buf, offset)
23    @classmethod
24    def TypeAliasesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
25        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
26
27    # TypeAliases
28    def Init(self, buf, pos):
29        self._tab = flatbuffers.table.Table(buf, pos)
30
31    # TypeAliases
32    def I8(self):
33        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
34        if o != 0:
35            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
36        return 0
37
38    # TypeAliases
39    def U8(self):
40        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
41        if o != 0:
42            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
43        return 0
44
45    # TypeAliases
46    def I16(self):
47        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
48        if o != 0:
49            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
50        return 0
51
52    # TypeAliases
53    def U16(self):
54        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
55        if o != 0:
56            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
57        return 0
58
59    # TypeAliases
60    def I32(self):
61        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
62        if o != 0:
63            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
64        return 0
65
66    # TypeAliases
67    def U32(self):
68        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
69        if o != 0:
70            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
71        return 0
72
73    # TypeAliases
74    def I64(self):
75        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
76        if o != 0:
77            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
78        return 0
79
80    # TypeAliases
81    def U64(self):
82        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
83        if o != 0:
84            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
85        return 0
86
87    # TypeAliases
88    def F32(self):
89        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
90        if o != 0:
91            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
92        return 0.0
93
94    # TypeAliases
95    def F64(self):
96        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
97        if o != 0:
98            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
99        return 0.0
100
101    # TypeAliases
102    def V8(self, j):
103        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
104        if o != 0:
105            a = self._tab.Vector(o)
106            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
107        return 0
108
109    # TypeAliases
110    def V8AsNumpy(self):
111        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
112        if o != 0:
113            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
114        return 0
115
116    # TypeAliases
117    def V8Length(self):
118        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
119        if o != 0:
120            return self._tab.VectorLen(o)
121        return 0
122
123    # TypeAliases
124    def V8IsNone(self):
125        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
126        return o == 0
127
128    # TypeAliases
129    def Vf64(self, j):
130        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
131        if o != 0:
132            a = self._tab.Vector(o)
133            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
134        return 0
135
136    # TypeAliases
137    def Vf64AsNumpy(self):
138        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
139        if o != 0:
140            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
141        return 0
142
143    # TypeAliases
144    def Vf64Length(self):
145        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
146        if o != 0:
147            return self._tab.VectorLen(o)
148        return 0
149
150    # TypeAliases
151    def Vf64IsNone(self):
152        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
153        return o == 0
154
155def Start(builder): builder.StartObject(12)
156def TypeAliasesStart(builder):
157    """This method is deprecated. Please switch to Start."""
158    return Start(builder)
159def AddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
160def TypeAliasesAddI8(builder, i8):
161    """This method is deprecated. Please switch to AddI8."""
162    return AddI8(builder, i8)
163def AddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
164def TypeAliasesAddU8(builder, u8):
165    """This method is deprecated. Please switch to AddU8."""
166    return AddU8(builder, u8)
167def AddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
168def TypeAliasesAddI16(builder, i16):
169    """This method is deprecated. Please switch to AddI16."""
170    return AddI16(builder, i16)
171def AddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
172def TypeAliasesAddU16(builder, u16):
173    """This method is deprecated. Please switch to AddU16."""
174    return AddU16(builder, u16)
175def AddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
176def TypeAliasesAddI32(builder, i32):
177    """This method is deprecated. Please switch to AddI32."""
178    return AddI32(builder, i32)
179def AddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
180def TypeAliasesAddU32(builder, u32):
181    """This method is deprecated. Please switch to AddU32."""
182    return AddU32(builder, u32)
183def AddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
184def TypeAliasesAddI64(builder, i64):
185    """This method is deprecated. Please switch to AddI64."""
186    return AddI64(builder, i64)
187def AddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
188def TypeAliasesAddU64(builder, u64):
189    """This method is deprecated. Please switch to AddU64."""
190    return AddU64(builder, u64)
191def AddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
192def TypeAliasesAddF32(builder, f32):
193    """This method is deprecated. Please switch to AddF32."""
194    return AddF32(builder, f32)
195def AddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
196def TypeAliasesAddF64(builder, f64):
197    """This method is deprecated. Please switch to AddF64."""
198    return AddF64(builder, f64)
199def AddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
200def TypeAliasesAddV8(builder, v8):
201    """This method is deprecated. Please switch to AddV8."""
202    return AddV8(builder, v8)
203def StartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
204def TypeAliasesStartV8Vector(builder, numElems):
205    """This method is deprecated. Please switch to Start."""
206    return StartV8Vector(builder, numElems)
207def AddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
208def TypeAliasesAddVf64(builder, vf64):
209    """This method is deprecated. Please switch to AddVf64."""
210    return AddVf64(builder, vf64)
211def StartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
212def TypeAliasesStartVf64Vector(builder, numElems):
213    """This method is deprecated. Please switch to Start."""
214    return StartVf64Vector(builder, numElems)
215def End(builder): return builder.EndObject()
216def TypeAliasesEnd(builder):
217    """This method is deprecated. Please switch to End."""
218    return End(builder)
219try:
220    from typing import List
221except:
222    pass
223
224class TypeAliasesT(object):
225
226    # TypeAliasesT
227    def __init__(self):
228        self.i8 = 0  # type: int
229        self.u8 = 0  # type: int
230        self.i16 = 0  # type: int
231        self.u16 = 0  # type: int
232        self.i32 = 0  # type: int
233        self.u32 = 0  # type: int
234        self.i64 = 0  # type: int
235        self.u64 = 0  # type: int
236        self.f32 = 0.0  # type: float
237        self.f64 = 0.0  # type: float
238        self.v8 = None  # type: List[int]
239        self.vf64 = None  # type: List[float]
240
241    @classmethod
242    def InitFromBuf(cls, buf, pos):
243        typeAliases = TypeAliases()
244        typeAliases.Init(buf, pos)
245        return cls.InitFromObj(typeAliases)
246
247    @classmethod
248    def InitFromObj(cls, typeAliases):
249        x = TypeAliasesT()
250        x._UnPack(typeAliases)
251        return x
252
253    # TypeAliasesT
254    def _UnPack(self, typeAliases):
255        if typeAliases is None:
256            return
257        self.i8 = typeAliases.I8()
258        self.u8 = typeAliases.U8()
259        self.i16 = typeAliases.I16()
260        self.u16 = typeAliases.U16()
261        self.i32 = typeAliases.I32()
262        self.u32 = typeAliases.U32()
263        self.i64 = typeAliases.I64()
264        self.u64 = typeAliases.U64()
265        self.f32 = typeAliases.F32()
266        self.f64 = typeAliases.F64()
267        if not typeAliases.V8IsNone():
268            if np is None:
269                self.v8 = []
270                for i in range(typeAliases.V8Length()):
271                    self.v8.append(typeAliases.V8(i))
272            else:
273                self.v8 = typeAliases.V8AsNumpy()
274        if not typeAliases.Vf64IsNone():
275            if np is None:
276                self.vf64 = []
277                for i in range(typeAliases.Vf64Length()):
278                    self.vf64.append(typeAliases.Vf64(i))
279            else:
280                self.vf64 = typeAliases.Vf64AsNumpy()
281
282    # TypeAliasesT
283    def Pack(self, builder):
284        if self.v8 is not None:
285            if np is not None and type(self.v8) is np.ndarray:
286                v8 = builder.CreateNumpyVector(self.v8)
287            else:
288                StartV8Vector(builder, len(self.v8))
289                for i in reversed(range(len(self.v8))):
290                    builder.PrependByte(self.v8[i])
291                v8 = builder.EndVector()
292        if self.vf64 is not None:
293            if np is not None and type(self.vf64) is np.ndarray:
294                vf64 = builder.CreateNumpyVector(self.vf64)
295            else:
296                StartVf64Vector(builder, len(self.vf64))
297                for i in reversed(range(len(self.vf64))):
298                    builder.PrependFloat64(self.vf64[i])
299                vf64 = builder.EndVector()
300        Start(builder)
301        AddI8(builder, self.i8)
302        AddU8(builder, self.u8)
303        AddI16(builder, self.i16)
304        AddU16(builder, self.u16)
305        AddI32(builder, self.i32)
306        AddU32(builder, self.u32)
307        AddI64(builder, self.i64)
308        AddU64(builder, self.u64)
309        AddF32(builder, self.f32)
310        AddF64(builder, self.f64)
311        if self.v8 is not None:
312            AddV8(builder, v8)
313        if self.vf64 is not None:
314            AddVf64(builder, vf64)
315        typeAliases = End(builder)
316        return typeAliases
317