• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// automatically generated by the FlatBuffers compiler, do not modify
2
3package Example
4
5import (
6	flatbuffers "github.com/google/flatbuffers/go"
7)
8
9/// an example documentation comment: monster object
10type Monster struct {
11	_tab flatbuffers.Table
12}
13
14func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
15	n := flatbuffers.GetUOffsetT(buf[offset:])
16	x := &Monster{}
17	x.Init(buf, n+offset)
18	return x
19}
20
21func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) {
22	rcv._tab.Bytes = buf
23	rcv._tab.Pos = i
24}
25
26func (rcv *Monster) Table() flatbuffers.Table {
27	return rcv._tab
28}
29
30func (rcv *Monster) Pos(obj *Vec3) *Vec3 {
31	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
32	if o != 0 {
33		x := o + rcv._tab.Pos
34		if obj == nil {
35			obj = new(Vec3)
36		}
37		obj.Init(rcv._tab.Bytes, x)
38		return obj
39	}
40	return nil
41}
42
43func (rcv *Monster) Mana() int16 {
44	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
45	if o != 0 {
46		return rcv._tab.GetInt16(o + rcv._tab.Pos)
47	}
48	return 150
49}
50
51func (rcv *Monster) MutateMana(n int16) bool {
52	return rcv._tab.MutateInt16Slot(6, n)
53}
54
55func (rcv *Monster) Hp() int16 {
56	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
57	if o != 0 {
58		return rcv._tab.GetInt16(o + rcv._tab.Pos)
59	}
60	return 100
61}
62
63func (rcv *Monster) MutateHp(n int16) bool {
64	return rcv._tab.MutateInt16Slot(8, n)
65}
66
67func (rcv *Monster) Name() []byte {
68	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
69	if o != 0 {
70		return rcv._tab.ByteVector(o + rcv._tab.Pos)
71	}
72	return nil
73}
74
75func (rcv *Monster) Inventory(j int) byte {
76	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
77	if o != 0 {
78		a := rcv._tab.Vector(o)
79		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
80	}
81	return 0
82}
83
84func (rcv *Monster) InventoryLength() int {
85	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
86	if o != 0 {
87		return rcv._tab.VectorLen(o)
88	}
89	return 0
90}
91
92func (rcv *Monster) InventoryBytes() []byte {
93	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
94	if o != 0 {
95		return rcv._tab.ByteVector(o + rcv._tab.Pos)
96	}
97	return nil
98}
99
100func (rcv *Monster) Color() int8 {
101	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
102	if o != 0 {
103		return rcv._tab.GetInt8(o + rcv._tab.Pos)
104	}
105	return 8
106}
107
108func (rcv *Monster) MutateColor(n int8) bool {
109	return rcv._tab.MutateInt8Slot(16, n)
110}
111
112func (rcv *Monster) TestType() byte {
113	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
114	if o != 0 {
115		return rcv._tab.GetByte(o + rcv._tab.Pos)
116	}
117	return 0
118}
119
120func (rcv *Monster) MutateTestType(n byte) bool {
121	return rcv._tab.MutateByteSlot(18, n)
122}
123
124func (rcv *Monster) Test(obj *flatbuffers.Table) bool {
125	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
126	if o != 0 {
127		rcv._tab.Union(obj, o)
128		return true
129	}
130	return false
131}
132
133func (rcv *Monster) Test4(obj *Test, j int) bool {
134	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
135	if o != 0 {
136		x := rcv._tab.Vector(o)
137		x += flatbuffers.UOffsetT(j) * 4
138		obj.Init(rcv._tab.Bytes, x)
139		return true
140	}
141	return false
142}
143
144func (rcv *Monster) Test4Length() int {
145	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
146	if o != 0 {
147		return rcv._tab.VectorLen(o)
148	}
149	return 0
150}
151
152func (rcv *Monster) Testarrayofstring(j int) []byte {
153	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
154	if o != 0 {
155		a := rcv._tab.Vector(o)
156		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
157	}
158	return nil
159}
160
161func (rcv *Monster) TestarrayofstringLength() int {
162	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
163	if o != 0 {
164		return rcv._tab.VectorLen(o)
165	}
166	return 0
167}
168
169/// an example documentation comment: this will end up in the generated code
170/// multiline too
171func (rcv *Monster) Testarrayoftables(obj *Monster, j int) bool {
172	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
173	if o != 0 {
174		x := rcv._tab.Vector(o)
175		x += flatbuffers.UOffsetT(j) * 4
176		x = rcv._tab.Indirect(x)
177		obj.Init(rcv._tab.Bytes, x)
178		return true
179	}
180	return false
181}
182
183func (rcv *Monster) TestarrayoftablesLength() int {
184	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
185	if o != 0 {
186		return rcv._tab.VectorLen(o)
187	}
188	return 0
189}
190
191/// an example documentation comment: this will end up in the generated code
192/// multiline too
193func (rcv *Monster) Enemy(obj *Monster) *Monster {
194	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
195	if o != 0 {
196		x := rcv._tab.Indirect(o + rcv._tab.Pos)
197		if obj == nil {
198			obj = new(Monster)
199		}
200		obj.Init(rcv._tab.Bytes, x)
201		return obj
202	}
203	return nil
204}
205
206func (rcv *Monster) Testnestedflatbuffer(j int) byte {
207	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
208	if o != 0 {
209		a := rcv._tab.Vector(o)
210		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
211	}
212	return 0
213}
214
215func (rcv *Monster) TestnestedflatbufferLength() int {
216	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
217	if o != 0 {
218		return rcv._tab.VectorLen(o)
219	}
220	return 0
221}
222
223func (rcv *Monster) TestnestedflatbufferBytes() []byte {
224	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
225	if o != 0 {
226		return rcv._tab.ByteVector(o + rcv._tab.Pos)
227	}
228	return nil
229}
230
231func (rcv *Monster) Testempty(obj *Stat) *Stat {
232	o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
233	if o != 0 {
234		x := rcv._tab.Indirect(o + rcv._tab.Pos)
235		if obj == nil {
236			obj = new(Stat)
237		}
238		obj.Init(rcv._tab.Bytes, x)
239		return obj
240	}
241	return nil
242}
243
244func (rcv *Monster) Testbool() byte {
245	o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
246	if o != 0 {
247		return rcv._tab.GetByte(o + rcv._tab.Pos)
248	}
249	return 0
250}
251
252func (rcv *Monster) MutateTestbool(n byte) bool {
253	return rcv._tab.MutateByteSlot(34, n)
254}
255
256func (rcv *Monster) Testhashs32Fnv1() int32 {
257	o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
258	if o != 0 {
259		return rcv._tab.GetInt32(o + rcv._tab.Pos)
260	}
261	return 0
262}
263
264func (rcv *Monster) MutateTesthashs32Fnv1(n int32) bool {
265	return rcv._tab.MutateInt32Slot(36, n)
266}
267
268func (rcv *Monster) Testhashu32Fnv1() uint32 {
269	o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
270	if o != 0 {
271		return rcv._tab.GetUint32(o + rcv._tab.Pos)
272	}
273	return 0
274}
275
276func (rcv *Monster) MutateTesthashu32Fnv1(n uint32) bool {
277	return rcv._tab.MutateUint32Slot(38, n)
278}
279
280func (rcv *Monster) Testhashs64Fnv1() int64 {
281	o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
282	if o != 0 {
283		return rcv._tab.GetInt64(o + rcv._tab.Pos)
284	}
285	return 0
286}
287
288func (rcv *Monster) MutateTesthashs64Fnv1(n int64) bool {
289	return rcv._tab.MutateInt64Slot(40, n)
290}
291
292func (rcv *Monster) Testhashu64Fnv1() uint64 {
293	o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
294	if o != 0 {
295		return rcv._tab.GetUint64(o + rcv._tab.Pos)
296	}
297	return 0
298}
299
300func (rcv *Monster) MutateTesthashu64Fnv1(n uint64) bool {
301	return rcv._tab.MutateUint64Slot(42, n)
302}
303
304func (rcv *Monster) Testhashs32Fnv1a() int32 {
305	o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
306	if o != 0 {
307		return rcv._tab.GetInt32(o + rcv._tab.Pos)
308	}
309	return 0
310}
311
312func (rcv *Monster) MutateTesthashs32Fnv1a(n int32) bool {
313	return rcv._tab.MutateInt32Slot(44, n)
314}
315
316func (rcv *Monster) Testhashu32Fnv1a() uint32 {
317	o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
318	if o != 0 {
319		return rcv._tab.GetUint32(o + rcv._tab.Pos)
320	}
321	return 0
322}
323
324func (rcv *Monster) MutateTesthashu32Fnv1a(n uint32) bool {
325	return rcv._tab.MutateUint32Slot(46, n)
326}
327
328func (rcv *Monster) Testhashs64Fnv1a() int64 {
329	o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
330	if o != 0 {
331		return rcv._tab.GetInt64(o + rcv._tab.Pos)
332	}
333	return 0
334}
335
336func (rcv *Monster) MutateTesthashs64Fnv1a(n int64) bool {
337	return rcv._tab.MutateInt64Slot(48, n)
338}
339
340func (rcv *Monster) Testhashu64Fnv1a() uint64 {
341	o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
342	if o != 0 {
343		return rcv._tab.GetUint64(o + rcv._tab.Pos)
344	}
345	return 0
346}
347
348func (rcv *Monster) MutateTesthashu64Fnv1a(n uint64) bool {
349	return rcv._tab.MutateUint64Slot(50, n)
350}
351
352func (rcv *Monster) Testarrayofbools(j int) byte {
353	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
354	if o != 0 {
355		a := rcv._tab.Vector(o)
356		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
357	}
358	return 0
359}
360
361func (rcv *Monster) TestarrayofboolsLength() int {
362	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
363	if o != 0 {
364		return rcv._tab.VectorLen(o)
365	}
366	return 0
367}
368
369func (rcv *Monster) Testf() float32 {
370	o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
371	if o != 0 {
372		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
373	}
374	return 3.14159
375}
376
377func (rcv *Monster) MutateTestf(n float32) bool {
378	return rcv._tab.MutateFloat32Slot(54, n)
379}
380
381func (rcv *Monster) Testf2() float32 {
382	o := flatbuffers.UOffsetT(rcv._tab.Offset(56))
383	if o != 0 {
384		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
385	}
386	return 3.0
387}
388
389func (rcv *Monster) MutateTestf2(n float32) bool {
390	return rcv._tab.MutateFloat32Slot(56, n)
391}
392
393func (rcv *Monster) Testf3() float32 {
394	o := flatbuffers.UOffsetT(rcv._tab.Offset(58))
395	if o != 0 {
396		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
397	}
398	return 0.0
399}
400
401func (rcv *Monster) MutateTestf3(n float32) bool {
402	return rcv._tab.MutateFloat32Slot(58, n)
403}
404
405func (rcv *Monster) Testarrayofstring2(j int) []byte {
406	o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
407	if o != 0 {
408		a := rcv._tab.Vector(o)
409		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
410	}
411	return nil
412}
413
414func (rcv *Monster) Testarrayofstring2Length() int {
415	o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
416	if o != 0 {
417		return rcv._tab.VectorLen(o)
418	}
419	return 0
420}
421
422func MonsterStart(builder *flatbuffers.Builder) {
423	builder.StartObject(29)
424}
425func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
426	builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
427}
428func MonsterAddMana(builder *flatbuffers.Builder, mana int16) {
429	builder.PrependInt16Slot(1, mana, 150)
430}
431func MonsterAddHp(builder *flatbuffers.Builder, hp int16) {
432	builder.PrependInt16Slot(2, hp, 100)
433}
434func MonsterAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
435	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(name), 0)
436}
437func MonsterAddInventory(builder *flatbuffers.Builder, inventory flatbuffers.UOffsetT) {
438	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(inventory), 0)
439}
440func MonsterStartInventoryVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
441	return builder.StartVector(1, numElems, 1)
442}
443func MonsterAddColor(builder *flatbuffers.Builder, color int8) {
444	builder.PrependInt8Slot(6, color, 8)
445}
446func MonsterAddTestType(builder *flatbuffers.Builder, testType byte) {
447	builder.PrependByteSlot(7, testType, 0)
448}
449func MonsterAddTest(builder *flatbuffers.Builder, test flatbuffers.UOffsetT) {
450	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(test), 0)
451}
452func MonsterAddTest4(builder *flatbuffers.Builder, test4 flatbuffers.UOffsetT) {
453	builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(test4), 0)
454}
455func MonsterStartTest4Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
456	return builder.StartVector(4, numElems, 2)
457}
458func MonsterAddTestarrayofstring(builder *flatbuffers.Builder, testarrayofstring flatbuffers.UOffsetT) {
459	builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(testarrayofstring), 0)
460}
461func MonsterStartTestarrayofstringVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
462	return builder.StartVector(4, numElems, 4)
463}
464func MonsterAddTestarrayoftables(builder *flatbuffers.Builder, testarrayoftables flatbuffers.UOffsetT) {
465	builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(testarrayoftables), 0)
466}
467func MonsterStartTestarrayoftablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
468	return builder.StartVector(4, numElems, 4)
469}
470func MonsterAddEnemy(builder *flatbuffers.Builder, enemy flatbuffers.UOffsetT) {
471	builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(enemy), 0)
472}
473func MonsterAddTestnestedflatbuffer(builder *flatbuffers.Builder, testnestedflatbuffer flatbuffers.UOffsetT) {
474	builder.PrependUOffsetTSlot(13, flatbuffers.UOffsetT(testnestedflatbuffer), 0)
475}
476func MonsterStartTestnestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
477	return builder.StartVector(1, numElems, 1)
478}
479func MonsterAddTestempty(builder *flatbuffers.Builder, testempty flatbuffers.UOffsetT) {
480	builder.PrependUOffsetTSlot(14, flatbuffers.UOffsetT(testempty), 0)
481}
482func MonsterAddTestbool(builder *flatbuffers.Builder, testbool byte) {
483	builder.PrependByteSlot(15, testbool, 0)
484}
485func MonsterAddTesthashs32Fnv1(builder *flatbuffers.Builder, testhashs32Fnv1 int32) {
486	builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
487}
488func MonsterAddTesthashu32Fnv1(builder *flatbuffers.Builder, testhashu32Fnv1 uint32) {
489	builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
490}
491func MonsterAddTesthashs64Fnv1(builder *flatbuffers.Builder, testhashs64Fnv1 int64) {
492	builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
493}
494func MonsterAddTesthashu64Fnv1(builder *flatbuffers.Builder, testhashu64Fnv1 uint64) {
495	builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
496}
497func MonsterAddTesthashs32Fnv1a(builder *flatbuffers.Builder, testhashs32Fnv1a int32) {
498	builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
499}
500func MonsterAddTesthashu32Fnv1a(builder *flatbuffers.Builder, testhashu32Fnv1a uint32) {
501	builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
502}
503func MonsterAddTesthashs64Fnv1a(builder *flatbuffers.Builder, testhashs64Fnv1a int64) {
504	builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
505}
506func MonsterAddTesthashu64Fnv1a(builder *flatbuffers.Builder, testhashu64Fnv1a uint64) {
507	builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
508}
509func MonsterAddTestarrayofbools(builder *flatbuffers.Builder, testarrayofbools flatbuffers.UOffsetT) {
510	builder.PrependUOffsetTSlot(24, flatbuffers.UOffsetT(testarrayofbools), 0)
511}
512func MonsterStartTestarrayofboolsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
513	return builder.StartVector(1, numElems, 1)
514}
515func MonsterAddTestf(builder *flatbuffers.Builder, testf float32) {
516	builder.PrependFloat32Slot(25, testf, 3.14159)
517}
518func MonsterAddTestf2(builder *flatbuffers.Builder, testf2 float32) {
519	builder.PrependFloat32Slot(26, testf2, 3.0)
520}
521func MonsterAddTestf3(builder *flatbuffers.Builder, testf3 float32) {
522	builder.PrependFloat32Slot(27, testf3, 0.0)
523}
524func MonsterAddTestarrayofstring2(builder *flatbuffers.Builder, testarrayofstring2 flatbuffers.UOffsetT) {
525	builder.PrependUOffsetTSlot(28, flatbuffers.UOffsetT(testarrayofstring2), 0)
526}
527func MonsterStartTestarrayofstring2Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
528	return builder.StartVector(4, numElems, 4)
529}
530func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
531	return builder.EndObject()
532}
533