1// Code generated by the FlatBuffers compiler. DO NOT EDIT. 2 3package optional_scalars 4 5import ( 6 flatbuffers "github.com/google/flatbuffers/go" 7) 8 9type 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 48func (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 114func (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 153func (rcv *ScalarStuff) UnPack() *ScalarStuffT { 154 if rcv == nil { return nil } 155 t := &ScalarStuffT{} 156 rcv.UnPackTo(t) 157 return t 158} 159 160type ScalarStuff struct { 161 _tab flatbuffers.Table 162} 163 164func 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 171func 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 178func (rcv *ScalarStuff) Init(buf []byte, i flatbuffers.UOffsetT) { 179 rcv._tab.Bytes = buf 180 rcv._tab.Pos = i 181} 182 183func (rcv *ScalarStuff) Table() flatbuffers.Table { 184 return rcv._tab 185} 186 187func (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 195func (rcv *ScalarStuff) MutateJustI8(n int8) bool { 196 return rcv._tab.MutateInt8Slot(4, n) 197} 198 199func (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 208func (rcv *ScalarStuff) MutateMaybeI8(n int8) bool { 209 return rcv._tab.MutateInt8Slot(6, n) 210} 211 212func (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 220func (rcv *ScalarStuff) MutateDefaultI8(n int8) bool { 221 return rcv._tab.MutateInt8Slot(8, n) 222} 223 224func (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 232func (rcv *ScalarStuff) MutateJustU8(n byte) bool { 233 return rcv._tab.MutateByteSlot(10, n) 234} 235 236func (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 245func (rcv *ScalarStuff) MutateMaybeU8(n byte) bool { 246 return rcv._tab.MutateByteSlot(12, n) 247} 248 249func (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 257func (rcv *ScalarStuff) MutateDefaultU8(n byte) bool { 258 return rcv._tab.MutateByteSlot(14, n) 259} 260 261func (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 269func (rcv *ScalarStuff) MutateJustI16(n int16) bool { 270 return rcv._tab.MutateInt16Slot(16, n) 271} 272 273func (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 282func (rcv *ScalarStuff) MutateMaybeI16(n int16) bool { 283 return rcv._tab.MutateInt16Slot(18, n) 284} 285 286func (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 294func (rcv *ScalarStuff) MutateDefaultI16(n int16) bool { 295 return rcv._tab.MutateInt16Slot(20, n) 296} 297 298func (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 306func (rcv *ScalarStuff) MutateJustU16(n uint16) bool { 307 return rcv._tab.MutateUint16Slot(22, n) 308} 309 310func (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 319func (rcv *ScalarStuff) MutateMaybeU16(n uint16) bool { 320 return rcv._tab.MutateUint16Slot(24, n) 321} 322 323func (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 331func (rcv *ScalarStuff) MutateDefaultU16(n uint16) bool { 332 return rcv._tab.MutateUint16Slot(26, n) 333} 334 335func (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 343func (rcv *ScalarStuff) MutateJustI32(n int32) bool { 344 return rcv._tab.MutateInt32Slot(28, n) 345} 346 347func (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 356func (rcv *ScalarStuff) MutateMaybeI32(n int32) bool { 357 return rcv._tab.MutateInt32Slot(30, n) 358} 359 360func (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 368func (rcv *ScalarStuff) MutateDefaultI32(n int32) bool { 369 return rcv._tab.MutateInt32Slot(32, n) 370} 371 372func (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 380func (rcv *ScalarStuff) MutateJustU32(n uint32) bool { 381 return rcv._tab.MutateUint32Slot(34, n) 382} 383 384func (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 393func (rcv *ScalarStuff) MutateMaybeU32(n uint32) bool { 394 return rcv._tab.MutateUint32Slot(36, n) 395} 396 397func (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 405func (rcv *ScalarStuff) MutateDefaultU32(n uint32) bool { 406 return rcv._tab.MutateUint32Slot(38, n) 407} 408 409func (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 417func (rcv *ScalarStuff) MutateJustI64(n int64) bool { 418 return rcv._tab.MutateInt64Slot(40, n) 419} 420 421func (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 430func (rcv *ScalarStuff) MutateMaybeI64(n int64) bool { 431 return rcv._tab.MutateInt64Slot(42, n) 432} 433 434func (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 442func (rcv *ScalarStuff) MutateDefaultI64(n int64) bool { 443 return rcv._tab.MutateInt64Slot(44, n) 444} 445 446func (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 454func (rcv *ScalarStuff) MutateJustU64(n uint64) bool { 455 return rcv._tab.MutateUint64Slot(46, n) 456} 457 458func (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 467func (rcv *ScalarStuff) MutateMaybeU64(n uint64) bool { 468 return rcv._tab.MutateUint64Slot(48, n) 469} 470 471func (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 479func (rcv *ScalarStuff) MutateDefaultU64(n uint64) bool { 480 return rcv._tab.MutateUint64Slot(50, n) 481} 482 483func (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 491func (rcv *ScalarStuff) MutateJustF32(n float32) bool { 492 return rcv._tab.MutateFloat32Slot(52, n) 493} 494 495func (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 504func (rcv *ScalarStuff) MutateMaybeF32(n float32) bool { 505 return rcv._tab.MutateFloat32Slot(54, n) 506} 507 508func (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 516func (rcv *ScalarStuff) MutateDefaultF32(n float32) bool { 517 return rcv._tab.MutateFloat32Slot(56, n) 518} 519 520func (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 528func (rcv *ScalarStuff) MutateJustF64(n float64) bool { 529 return rcv._tab.MutateFloat64Slot(58, n) 530} 531 532func (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 541func (rcv *ScalarStuff) MutateMaybeF64(n float64) bool { 542 return rcv._tab.MutateFloat64Slot(60, n) 543} 544 545func (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 553func (rcv *ScalarStuff) MutateDefaultF64(n float64) bool { 554 return rcv._tab.MutateFloat64Slot(62, n) 555} 556 557func (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 565func (rcv *ScalarStuff) MutateJustBool(n bool) bool { 566 return rcv._tab.MutateBoolSlot(64, n) 567} 568 569func (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 578func (rcv *ScalarStuff) MutateMaybeBool(n bool) bool { 579 return rcv._tab.MutateBoolSlot(66, n) 580} 581 582func (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 590func (rcv *ScalarStuff) MutateDefaultBool(n bool) bool { 591 return rcv._tab.MutateBoolSlot(68, n) 592} 593 594func (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 602func (rcv *ScalarStuff) MutateJustEnum(n OptionalByte) bool { 603 return rcv._tab.MutateInt8Slot(70, int8(n)) 604} 605 606func (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 615func (rcv *ScalarStuff) MutateMaybeEnum(n OptionalByte) bool { 616 return rcv._tab.MutateInt8Slot(72, int8(n)) 617} 618 619func (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 627func (rcv *ScalarStuff) MutateDefaultEnum(n OptionalByte) bool { 628 return rcv._tab.MutateInt8Slot(74, int8(n)) 629} 630 631func ScalarStuffStart(builder *flatbuffers.Builder) { 632 builder.StartObject(36) 633} 634func ScalarStuffAddJustI8(builder *flatbuffers.Builder, justI8 int8) { 635 builder.PrependInt8Slot(0, justI8, 0) 636} 637func ScalarStuffAddMaybeI8(builder *flatbuffers.Builder, maybeI8 int8) { 638 builder.PrependInt8(maybeI8) 639 builder.Slot(1) 640} 641func ScalarStuffAddDefaultI8(builder *flatbuffers.Builder, defaultI8 int8) { 642 builder.PrependInt8Slot(2, defaultI8, 42) 643} 644func ScalarStuffAddJustU8(builder *flatbuffers.Builder, justU8 byte) { 645 builder.PrependByteSlot(3, justU8, 0) 646} 647func ScalarStuffAddMaybeU8(builder *flatbuffers.Builder, maybeU8 byte) { 648 builder.PrependByte(maybeU8) 649 builder.Slot(4) 650} 651func ScalarStuffAddDefaultU8(builder *flatbuffers.Builder, defaultU8 byte) { 652 builder.PrependByteSlot(5, defaultU8, 42) 653} 654func ScalarStuffAddJustI16(builder *flatbuffers.Builder, justI16 int16) { 655 builder.PrependInt16Slot(6, justI16, 0) 656} 657func ScalarStuffAddMaybeI16(builder *flatbuffers.Builder, maybeI16 int16) { 658 builder.PrependInt16(maybeI16) 659 builder.Slot(7) 660} 661func ScalarStuffAddDefaultI16(builder *flatbuffers.Builder, defaultI16 int16) { 662 builder.PrependInt16Slot(8, defaultI16, 42) 663} 664func ScalarStuffAddJustU16(builder *flatbuffers.Builder, justU16 uint16) { 665 builder.PrependUint16Slot(9, justU16, 0) 666} 667func ScalarStuffAddMaybeU16(builder *flatbuffers.Builder, maybeU16 uint16) { 668 builder.PrependUint16(maybeU16) 669 builder.Slot(10) 670} 671func ScalarStuffAddDefaultU16(builder *flatbuffers.Builder, defaultU16 uint16) { 672 builder.PrependUint16Slot(11, defaultU16, 42) 673} 674func ScalarStuffAddJustI32(builder *flatbuffers.Builder, justI32 int32) { 675 builder.PrependInt32Slot(12, justI32, 0) 676} 677func ScalarStuffAddMaybeI32(builder *flatbuffers.Builder, maybeI32 int32) { 678 builder.PrependInt32(maybeI32) 679 builder.Slot(13) 680} 681func ScalarStuffAddDefaultI32(builder *flatbuffers.Builder, defaultI32 int32) { 682 builder.PrependInt32Slot(14, defaultI32, 42) 683} 684func ScalarStuffAddJustU32(builder *flatbuffers.Builder, justU32 uint32) { 685 builder.PrependUint32Slot(15, justU32, 0) 686} 687func ScalarStuffAddMaybeU32(builder *flatbuffers.Builder, maybeU32 uint32) { 688 builder.PrependUint32(maybeU32) 689 builder.Slot(16) 690} 691func ScalarStuffAddDefaultU32(builder *flatbuffers.Builder, defaultU32 uint32) { 692 builder.PrependUint32Slot(17, defaultU32, 42) 693} 694func ScalarStuffAddJustI64(builder *flatbuffers.Builder, justI64 int64) { 695 builder.PrependInt64Slot(18, justI64, 0) 696} 697func ScalarStuffAddMaybeI64(builder *flatbuffers.Builder, maybeI64 int64) { 698 builder.PrependInt64(maybeI64) 699 builder.Slot(19) 700} 701func ScalarStuffAddDefaultI64(builder *flatbuffers.Builder, defaultI64 int64) { 702 builder.PrependInt64Slot(20, defaultI64, 42) 703} 704func ScalarStuffAddJustU64(builder *flatbuffers.Builder, justU64 uint64) { 705 builder.PrependUint64Slot(21, justU64, 0) 706} 707func ScalarStuffAddMaybeU64(builder *flatbuffers.Builder, maybeU64 uint64) { 708 builder.PrependUint64(maybeU64) 709 builder.Slot(22) 710} 711func ScalarStuffAddDefaultU64(builder *flatbuffers.Builder, defaultU64 uint64) { 712 builder.PrependUint64Slot(23, defaultU64, 42) 713} 714func ScalarStuffAddJustF32(builder *flatbuffers.Builder, justF32 float32) { 715 builder.PrependFloat32Slot(24, justF32, 0.0) 716} 717func ScalarStuffAddMaybeF32(builder *flatbuffers.Builder, maybeF32 float32) { 718 builder.PrependFloat32(maybeF32) 719 builder.Slot(25) 720} 721func ScalarStuffAddDefaultF32(builder *flatbuffers.Builder, defaultF32 float32) { 722 builder.PrependFloat32Slot(26, defaultF32, 42.0) 723} 724func ScalarStuffAddJustF64(builder *flatbuffers.Builder, justF64 float64) { 725 builder.PrependFloat64Slot(27, justF64, 0.0) 726} 727func ScalarStuffAddMaybeF64(builder *flatbuffers.Builder, maybeF64 float64) { 728 builder.PrependFloat64(maybeF64) 729 builder.Slot(28) 730} 731func ScalarStuffAddDefaultF64(builder *flatbuffers.Builder, defaultF64 float64) { 732 builder.PrependFloat64Slot(29, defaultF64, 42.0) 733} 734func ScalarStuffAddJustBool(builder *flatbuffers.Builder, justBool bool) { 735 builder.PrependBoolSlot(30, justBool, false) 736} 737func ScalarStuffAddMaybeBool(builder *flatbuffers.Builder, maybeBool bool) { 738 builder.PrependBool(maybeBool) 739 builder.Slot(31) 740} 741func ScalarStuffAddDefaultBool(builder *flatbuffers.Builder, defaultBool bool) { 742 builder.PrependBoolSlot(32, defaultBool, true) 743} 744func ScalarStuffAddJustEnum(builder *flatbuffers.Builder, justEnum OptionalByte) { 745 builder.PrependInt8Slot(33, int8(justEnum), 0) 746} 747func ScalarStuffAddMaybeEnum(builder *flatbuffers.Builder, maybeEnum OptionalByte) { 748 builder.PrependInt8(int8(maybeEnum)) 749 builder.Slot(34) 750} 751func ScalarStuffAddDefaultEnum(builder *flatbuffers.Builder, defaultEnum OptionalByte) { 752 builder.PrependInt8Slot(35, int8(defaultEnum), 1) 753} 754func ScalarStuffEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { 755 return builder.EndObject() 756} 757