1
2
3 package optional_scalars
4
5 import (
6 flatbuffers "github.com/google/flatbuffers/go"
7 )
8
9 type ScalarStuffT struct {
10 JustI8 int8 `json:"just_i8"`
11 MaybeI8 *int8 `json:"maybe_i8"`
12 DefaultI8 int8 `json:"default_i8"`
13 JustU8 byte `json:"just_u8"`
14 MaybeU8 *byte `json:"maybe_u8"`
15 DefaultU8 byte `json:"default_u8"`
16 JustI16 int16 `json:"just_i16"`
17 MaybeI16 *int16 `json:"maybe_i16"`
18 DefaultI16 int16 `json:"default_i16"`
19 JustU16 uint16 `json:"just_u16"`
20 MaybeU16 *uint16 `json:"maybe_u16"`
21 DefaultU16 uint16 `json:"default_u16"`
22 JustI32 int32 `json:"just_i32"`
23 MaybeI32 *int32 `json:"maybe_i32"`
24 DefaultI32 int32 `json:"default_i32"`
25 JustU32 uint32 `json:"just_u32"`
26 MaybeU32 *uint32 `json:"maybe_u32"`
27 DefaultU32 uint32 `json:"default_u32"`
28 JustI64 int64 `json:"just_i64"`
29 MaybeI64 *int64 `json:"maybe_i64"`
30 DefaultI64 int64 `json:"default_i64"`
31 JustU64 uint64 `json:"just_u64"`
32 MaybeU64 *uint64 `json:"maybe_u64"`
33 DefaultU64 uint64 `json:"default_u64"`
34 JustF32 float32 `json:"just_f32"`
35 MaybeF32 *float32 `json:"maybe_f32"`
36 DefaultF32 float32 `json:"default_f32"`
37 JustF64 float64 `json:"just_f64"`
38 MaybeF64 *float64 `json:"maybe_f64"`
39 DefaultF64 float64 `json:"default_f64"`
40 JustBool bool `json:"just_bool"`
41 MaybeBool *bool `json:"maybe_bool"`
42 DefaultBool bool `json:"default_bool"`
43 JustEnum OptionalByte `json:"just_enum"`
44 MaybeEnum *OptionalByte `json:"maybe_enum"`
45 DefaultEnum OptionalByte `json:"default_enum"`
46 }
47
48 func (t *ScalarStuffT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
49 if t == nil { return 0 }
50 ScalarStuffStart(builder)
51 ScalarStuffAddJustI8(builder, t.JustI8)
52 if t.MaybeI8 != nil {
53 ScalarStuffAddMaybeI8(builder, *t.MaybeI8)
54 }
55 ScalarStuffAddDefaultI8(builder, t.DefaultI8)
56 ScalarStuffAddJustU8(builder, t.JustU8)
57 if t.MaybeU8 != nil {
58 ScalarStuffAddMaybeU8(builder, *t.MaybeU8)
59 }
60 ScalarStuffAddDefaultU8(builder, t.DefaultU8)
61 ScalarStuffAddJustI16(builder, t.JustI16)
62 if t.MaybeI16 != nil {
63 ScalarStuffAddMaybeI16(builder, *t.MaybeI16)
64 }
65 ScalarStuffAddDefaultI16(builder, t.DefaultI16)
66 ScalarStuffAddJustU16(builder, t.JustU16)
67 if t.MaybeU16 != nil {
68 ScalarStuffAddMaybeU16(builder, *t.MaybeU16)
69 }
70 ScalarStuffAddDefaultU16(builder, t.DefaultU16)
71 ScalarStuffAddJustI32(builder, t.JustI32)
72 if t.MaybeI32 != nil {
73 ScalarStuffAddMaybeI32(builder, *t.MaybeI32)
74 }
75 ScalarStuffAddDefaultI32(builder, t.DefaultI32)
76 ScalarStuffAddJustU32(builder, t.JustU32)
77 if t.MaybeU32 != nil {
78 ScalarStuffAddMaybeU32(builder, *t.MaybeU32)
79 }
80 ScalarStuffAddDefaultU32(builder, t.DefaultU32)
81 ScalarStuffAddJustI64(builder, t.JustI64)
82 if t.MaybeI64 != nil {
83 ScalarStuffAddMaybeI64(builder, *t.MaybeI64)
84 }
85 ScalarStuffAddDefaultI64(builder, t.DefaultI64)
86 ScalarStuffAddJustU64(builder, t.JustU64)
87 if t.MaybeU64 != nil {
88 ScalarStuffAddMaybeU64(builder, *t.MaybeU64)
89 }
90 ScalarStuffAddDefaultU64(builder, t.DefaultU64)
91 ScalarStuffAddJustF32(builder, t.JustF32)
92 if t.MaybeF32 != nil {
93 ScalarStuffAddMaybeF32(builder, *t.MaybeF32)
94 }
95 ScalarStuffAddDefaultF32(builder, t.DefaultF32)
96 ScalarStuffAddJustF64(builder, t.JustF64)
97 if t.MaybeF64 != nil {
98 ScalarStuffAddMaybeF64(builder, *t.MaybeF64)
99 }
100 ScalarStuffAddDefaultF64(builder, t.DefaultF64)
101 ScalarStuffAddJustBool(builder, t.JustBool)
102 if t.MaybeBool != nil {
103 ScalarStuffAddMaybeBool(builder, *t.MaybeBool)
104 }
105 ScalarStuffAddDefaultBool(builder, t.DefaultBool)
106 ScalarStuffAddJustEnum(builder, t.JustEnum)
107 if t.MaybeEnum != nil {
108 ScalarStuffAddMaybeEnum(builder, *t.MaybeEnum)
109 }
110 ScalarStuffAddDefaultEnum(builder, t.DefaultEnum)
111 return ScalarStuffEnd(builder)
112 }
113
114 func (rcv *ScalarStuff) UnPackTo(t *ScalarStuffT) {
115 t.JustI8 = rcv.JustI8()
116 t.MaybeI8 = rcv.MaybeI8()
117 t.DefaultI8 = rcv.DefaultI8()
118 t.JustU8 = rcv.JustU8()
119 t.MaybeU8 = rcv.MaybeU8()
120 t.DefaultU8 = rcv.DefaultU8()
121 t.JustI16 = rcv.JustI16()
122 t.MaybeI16 = rcv.MaybeI16()
123 t.DefaultI16 = rcv.DefaultI16()
124 t.JustU16 = rcv.JustU16()
125 t.MaybeU16 = rcv.MaybeU16()
126 t.DefaultU16 = rcv.DefaultU16()
127 t.JustI32 = rcv.JustI32()
128 t.MaybeI32 = rcv.MaybeI32()
129 t.DefaultI32 = rcv.DefaultI32()
130 t.JustU32 = rcv.JustU32()
131 t.MaybeU32 = rcv.MaybeU32()
132 t.DefaultU32 = rcv.DefaultU32()
133 t.JustI64 = rcv.JustI64()
134 t.MaybeI64 = rcv.MaybeI64()
135 t.DefaultI64 = rcv.DefaultI64()
136 t.JustU64 = rcv.JustU64()
137 t.MaybeU64 = rcv.MaybeU64()
138 t.DefaultU64 = rcv.DefaultU64()
139 t.JustF32 = rcv.JustF32()
140 t.MaybeF32 = rcv.MaybeF32()
141 t.DefaultF32 = rcv.DefaultF32()
142 t.JustF64 = rcv.JustF64()
143 t.MaybeF64 = rcv.MaybeF64()
144 t.DefaultF64 = rcv.DefaultF64()
145 t.JustBool = rcv.JustBool()
146 t.MaybeBool = rcv.MaybeBool()
147 t.DefaultBool = rcv.DefaultBool()
148 t.JustEnum = rcv.JustEnum()
149 t.MaybeEnum = rcv.MaybeEnum()
150 t.DefaultEnum = rcv.DefaultEnum()
151 }
152
153 func (rcv *ScalarStuff) UnPack() *ScalarStuffT {
154 if rcv == nil { return nil }
155 t := &ScalarStuffT{}
156 rcv.UnPackTo(t)
157 return t
158 }
159
160 type ScalarStuff struct {
161 _tab flatbuffers.Table
162 }
163
164 func GetRootAsScalarStuff(buf []byte, offset flatbuffers.UOffsetT) *ScalarStuff {
165 n := flatbuffers.GetUOffsetT(buf[offset:])
166 x := &ScalarStuff{}
167 x.Init(buf, n+offset)
168 return x
169 }
170
171 func GetSizePrefixedRootAsScalarStuff(buf []byte, offset flatbuffers.UOffsetT) *ScalarStuff {
172 n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
173 x := &ScalarStuff{}
174 x.Init(buf, n+offset+flatbuffers.SizeUint32)
175 return x
176 }
177
178 func (rcv *ScalarStuff) Init(buf []byte, i flatbuffers.UOffsetT) {
179 rcv._tab.Bytes = buf
180 rcv._tab.Pos = i
181 }
182
183 func (rcv *ScalarStuff) Table() flatbuffers.Table {
184 return rcv._tab
185 }
186
187 func (rcv *ScalarStuff) JustI8() int8 {
188 o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
189 if o != 0 {
190 return rcv._tab.GetInt8(o + rcv._tab.Pos)
191 }
192 return 0
193 }
194
195 func (rcv *ScalarStuff) MutateJustI8(n int8) bool {
196 return rcv._tab.MutateInt8Slot(4, n)
197 }
198
199 func (rcv *ScalarStuff) MaybeI8() *int8 {
200 o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
201 if o != 0 {
202 v := rcv._tab.GetInt8(o + rcv._tab.Pos)
203 return &v
204 }
205 return nil
206 }
207
208 func (rcv *ScalarStuff) MutateMaybeI8(n int8) bool {
209 return rcv._tab.MutateInt8Slot(6, n)
210 }
211
212 func (rcv *ScalarStuff) DefaultI8() int8 {
213 o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
214 if o != 0 {
215 return rcv._tab.GetInt8(o + rcv._tab.Pos)
216 }
217 return 42
218 }
219
220 func (rcv *ScalarStuff) MutateDefaultI8(n int8) bool {
221 return rcv._tab.MutateInt8Slot(8, n)
222 }
223
224 func (rcv *ScalarStuff) JustU8() byte {
225 o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
226 if o != 0 {
227 return rcv._tab.GetByte(o + rcv._tab.Pos)
228 }
229 return 0
230 }
231
232 func (rcv *ScalarStuff) MutateJustU8(n byte) bool {
233 return rcv._tab.MutateByteSlot(10, n)
234 }
235
236 func (rcv *ScalarStuff) MaybeU8() *byte {
237 o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
238 if o != 0 {
239 v := rcv._tab.GetByte(o + rcv._tab.Pos)
240 return &v
241 }
242 return nil
243 }
244
245 func (rcv *ScalarStuff) MutateMaybeU8(n byte) bool {
246 return rcv._tab.MutateByteSlot(12, n)
247 }
248
249 func (rcv *ScalarStuff) DefaultU8() byte {
250 o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
251 if o != 0 {
252 return rcv._tab.GetByte(o + rcv._tab.Pos)
253 }
254 return 42
255 }
256
257 func (rcv *ScalarStuff) MutateDefaultU8(n byte) bool {
258 return rcv._tab.MutateByteSlot(14, n)
259 }
260
261 func (rcv *ScalarStuff) JustI16() int16 {
262 o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
263 if o != 0 {
264 return rcv._tab.GetInt16(o + rcv._tab.Pos)
265 }
266 return 0
267 }
268
269 func (rcv *ScalarStuff) MutateJustI16(n int16) bool {
270 return rcv._tab.MutateInt16Slot(16, n)
271 }
272
273 func (rcv *ScalarStuff) MaybeI16() *int16 {
274 o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
275 if o != 0 {
276 v := rcv._tab.GetInt16(o + rcv._tab.Pos)
277 return &v
278 }
279 return nil
280 }
281
282 func (rcv *ScalarStuff) MutateMaybeI16(n int16) bool {
283 return rcv._tab.MutateInt16Slot(18, n)
284 }
285
286 func (rcv *ScalarStuff) DefaultI16() int16 {
287 o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
288 if o != 0 {
289 return rcv._tab.GetInt16(o + rcv._tab.Pos)
290 }
291 return 42
292 }
293
294 func (rcv *ScalarStuff) MutateDefaultI16(n int16) bool {
295 return rcv._tab.MutateInt16Slot(20, n)
296 }
297
298 func (rcv *ScalarStuff) JustU16() uint16 {
299 o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
300 if o != 0 {
301 return rcv._tab.GetUint16(o + rcv._tab.Pos)
302 }
303 return 0
304 }
305
306 func (rcv *ScalarStuff) MutateJustU16(n uint16) bool {
307 return rcv._tab.MutateUint16Slot(22, n)
308 }
309
310 func (rcv *ScalarStuff) MaybeU16() *uint16 {
311 o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
312 if o != 0 {
313 v := rcv._tab.GetUint16(o + rcv._tab.Pos)
314 return &v
315 }
316 return nil
317 }
318
319 func (rcv *ScalarStuff) MutateMaybeU16(n uint16) bool {
320 return rcv._tab.MutateUint16Slot(24, n)
321 }
322
323 func (rcv *ScalarStuff) DefaultU16() uint16 {
324 o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
325 if o != 0 {
326 return rcv._tab.GetUint16(o + rcv._tab.Pos)
327 }
328 return 42
329 }
330
331 func (rcv *ScalarStuff) MutateDefaultU16(n uint16) bool {
332 return rcv._tab.MutateUint16Slot(26, n)
333 }
334
335 func (rcv *ScalarStuff) JustI32() int32 {
336 o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
337 if o != 0 {
338 return rcv._tab.GetInt32(o + rcv._tab.Pos)
339 }
340 return 0
341 }
342
343 func (rcv *ScalarStuff) MutateJustI32(n int32) bool {
344 return rcv._tab.MutateInt32Slot(28, n)
345 }
346
347 func (rcv *ScalarStuff) MaybeI32() *int32 {
348 o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
349 if o != 0 {
350 v := rcv._tab.GetInt32(o + rcv._tab.Pos)
351 return &v
352 }
353 return nil
354 }
355
356 func (rcv *ScalarStuff) MutateMaybeI32(n int32) bool {
357 return rcv._tab.MutateInt32Slot(30, n)
358 }
359
360 func (rcv *ScalarStuff) DefaultI32() int32 {
361 o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
362 if o != 0 {
363 return rcv._tab.GetInt32(o + rcv._tab.Pos)
364 }
365 return 42
366 }
367
368 func (rcv *ScalarStuff) MutateDefaultI32(n int32) bool {
369 return rcv._tab.MutateInt32Slot(32, n)
370 }
371
372 func (rcv *ScalarStuff) JustU32() uint32 {
373 o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
374 if o != 0 {
375 return rcv._tab.GetUint32(o + rcv._tab.Pos)
376 }
377 return 0
378 }
379
380 func (rcv *ScalarStuff) MutateJustU32(n uint32) bool {
381 return rcv._tab.MutateUint32Slot(34, n)
382 }
383
384 func (rcv *ScalarStuff) MaybeU32() *uint32 {
385 o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
386 if o != 0 {
387 v := rcv._tab.GetUint32(o + rcv._tab.Pos)
388 return &v
389 }
390 return nil
391 }
392
393 func (rcv *ScalarStuff) MutateMaybeU32(n uint32) bool {
394 return rcv._tab.MutateUint32Slot(36, n)
395 }
396
397 func (rcv *ScalarStuff) DefaultU32() uint32 {
398 o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
399 if o != 0 {
400 return rcv._tab.GetUint32(o + rcv._tab.Pos)
401 }
402 return 42
403 }
404
405 func (rcv *ScalarStuff) MutateDefaultU32(n uint32) bool {
406 return rcv._tab.MutateUint32Slot(38, n)
407 }
408
409 func (rcv *ScalarStuff) JustI64() int64 {
410 o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
411 if o != 0 {
412 return rcv._tab.GetInt64(o + rcv._tab.Pos)
413 }
414 return 0
415 }
416
417 func (rcv *ScalarStuff) MutateJustI64(n int64) bool {
418 return rcv._tab.MutateInt64Slot(40, n)
419 }
420
421 func (rcv *ScalarStuff) MaybeI64() *int64 {
422 o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
423 if o != 0 {
424 v := rcv._tab.GetInt64(o + rcv._tab.Pos)
425 return &v
426 }
427 return nil
428 }
429
430 func (rcv *ScalarStuff) MutateMaybeI64(n int64) bool {
431 return rcv._tab.MutateInt64Slot(42, n)
432 }
433
434 func (rcv *ScalarStuff) DefaultI64() int64 {
435 o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
436 if o != 0 {
437 return rcv._tab.GetInt64(o + rcv._tab.Pos)
438 }
439 return 42
440 }
441
442 func (rcv *ScalarStuff) MutateDefaultI64(n int64) bool {
443 return rcv._tab.MutateInt64Slot(44, n)
444 }
445
446 func (rcv *ScalarStuff) JustU64() uint64 {
447 o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
448 if o != 0 {
449 return rcv._tab.GetUint64(o + rcv._tab.Pos)
450 }
451 return 0
452 }
453
454 func (rcv *ScalarStuff) MutateJustU64(n uint64) bool {
455 return rcv._tab.MutateUint64Slot(46, n)
456 }
457
458 func (rcv *ScalarStuff) MaybeU64() *uint64 {
459 o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
460 if o != 0 {
461 v := rcv._tab.GetUint64(o + rcv._tab.Pos)
462 return &v
463 }
464 return nil
465 }
466
467 func (rcv *ScalarStuff) MutateMaybeU64(n uint64) bool {
468 return rcv._tab.MutateUint64Slot(48, n)
469 }
470
471 func (rcv *ScalarStuff) DefaultU64() uint64 {
472 o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
473 if o != 0 {
474 return rcv._tab.GetUint64(o + rcv._tab.Pos)
475 }
476 return 42
477 }
478
479 func (rcv *ScalarStuff) MutateDefaultU64(n uint64) bool {
480 return rcv._tab.MutateUint64Slot(50, n)
481 }
482
483 func (rcv *ScalarStuff) JustF32() float32 {
484 o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
485 if o != 0 {
486 return rcv._tab.GetFloat32(o + rcv._tab.Pos)
487 }
488 return 0.0
489 }
490
491 func (rcv *ScalarStuff) MutateJustF32(n float32) bool {
492 return rcv._tab.MutateFloat32Slot(52, n)
493 }
494
495 func (rcv *ScalarStuff) MaybeF32() *float32 {
496 o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
497 if o != 0 {
498 v := rcv._tab.GetFloat32(o + rcv._tab.Pos)
499 return &v
500 }
501 return nil
502 }
503
504 func (rcv *ScalarStuff) MutateMaybeF32(n float32) bool {
505 return rcv._tab.MutateFloat32Slot(54, n)
506 }
507
508 func (rcv *ScalarStuff) DefaultF32() float32 {
509 o := flatbuffers.UOffsetT(rcv._tab.Offset(56))
510 if o != 0 {
511 return rcv._tab.GetFloat32(o + rcv._tab.Pos)
512 }
513 return 42.0
514 }
515
516 func (rcv *ScalarStuff) MutateDefaultF32(n float32) bool {
517 return rcv._tab.MutateFloat32Slot(56, n)
518 }
519
520 func (rcv *ScalarStuff) JustF64() float64 {
521 o := flatbuffers.UOffsetT(rcv._tab.Offset(58))
522 if o != 0 {
523 return rcv._tab.GetFloat64(o + rcv._tab.Pos)
524 }
525 return 0.0
526 }
527
528 func (rcv *ScalarStuff) MutateJustF64(n float64) bool {
529 return rcv._tab.MutateFloat64Slot(58, n)
530 }
531
532 func (rcv *ScalarStuff) MaybeF64() *float64 {
533 o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
534 if o != 0 {
535 v := rcv._tab.GetFloat64(o + rcv._tab.Pos)
536 return &v
537 }
538 return nil
539 }
540
541 func (rcv *ScalarStuff) MutateMaybeF64(n float64) bool {
542 return rcv._tab.MutateFloat64Slot(60, n)
543 }
544
545 func (rcv *ScalarStuff) DefaultF64() float64 {
546 o := flatbuffers.UOffsetT(rcv._tab.Offset(62))
547 if o != 0 {
548 return rcv._tab.GetFloat64(o + rcv._tab.Pos)
549 }
550 return 42.0
551 }
552
553 func (rcv *ScalarStuff) MutateDefaultF64(n float64) bool {
554 return rcv._tab.MutateFloat64Slot(62, n)
555 }
556
557 func (rcv *ScalarStuff) JustBool() bool {
558 o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
559 if o != 0 {
560 return rcv._tab.GetBool(o + rcv._tab.Pos)
561 }
562 return false
563 }
564
565 func (rcv *ScalarStuff) MutateJustBool(n bool) bool {
566 return rcv._tab.MutateBoolSlot(64, n)
567 }
568
569 func (rcv *ScalarStuff) MaybeBool() *bool {
570 o := flatbuffers.UOffsetT(rcv._tab.Offset(66))
571 if o != 0 {
572 v := rcv._tab.GetBool(o + rcv._tab.Pos)
573 return &v
574 }
575 return nil
576 }
577
578 func (rcv *ScalarStuff) MutateMaybeBool(n bool) bool {
579 return rcv._tab.MutateBoolSlot(66, n)
580 }
581
582 func (rcv *ScalarStuff) DefaultBool() bool {
583 o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
584 if o != 0 {
585 return rcv._tab.GetBool(o + rcv._tab.Pos)
586 }
587 return true
588 }
589
590 func (rcv *ScalarStuff) MutateDefaultBool(n bool) bool {
591 return rcv._tab.MutateBoolSlot(68, n)
592 }
593
594 func (rcv *ScalarStuff) JustEnum() OptionalByte {
595 o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
596 if o != 0 {
597 return OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
598 }
599 return 0
600 }
601
602 func (rcv *ScalarStuff) MutateJustEnum(n OptionalByte) bool {
603 return rcv._tab.MutateInt8Slot(70, int8(n))
604 }
605
606 func (rcv *ScalarStuff) MaybeEnum() *OptionalByte {
607 o := flatbuffers.UOffsetT(rcv._tab.Offset(72))
608 if o != 0 {
609 v := OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
610 return &v
611 }
612 return nil
613 }
614
615 func (rcv *ScalarStuff) MutateMaybeEnum(n OptionalByte) bool {
616 return rcv._tab.MutateInt8Slot(72, int8(n))
617 }
618
619 func (rcv *ScalarStuff) DefaultEnum() OptionalByte {
620 o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
621 if o != 0 {
622 return OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
623 }
624 return 1
625 }
626
627 func (rcv *ScalarStuff) MutateDefaultEnum(n OptionalByte) bool {
628 return rcv._tab.MutateInt8Slot(74, int8(n))
629 }
630
631 func ScalarStuffStart(builder *flatbuffers.Builder) {
632 builder.StartObject(36)
633 }
634 func ScalarStuffAddJustI8(builder *flatbuffers.Builder, justI8 int8) {
635 builder.PrependInt8Slot(0, justI8, 0)
636 }
637 func ScalarStuffAddMaybeI8(builder *flatbuffers.Builder, maybeI8 int8) {
638 builder.PrependInt8(maybeI8)
639 builder.Slot(1)
640 }
641 func ScalarStuffAddDefaultI8(builder *flatbuffers.Builder, defaultI8 int8) {
642 builder.PrependInt8Slot(2, defaultI8, 42)
643 }
644 func ScalarStuffAddJustU8(builder *flatbuffers.Builder, justU8 byte) {
645 builder.PrependByteSlot(3, justU8, 0)
646 }
647 func ScalarStuffAddMaybeU8(builder *flatbuffers.Builder, maybeU8 byte) {
648 builder.PrependByte(maybeU8)
649 builder.Slot(4)
650 }
651 func ScalarStuffAddDefaultU8(builder *flatbuffers.Builder, defaultU8 byte) {
652 builder.PrependByteSlot(5, defaultU8, 42)
653 }
654 func ScalarStuffAddJustI16(builder *flatbuffers.Builder, justI16 int16) {
655 builder.PrependInt16Slot(6, justI16, 0)
656 }
657 func ScalarStuffAddMaybeI16(builder *flatbuffers.Builder, maybeI16 int16) {
658 builder.PrependInt16(maybeI16)
659 builder.Slot(7)
660 }
661 func ScalarStuffAddDefaultI16(builder *flatbuffers.Builder, defaultI16 int16) {
662 builder.PrependInt16Slot(8, defaultI16, 42)
663 }
664 func ScalarStuffAddJustU16(builder *flatbuffers.Builder, justU16 uint16) {
665 builder.PrependUint16Slot(9, justU16, 0)
666 }
667 func ScalarStuffAddMaybeU16(builder *flatbuffers.Builder, maybeU16 uint16) {
668 builder.PrependUint16(maybeU16)
669 builder.Slot(10)
670 }
671 func ScalarStuffAddDefaultU16(builder *flatbuffers.Builder, defaultU16 uint16) {
672 builder.PrependUint16Slot(11, defaultU16, 42)
673 }
674 func ScalarStuffAddJustI32(builder *flatbuffers.Builder, justI32 int32) {
675 builder.PrependInt32Slot(12, justI32, 0)
676 }
677 func ScalarStuffAddMaybeI32(builder *flatbuffers.Builder, maybeI32 int32) {
678 builder.PrependInt32(maybeI32)
679 builder.Slot(13)
680 }
681 func ScalarStuffAddDefaultI32(builder *flatbuffers.Builder, defaultI32 int32) {
682 builder.PrependInt32Slot(14, defaultI32, 42)
683 }
684 func ScalarStuffAddJustU32(builder *flatbuffers.Builder, justU32 uint32) {
685 builder.PrependUint32Slot(15, justU32, 0)
686 }
687 func ScalarStuffAddMaybeU32(builder *flatbuffers.Builder, maybeU32 uint32) {
688 builder.PrependUint32(maybeU32)
689 builder.Slot(16)
690 }
691 func ScalarStuffAddDefaultU32(builder *flatbuffers.Builder, defaultU32 uint32) {
692 builder.PrependUint32Slot(17, defaultU32, 42)
693 }
694 func ScalarStuffAddJustI64(builder *flatbuffers.Builder, justI64 int64) {
695 builder.PrependInt64Slot(18, justI64, 0)
696 }
697 func ScalarStuffAddMaybeI64(builder *flatbuffers.Builder, maybeI64 int64) {
698 builder.PrependInt64(maybeI64)
699 builder.Slot(19)
700 }
701 func ScalarStuffAddDefaultI64(builder *flatbuffers.Builder, defaultI64 int64) {
702 builder.PrependInt64Slot(20, defaultI64, 42)
703 }
704 func ScalarStuffAddJustU64(builder *flatbuffers.Builder, justU64 uint64) {
705 builder.PrependUint64Slot(21, justU64, 0)
706 }
707 func ScalarStuffAddMaybeU64(builder *flatbuffers.Builder, maybeU64 uint64) {
708 builder.PrependUint64(maybeU64)
709 builder.Slot(22)
710 }
711 func ScalarStuffAddDefaultU64(builder *flatbuffers.Builder, defaultU64 uint64) {
712 builder.PrependUint64Slot(23, defaultU64, 42)
713 }
714 func ScalarStuffAddJustF32(builder *flatbuffers.Builder, justF32 float32) {
715 builder.PrependFloat32Slot(24, justF32, 0.0)
716 }
717 func ScalarStuffAddMaybeF32(builder *flatbuffers.Builder, maybeF32 float32) {
718 builder.PrependFloat32(maybeF32)
719 builder.Slot(25)
720 }
721 func ScalarStuffAddDefaultF32(builder *flatbuffers.Builder, defaultF32 float32) {
722 builder.PrependFloat32Slot(26, defaultF32, 42.0)
723 }
724 func ScalarStuffAddJustF64(builder *flatbuffers.Builder, justF64 float64) {
725 builder.PrependFloat64Slot(27, justF64, 0.0)
726 }
727 func ScalarStuffAddMaybeF64(builder *flatbuffers.Builder, maybeF64 float64) {
728 builder.PrependFloat64(maybeF64)
729 builder.Slot(28)
730 }
731 func ScalarStuffAddDefaultF64(builder *flatbuffers.Builder, defaultF64 float64) {
732 builder.PrependFloat64Slot(29, defaultF64, 42.0)
733 }
734 func ScalarStuffAddJustBool(builder *flatbuffers.Builder, justBool bool) {
735 builder.PrependBoolSlot(30, justBool, false)
736 }
737 func ScalarStuffAddMaybeBool(builder *flatbuffers.Builder, maybeBool bool) {
738 builder.PrependBool(maybeBool)
739 builder.Slot(31)
740 }
741 func ScalarStuffAddDefaultBool(builder *flatbuffers.Builder, defaultBool bool) {
742 builder.PrependBoolSlot(32, defaultBool, true)
743 }
744 func ScalarStuffAddJustEnum(builder *flatbuffers.Builder, justEnum OptionalByte) {
745 builder.PrependInt8Slot(33, int8(justEnum), 0)
746 }
747 func ScalarStuffAddMaybeEnum(builder *flatbuffers.Builder, maybeEnum OptionalByte) {
748 builder.PrependInt8(int8(maybeEnum))
749 builder.Slot(34)
750 }
751 func ScalarStuffAddDefaultEnum(builder *flatbuffers.Builder, defaultEnum OptionalByte) {
752 builder.PrependInt8Slot(35, int8(defaultEnum), 1)
753 }
754 func ScalarStuffEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
755 return builder.EndObject()
756 }
757
View as plain text