1
2
3 package Example
4
5 import (
6 flatbuffers "github.com/google/flatbuffers/go"
7 )
8
9 type TypeAliasesT struct {
10 I8 int8 `json:"i8"`
11 U8 byte `json:"u8"`
12 I16 int16 `json:"i16"`
13 U16 uint16 `json:"u16"`
14 I32 int32 `json:"i32"`
15 U32 uint32 `json:"u32"`
16 I64 int64 `json:"i64"`
17 U64 uint64 `json:"u64"`
18 F32 float32 `json:"f32"`
19 F64 float64 `json:"f64"`
20 V8 []int8 `json:"v8"`
21 Vf64 []float64 `json:"vf64"`
22 }
23
24 func (t *TypeAliasesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
25 if t == nil {
26 return 0
27 }
28 v8Offset := flatbuffers.UOffsetT(0)
29 if t.V8 != nil {
30 v8Length := len(t.V8)
31 TypeAliasesStartV8Vector(builder, v8Length)
32 for j := v8Length - 1; j >= 0; j-- {
33 builder.PrependInt8(t.V8[j])
34 }
35 v8Offset = builder.EndVector(v8Length)
36 }
37 vf64Offset := flatbuffers.UOffsetT(0)
38 if t.Vf64 != nil {
39 vf64Length := len(t.Vf64)
40 TypeAliasesStartVf64Vector(builder, vf64Length)
41 for j := vf64Length - 1; j >= 0; j-- {
42 builder.PrependFloat64(t.Vf64[j])
43 }
44 vf64Offset = builder.EndVector(vf64Length)
45 }
46 TypeAliasesStart(builder)
47 TypeAliasesAddI8(builder, t.I8)
48 TypeAliasesAddU8(builder, t.U8)
49 TypeAliasesAddI16(builder, t.I16)
50 TypeAliasesAddU16(builder, t.U16)
51 TypeAliasesAddI32(builder, t.I32)
52 TypeAliasesAddU32(builder, t.U32)
53 TypeAliasesAddI64(builder, t.I64)
54 TypeAliasesAddU64(builder, t.U64)
55 TypeAliasesAddF32(builder, t.F32)
56 TypeAliasesAddF64(builder, t.F64)
57 TypeAliasesAddV8(builder, v8Offset)
58 TypeAliasesAddVf64(builder, vf64Offset)
59 return TypeAliasesEnd(builder)
60 }
61
62 func (rcv *TypeAliases) UnPackTo(t *TypeAliasesT) {
63 t.I8 = rcv.I8()
64 t.U8 = rcv.U8()
65 t.I16 = rcv.I16()
66 t.U16 = rcv.U16()
67 t.I32 = rcv.I32()
68 t.U32 = rcv.U32()
69 t.I64 = rcv.I64()
70 t.U64 = rcv.U64()
71 t.F32 = rcv.F32()
72 t.F64 = rcv.F64()
73 v8Length := rcv.V8Length()
74 t.V8 = make([]int8, v8Length)
75 for j := 0; j < v8Length; j++ {
76 t.V8[j] = rcv.V8(j)
77 }
78 vf64Length := rcv.Vf64Length()
79 t.Vf64 = make([]float64, vf64Length)
80 for j := 0; j < vf64Length; j++ {
81 t.Vf64[j] = rcv.Vf64(j)
82 }
83 }
84
85 func (rcv *TypeAliases) UnPack() *TypeAliasesT {
86 if rcv == nil {
87 return nil
88 }
89 t := &TypeAliasesT{}
90 rcv.UnPackTo(t)
91 return t
92 }
93
94 type TypeAliases struct {
95 _tab flatbuffers.Table
96 }
97
98 func GetRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases {
99 n := flatbuffers.GetUOffsetT(buf[offset:])
100 x := &TypeAliases{}
101 x.Init(buf, n+offset)
102 return x
103 }
104
105 func FinishTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
106 builder.Finish(offset)
107 }
108
109 func GetSizePrefixedRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases {
110 n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
111 x := &TypeAliases{}
112 x.Init(buf, n+offset+flatbuffers.SizeUint32)
113 return x
114 }
115
116 func FinishSizePrefixedTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
117 builder.FinishSizePrefixed(offset)
118 }
119
120 func (rcv *TypeAliases) Init(buf []byte, i flatbuffers.UOffsetT) {
121 rcv._tab.Bytes = buf
122 rcv._tab.Pos = i
123 }
124
125 func (rcv *TypeAliases) Table() flatbuffers.Table {
126 return rcv._tab
127 }
128
129 func (rcv *TypeAliases) I8() int8 {
130 o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
131 if o != 0 {
132 return rcv._tab.GetInt8(o + rcv._tab.Pos)
133 }
134 return 0
135 }
136
137 func (rcv *TypeAliases) MutateI8(n int8) bool {
138 return rcv._tab.MutateInt8Slot(4, n)
139 }
140
141 func (rcv *TypeAliases) U8() byte {
142 o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
143 if o != 0 {
144 return rcv._tab.GetByte(o + rcv._tab.Pos)
145 }
146 return 0
147 }
148
149 func (rcv *TypeAliases) MutateU8(n byte) bool {
150 return rcv._tab.MutateByteSlot(6, n)
151 }
152
153 func (rcv *TypeAliases) I16() int16 {
154 o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
155 if o != 0 {
156 return rcv._tab.GetInt16(o + rcv._tab.Pos)
157 }
158 return 0
159 }
160
161 func (rcv *TypeAliases) MutateI16(n int16) bool {
162 return rcv._tab.MutateInt16Slot(8, n)
163 }
164
165 func (rcv *TypeAliases) U16() uint16 {
166 o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
167 if o != 0 {
168 return rcv._tab.GetUint16(o + rcv._tab.Pos)
169 }
170 return 0
171 }
172
173 func (rcv *TypeAliases) MutateU16(n uint16) bool {
174 return rcv._tab.MutateUint16Slot(10, n)
175 }
176
177 func (rcv *TypeAliases) I32() int32 {
178 o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
179 if o != 0 {
180 return rcv._tab.GetInt32(o + rcv._tab.Pos)
181 }
182 return 0
183 }
184
185 func (rcv *TypeAliases) MutateI32(n int32) bool {
186 return rcv._tab.MutateInt32Slot(12, n)
187 }
188
189 func (rcv *TypeAliases) U32() uint32 {
190 o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
191 if o != 0 {
192 return rcv._tab.GetUint32(o + rcv._tab.Pos)
193 }
194 return 0
195 }
196
197 func (rcv *TypeAliases) MutateU32(n uint32) bool {
198 return rcv._tab.MutateUint32Slot(14, n)
199 }
200
201 func (rcv *TypeAliases) I64() int64 {
202 o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
203 if o != 0 {
204 return rcv._tab.GetInt64(o + rcv._tab.Pos)
205 }
206 return 0
207 }
208
209 func (rcv *TypeAliases) MutateI64(n int64) bool {
210 return rcv._tab.MutateInt64Slot(16, n)
211 }
212
213 func (rcv *TypeAliases) U64() uint64 {
214 o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
215 if o != 0 {
216 return rcv._tab.GetUint64(o + rcv._tab.Pos)
217 }
218 return 0
219 }
220
221 func (rcv *TypeAliases) MutateU64(n uint64) bool {
222 return rcv._tab.MutateUint64Slot(18, n)
223 }
224
225 func (rcv *TypeAliases) F32() float32 {
226 o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
227 if o != 0 {
228 return rcv._tab.GetFloat32(o + rcv._tab.Pos)
229 }
230 return 0.0
231 }
232
233 func (rcv *TypeAliases) MutateF32(n float32) bool {
234 return rcv._tab.MutateFloat32Slot(20, n)
235 }
236
237 func (rcv *TypeAliases) F64() float64 {
238 o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
239 if o != 0 {
240 return rcv._tab.GetFloat64(o + rcv._tab.Pos)
241 }
242 return 0.0
243 }
244
245 func (rcv *TypeAliases) MutateF64(n float64) bool {
246 return rcv._tab.MutateFloat64Slot(22, n)
247 }
248
249 func (rcv *TypeAliases) V8(j int) int8 {
250 o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
251 if o != 0 {
252 a := rcv._tab.Vector(o)
253 return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))
254 }
255 return 0
256 }
257
258 func (rcv *TypeAliases) V8Length() int {
259 o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
260 if o != 0 {
261 return rcv._tab.VectorLen(o)
262 }
263 return 0
264 }
265
266 func (rcv *TypeAliases) MutateV8(j int, n int8) bool {
267 o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
268 if o != 0 {
269 a := rcv._tab.Vector(o)
270 return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), n)
271 }
272 return false
273 }
274
275 func (rcv *TypeAliases) Vf64(j int) float64 {
276 o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
277 if o != 0 {
278 a := rcv._tab.Vector(o)
279 return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8))
280 }
281 return 0
282 }
283
284 func (rcv *TypeAliases) Vf64Length() int {
285 o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
286 if o != 0 {
287 return rcv._tab.VectorLen(o)
288 }
289 return 0
290 }
291
292 func (rcv *TypeAliases) MutateVf64(j int, n float64) bool {
293 o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
294 if o != 0 {
295 a := rcv._tab.Vector(o)
296 return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n)
297 }
298 return false
299 }
300
301 func TypeAliasesStart(builder *flatbuffers.Builder) {
302 builder.StartObject(12)
303 }
304 func TypeAliasesAddI8(builder *flatbuffers.Builder, i8 int8) {
305 builder.PrependInt8Slot(0, i8, 0)
306 }
307 func TypeAliasesAddU8(builder *flatbuffers.Builder, u8 byte) {
308 builder.PrependByteSlot(1, u8, 0)
309 }
310 func TypeAliasesAddI16(builder *flatbuffers.Builder, i16 int16) {
311 builder.PrependInt16Slot(2, i16, 0)
312 }
313 func TypeAliasesAddU16(builder *flatbuffers.Builder, u16 uint16) {
314 builder.PrependUint16Slot(3, u16, 0)
315 }
316 func TypeAliasesAddI32(builder *flatbuffers.Builder, i32 int32) {
317 builder.PrependInt32Slot(4, i32, 0)
318 }
319 func TypeAliasesAddU32(builder *flatbuffers.Builder, u32 uint32) {
320 builder.PrependUint32Slot(5, u32, 0)
321 }
322 func TypeAliasesAddI64(builder *flatbuffers.Builder, i64 int64) {
323 builder.PrependInt64Slot(6, i64, 0)
324 }
325 func TypeAliasesAddU64(builder *flatbuffers.Builder, u64 uint64) {
326 builder.PrependUint64Slot(7, u64, 0)
327 }
328 func TypeAliasesAddF32(builder *flatbuffers.Builder, f32 float32) {
329 builder.PrependFloat32Slot(8, f32, 0.0)
330 }
331 func TypeAliasesAddF64(builder *flatbuffers.Builder, f64 float64) {
332 builder.PrependFloat64Slot(9, f64, 0.0)
333 }
334 func TypeAliasesAddV8(builder *flatbuffers.Builder, v8 flatbuffers.UOffsetT) {
335 builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(v8), 0)
336 }
337 func TypeAliasesStartV8Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
338 return builder.StartVector(1, numElems, 1)
339 }
340 func TypeAliasesAddVf64(builder *flatbuffers.Builder, vf64 flatbuffers.UOffsetT) {
341 builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(vf64), 0)
342 }
343 func TypeAliasesStartVf64Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
344 return builder.StartVector(8, numElems, 8)
345 }
346 func TypeAliasesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
347 return builder.EndObject()
348 }
349
View as plain text