Home | History | Annotate | Download | only in Example 
      1 // Code generated by the FlatBuffers compiler. DO NOT EDIT.
      2 
      3 package Example
      4 
      5 import (
      6 	flatbuffers "github.com/google/flatbuffers/go"
      7 
      8 	MyGame "MyGame"
      9 )
     10 
     11 /// an example documentation comment: monster object
     12 type Monster struct {
     13 	_tab flatbuffers.Table
     14 }
     15 
     16 func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
     17 	n := flatbuffers.GetUOffsetT(buf[offset:])
     18 	x := &Monster{}
     19 	x.Init(buf, n+offset)
     20 	return x
     21 }
     22 
     23 func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) {
     24 	rcv._tab.Bytes = buf
     25 	rcv._tab.Pos = i
     26 }
     27 
     28 func (rcv *Monster) Table() flatbuffers.Table {
     29 	return rcv._tab
     30 }
     31 
     32 func (rcv *Monster) Pos(obj *Vec3) *Vec3 {
     33 	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
     34 	if o != 0 {
     35 		x := o + rcv._tab.Pos
     36 		if obj == nil {
     37 			obj = new(Vec3)
     38 		}
     39 		obj.Init(rcv._tab.Bytes, x)
     40 		return obj
     41 	}
     42 	return nil
     43 }
     44 
     45 func (rcv *Monster) Mana() int16 {
     46 	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
     47 	if o != 0 {
     48 		return rcv._tab.GetInt16(o + rcv._tab.Pos)
     49 	}
     50 	return 150
     51 }
     52 
     53 func (rcv *Monster) MutateMana(n int16) bool {
     54 	return rcv._tab.MutateInt16Slot(6, n)
     55 }
     56 
     57 func (rcv *Monster) Hp() int16 {
     58 	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
     59 	if o != 0 {
     60 		return rcv._tab.GetInt16(o + rcv._tab.Pos)
     61 	}
     62 	return 100
     63 }
     64 
     65 func (rcv *Monster) MutateHp(n int16) bool {
     66 	return rcv._tab.MutateInt16Slot(8, n)
     67 }
     68 
     69 func (rcv *Monster) Name() []byte {
     70 	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
     71 	if o != 0 {
     72 		return rcv._tab.ByteVector(o + rcv._tab.Pos)
     73 	}
     74 	return nil
     75 }
     76 
     77 func (rcv *Monster) Inventory(j int) byte {
     78 	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
     79 	if o != 0 {
     80 		a := rcv._tab.Vector(o)
     81 		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
     82 	}
     83 	return 0
     84 }
     85 
     86 func (rcv *Monster) InventoryLength() int {
     87 	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
     88 	if o != 0 {
     89 		return rcv._tab.VectorLen(o)
     90 	}
     91 	return 0
     92 }
     93 
     94 func (rcv *Monster) InventoryBytes() []byte {
     95 	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
     96 	if o != 0 {
     97 		return rcv._tab.ByteVector(o + rcv._tab.Pos)
     98 	}
     99 	return nil
    100 }
    101 
    102 func (rcv *Monster) Color() Color {
    103 	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
    104 	if o != 0 {
    105 		return rcv._tab.GetInt8(o + rcv._tab.Pos)
    106 	}
    107 	return 8
    108 }
    109 
    110 func (rcv *Monster) MutateColor(n Color) bool {
    111 	return rcv._tab.MutateInt8Slot(16, n)
    112 }
    113 
    114 func (rcv *Monster) TestType() byte {
    115 	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
    116 	if o != 0 {
    117 		return rcv._tab.GetByte(o + rcv._tab.Pos)
    118 	}
    119 	return 0
    120 }
    121 
    122 func (rcv *Monster) MutateTestType(n byte) bool {
    123 	return rcv._tab.MutateByteSlot(18, n)
    124 }
    125 
    126 func (rcv *Monster) Test(obj *flatbuffers.Table) bool {
    127 	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
    128 	if o != 0 {
    129 		rcv._tab.Union(obj, o)
    130 		return true
    131 	}
    132 	return false
    133 }
    134 
    135 func (rcv *Monster) Test4(obj *Test, j int) bool {
    136 	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
    137 	if o != 0 {
    138 		x := rcv._tab.Vector(o)
    139 		x += flatbuffers.UOffsetT(j) * 4
    140 		obj.Init(rcv._tab.Bytes, x)
    141 		return true
    142 	}
    143 	return false
    144 }
    145 
    146 func (rcv *Monster) Test4Length() int {
    147 	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
    148 	if o != 0 {
    149 		return rcv._tab.VectorLen(o)
    150 	}
    151 	return 0
    152 }
    153 
    154 func (rcv *Monster) Testarrayofstring(j int) []byte {
    155 	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
    156 	if o != 0 {
    157 		a := rcv._tab.Vector(o)
    158 		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
    159 	}
    160 	return nil
    161 }
    162 
    163 func (rcv *Monster) TestarrayofstringLength() int {
    164 	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
    165 	if o != 0 {
    166 		return rcv._tab.VectorLen(o)
    167 	}
    168 	return 0
    169 }
    170 
    171 /// an example documentation comment: this will end up in the generated code
    172 /// multiline too
    173 func (rcv *Monster) Testarrayoftables(obj *Monster, j int) bool {
    174 	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
    175 	if o != 0 {
    176 		x := rcv._tab.Vector(o)
    177 		x += flatbuffers.UOffsetT(j) * 4
    178 		x = rcv._tab.Indirect(x)
    179 		obj.Init(rcv._tab.Bytes, x)
    180 		return true
    181 	}
    182 	return false
    183 }
    184 
    185 func (rcv *Monster) TestarrayoftablesLength() int {
    186 	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
    187 	if o != 0 {
    188 		return rcv._tab.VectorLen(o)
    189 	}
    190 	return 0
    191 }
    192 
    193 /// an example documentation comment: this will end up in the generated code
    194 /// multiline too
    195 func (rcv *Monster) Enemy(obj *Monster) *Monster {
    196 	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
    197 	if o != 0 {
    198 		x := rcv._tab.Indirect(o + rcv._tab.Pos)
    199 		if obj == nil {
    200 			obj = new(Monster)
    201 		}
    202 		obj.Init(rcv._tab.Bytes, x)
    203 		return obj
    204 	}
    205 	return nil
    206 }
    207 
    208 func (rcv *Monster) Testnestedflatbuffer(j int) byte {
    209 	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
    210 	if o != 0 {
    211 		a := rcv._tab.Vector(o)
    212 		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
    213 	}
    214 	return 0
    215 }
    216 
    217 func (rcv *Monster) TestnestedflatbufferLength() int {
    218 	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
    219 	if o != 0 {
    220 		return rcv._tab.VectorLen(o)
    221 	}
    222 	return 0
    223 }
    224 
    225 func (rcv *Monster) TestnestedflatbufferBytes() []byte {
    226 	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
    227 	if o != 0 {
    228 		return rcv._tab.ByteVector(o + rcv._tab.Pos)
    229 	}
    230 	return nil
    231 }
    232 
    233 func (rcv *Monster) Testempty(obj *Stat) *Stat {
    234 	o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
    235 	if o != 0 {
    236 		x := rcv._tab.Indirect(o + rcv._tab.Pos)
    237 		if obj == nil {
    238 			obj = new(Stat)
    239 		}
    240 		obj.Init(rcv._tab.Bytes, x)
    241 		return obj
    242 	}
    243 	return nil
    244 }
    245 
    246 func (rcv *Monster) Testbool() bool {
    247 	o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
    248 	if o != 0 {
    249 		return rcv._tab.GetBool(o + rcv._tab.Pos)
    250 	}
    251 	return false
    252 }
    253 
    254 func (rcv *Monster) MutateTestbool(n bool) bool {
    255 	return rcv._tab.MutateBoolSlot(34, n)
    256 }
    257 
    258 func (rcv *Monster) Testhashs32Fnv1() int32 {
    259 	o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
    260 	if o != 0 {
    261 		return rcv._tab.GetInt32(o + rcv._tab.Pos)
    262 	}
    263 	return 0
    264 }
    265 
    266 func (rcv *Monster) MutateTesthashs32Fnv1(n int32) bool {
    267 	return rcv._tab.MutateInt32Slot(36, n)
    268 }
    269 
    270 func (rcv *Monster) Testhashu32Fnv1() uint32 {
    271 	o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
    272 	if o != 0 {
    273 		return rcv._tab.GetUint32(o + rcv._tab.Pos)
    274 	}
    275 	return 0
    276 }
    277 
    278 func (rcv *Monster) MutateTesthashu32Fnv1(n uint32) bool {
    279 	return rcv._tab.MutateUint32Slot(38, n)
    280 }
    281 
    282 func (rcv *Monster) Testhashs64Fnv1() int64 {
    283 	o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
    284 	if o != 0 {
    285 		return rcv._tab.GetInt64(o + rcv._tab.Pos)
    286 	}
    287 	return 0
    288 }
    289 
    290 func (rcv *Monster) MutateTesthashs64Fnv1(n int64) bool {
    291 	return rcv._tab.MutateInt64Slot(40, n)
    292 }
    293 
    294 func (rcv *Monster) Testhashu64Fnv1() uint64 {
    295 	o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
    296 	if o != 0 {
    297 		return rcv._tab.GetUint64(o + rcv._tab.Pos)
    298 	}
    299 	return 0
    300 }
    301 
    302 func (rcv *Monster) MutateTesthashu64Fnv1(n uint64) bool {
    303 	return rcv._tab.MutateUint64Slot(42, n)
    304 }
    305 
    306 func (rcv *Monster) Testhashs32Fnv1a() int32 {
    307 	o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
    308 	if o != 0 {
    309 		return rcv._tab.GetInt32(o + rcv._tab.Pos)
    310 	}
    311 	return 0
    312 }
    313 
    314 func (rcv *Monster) MutateTesthashs32Fnv1a(n int32) bool {
    315 	return rcv._tab.MutateInt32Slot(44, n)
    316 }
    317 
    318 func (rcv *Monster) Testhashu32Fnv1a() uint32 {
    319 	o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
    320 	if o != 0 {
    321 		return rcv._tab.GetUint32(o + rcv._tab.Pos)
    322 	}
    323 	return 0
    324 }
    325 
    326 func (rcv *Monster) MutateTesthashu32Fnv1a(n uint32) bool {
    327 	return rcv._tab.MutateUint32Slot(46, n)
    328 }
    329 
    330 func (rcv *Monster) Testhashs64Fnv1a() int64 {
    331 	o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
    332 	if o != 0 {
    333 		return rcv._tab.GetInt64(o + rcv._tab.Pos)
    334 	}
    335 	return 0
    336 }
    337 
    338 func (rcv *Monster) MutateTesthashs64Fnv1a(n int64) bool {
    339 	return rcv._tab.MutateInt64Slot(48, n)
    340 }
    341 
    342 func (rcv *Monster) Testhashu64Fnv1a() uint64 {
    343 	o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
    344 	if o != 0 {
    345 		return rcv._tab.GetUint64(o + rcv._tab.Pos)
    346 	}
    347 	return 0
    348 }
    349 
    350 func (rcv *Monster) MutateTesthashu64Fnv1a(n uint64) bool {
    351 	return rcv._tab.MutateUint64Slot(50, n)
    352 }
    353 
    354 func (rcv *Monster) Testarrayofbools(j int) bool {
    355 	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
    356 	if o != 0 {
    357 		a := rcv._tab.Vector(o)
    358 		return rcv._tab.GetBool(a + flatbuffers.UOffsetT(j*1))
    359 	}
    360 	return false
    361 }
    362 
    363 func (rcv *Monster) TestarrayofboolsLength() int {
    364 	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
    365 	if o != 0 {
    366 		return rcv._tab.VectorLen(o)
    367 	}
    368 	return 0
    369 }
    370 
    371 func (rcv *Monster) Testf() float32 {
    372 	o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
    373 	if o != 0 {
    374 		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
    375 	}
    376 	return 3.14159
    377 }
    378 
    379 func (rcv *Monster) MutateTestf(n float32) bool {
    380 	return rcv._tab.MutateFloat32Slot(54, n)
    381 }
    382 
    383 func (rcv *Monster) Testf2() float32 {
    384 	o := flatbuffers.UOffsetT(rcv._tab.Offset(56))
    385 	if o != 0 {
    386 		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
    387 	}
    388 	return 3.0
    389 }
    390 
    391 func (rcv *Monster) MutateTestf2(n float32) bool {
    392 	return rcv._tab.MutateFloat32Slot(56, n)
    393 }
    394 
    395 func (rcv *Monster) Testf3() float32 {
    396 	o := flatbuffers.UOffsetT(rcv._tab.Offset(58))
    397 	if o != 0 {
    398 		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
    399 	}
    400 	return 0.0
    401 }
    402 
    403 func (rcv *Monster) MutateTestf3(n float32) bool {
    404 	return rcv._tab.MutateFloat32Slot(58, n)
    405 }
    406 
    407 func (rcv *Monster) Testarrayofstring2(j int) []byte {
    408 	o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
    409 	if o != 0 {
    410 		a := rcv._tab.Vector(o)
    411 		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
    412 	}
    413 	return nil
    414 }
    415 
    416 func (rcv *Monster) Testarrayofstring2Length() int {
    417 	o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
    418 	if o != 0 {
    419 		return rcv._tab.VectorLen(o)
    420 	}
    421 	return 0
    422 }
    423 
    424 func (rcv *Monster) Testarrayofsortedstruct(obj *Ability, j int) bool {
    425 	o := flatbuffers.UOffsetT(rcv._tab.Offset(62))
    426 	if o != 0 {
    427 		x := rcv._tab.Vector(o)
    428 		x += flatbuffers.UOffsetT(j) * 8
    429 		obj.Init(rcv._tab.Bytes, x)
    430 		return true
    431 	}
    432 	return false
    433 }
    434 
    435 func (rcv *Monster) TestarrayofsortedstructLength() int {
    436 	o := flatbuffers.UOffsetT(rcv._tab.Offset(62))
    437 	if o != 0 {
    438 		return rcv._tab.VectorLen(o)
    439 	}
    440 	return 0
    441 }
    442 
    443 func (rcv *Monster) Flex(j int) byte {
    444 	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
    445 	if o != 0 {
    446 		a := rcv._tab.Vector(o)
    447 		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
    448 	}
    449 	return 0
    450 }
    451 
    452 func (rcv *Monster) FlexLength() int {
    453 	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
    454 	if o != 0 {
    455 		return rcv._tab.VectorLen(o)
    456 	}
    457 	return 0
    458 }
    459 
    460 func (rcv *Monster) FlexBytes() []byte {
    461 	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
    462 	if o != 0 {
    463 		return rcv._tab.ByteVector(o + rcv._tab.Pos)
    464 	}
    465 	return nil
    466 }
    467 
    468 func (rcv *Monster) Test5(obj *Test, j int) bool {
    469 	o := flatbuffers.UOffsetT(rcv._tab.Offset(66))
    470 	if o != 0 {
    471 		x := rcv._tab.Vector(o)
    472 		x += flatbuffers.UOffsetT(j) * 4
    473 		obj.Init(rcv._tab.Bytes, x)
    474 		return true
    475 	}
    476 	return false
    477 }
    478 
    479 func (rcv *Monster) Test5Length() int {
    480 	o := flatbuffers.UOffsetT(rcv._tab.Offset(66))
    481 	if o != 0 {
    482 		return rcv._tab.VectorLen(o)
    483 	}
    484 	return 0
    485 }
    486 
    487 func (rcv *Monster) VectorOfLongs(j int) int64 {
    488 	o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
    489 	if o != 0 {
    490 		a := rcv._tab.Vector(o)
    491 		return rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8))
    492 	}
    493 	return 0
    494 }
    495 
    496 func (rcv *Monster) VectorOfLongsLength() int {
    497 	o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
    498 	if o != 0 {
    499 		return rcv._tab.VectorLen(o)
    500 	}
    501 	return 0
    502 }
    503 
    504 func (rcv *Monster) VectorOfDoubles(j int) float64 {
    505 	o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
    506 	if o != 0 {
    507 		a := rcv._tab.Vector(o)
    508 		return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8))
    509 	}
    510 	return 0
    511 }
    512 
    513 func (rcv *Monster) VectorOfDoublesLength() int {
    514 	o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
    515 	if o != 0 {
    516 		return rcv._tab.VectorLen(o)
    517 	}
    518 	return 0
    519 }
    520 
    521 func (rcv *Monster) ParentNamespaceTest(obj *MyGame.InParentNamespace) *MyGame.InParentNamespace {
    522 	o := flatbuffers.UOffsetT(rcv._tab.Offset(72))
    523 	if o != 0 {
    524 		x := rcv._tab.Indirect(o + rcv._tab.Pos)
    525 		if obj == nil {
    526 			obj = new(MyGame.InParentNamespace)
    527 		}
    528 		obj.Init(rcv._tab.Bytes, x)
    529 		return obj
    530 	}
    531 	return nil
    532 }
    533 
    534 func (rcv *Monster) VectorOfReferrables(obj *Referrable, j int) bool {
    535 	o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
    536 	if o != 0 {
    537 		x := rcv._tab.Vector(o)
    538 		x += flatbuffers.UOffsetT(j) * 4
    539 		x = rcv._tab.Indirect(x)
    540 		obj.Init(rcv._tab.Bytes, x)
    541 		return true
    542 	}
    543 	return false
    544 }
    545 
    546 func (rcv *Monster) VectorOfReferrablesLength() int {
    547 	o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
    548 	if o != 0 {
    549 		return rcv._tab.VectorLen(o)
    550 	}
    551 	return 0
    552 }
    553 
    554 func (rcv *Monster) SingleWeakReference() uint64 {
    555 	o := flatbuffers.UOffsetT(rcv._tab.Offset(76))
    556 	if o != 0 {
    557 		return rcv._tab.GetUint64(o + rcv._tab.Pos)
    558 	}
    559 	return 0
    560 }
    561 
    562 func (rcv *Monster) MutateSingleWeakReference(n uint64) bool {
    563 	return rcv._tab.MutateUint64Slot(76, n)
    564 }
    565 
    566 func (rcv *Monster) VectorOfWeakReferences(j int) uint64 {
    567 	o := flatbuffers.UOffsetT(rcv._tab.Offset(78))
    568 	if o != 0 {
    569 		a := rcv._tab.Vector(o)
    570 		return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
    571 	}
    572 	return 0
    573 }
    574 
    575 func (rcv *Monster) VectorOfWeakReferencesLength() int {
    576 	o := flatbuffers.UOffsetT(rcv._tab.Offset(78))
    577 	if o != 0 {
    578 		return rcv._tab.VectorLen(o)
    579 	}
    580 	return 0
    581 }
    582 
    583 func (rcv *Monster) VectorOfStrongReferrables(obj *Referrable, j int) bool {
    584 	o := flatbuffers.UOffsetT(rcv._tab.Offset(80))
    585 	if o != 0 {
    586 		x := rcv._tab.Vector(o)
    587 		x += flatbuffers.UOffsetT(j) * 4
    588 		x = rcv._tab.Indirect(x)
    589 		obj.Init(rcv._tab.Bytes, x)
    590 		return true
    591 	}
    592 	return false
    593 }
    594 
    595 func (rcv *Monster) VectorOfStrongReferrablesLength() int {
    596 	o := flatbuffers.UOffsetT(rcv._tab.Offset(80))
    597 	if o != 0 {
    598 		return rcv._tab.VectorLen(o)
    599 	}
    600 	return 0
    601 }
    602 
    603 func (rcv *Monster) CoOwningReference() uint64 {
    604 	o := flatbuffers.UOffsetT(rcv._tab.Offset(82))
    605 	if o != 0 {
    606 		return rcv._tab.GetUint64(o + rcv._tab.Pos)
    607 	}
    608 	return 0
    609 }
    610 
    611 func (rcv *Monster) MutateCoOwningReference(n uint64) bool {
    612 	return rcv._tab.MutateUint64Slot(82, n)
    613 }
    614 
    615 func (rcv *Monster) VectorOfCoOwningReferences(j int) uint64 {
    616 	o := flatbuffers.UOffsetT(rcv._tab.Offset(84))
    617 	if o != 0 {
    618 		a := rcv._tab.Vector(o)
    619 		return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
    620 	}
    621 	return 0
    622 }
    623 
    624 func (rcv *Monster) VectorOfCoOwningReferencesLength() int {
    625 	o := flatbuffers.UOffsetT(rcv._tab.Offset(84))
    626 	if o != 0 {
    627 		return rcv._tab.VectorLen(o)
    628 	}
    629 	return 0
    630 }
    631 
    632 func (rcv *Monster) NonOwningReference() uint64 {
    633 	o := flatbuffers.UOffsetT(rcv._tab.Offset(86))
    634 	if o != 0 {
    635 		return rcv._tab.GetUint64(o + rcv._tab.Pos)
    636 	}
    637 	return 0
    638 }
    639 
    640 func (rcv *Monster) MutateNonOwningReference(n uint64) bool {
    641 	return rcv._tab.MutateUint64Slot(86, n)
    642 }
    643 
    644 func (rcv *Monster) VectorOfNonOwningReferences(j int) uint64 {
    645 	o := flatbuffers.UOffsetT(rcv._tab.Offset(88))
    646 	if o != 0 {
    647 		a := rcv._tab.Vector(o)
    648 		return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
    649 	}
    650 	return 0
    651 }
    652 
    653 func (rcv *Monster) VectorOfNonOwningReferencesLength() int {
    654 	o := flatbuffers.UOffsetT(rcv._tab.Offset(88))
    655 	if o != 0 {
    656 		return rcv._tab.VectorLen(o)
    657 	}
    658 	return 0
    659 }
    660 
    661 func (rcv *Monster) AnyUniqueType() byte {
    662 	o := flatbuffers.UOffsetT(rcv._tab.Offset(90))
    663 	if o != 0 {
    664 		return rcv._tab.GetByte(o + rcv._tab.Pos)
    665 	}
    666 	return 0
    667 }
    668 
    669 func (rcv *Monster) MutateAnyUniqueType(n byte) bool {
    670 	return rcv._tab.MutateByteSlot(90, n)
    671 }
    672 
    673 func (rcv *Monster) AnyUnique(obj *flatbuffers.Table) bool {
    674 	o := flatbuffers.UOffsetT(rcv._tab.Offset(92))
    675 	if o != 0 {
    676 		rcv._tab.Union(obj, o)
    677 		return true
    678 	}
    679 	return false
    680 }
    681 
    682 func (rcv *Monster) AnyAmbiguousType() byte {
    683 	o := flatbuffers.UOffsetT(rcv._tab.Offset(94))
    684 	if o != 0 {
    685 		return rcv._tab.GetByte(o + rcv._tab.Pos)
    686 	}
    687 	return 0
    688 }
    689 
    690 func (rcv *Monster) MutateAnyAmbiguousType(n byte) bool {
    691 	return rcv._tab.MutateByteSlot(94, n)
    692 }
    693 
    694 func (rcv *Monster) AnyAmbiguous(obj *flatbuffers.Table) bool {
    695 	o := flatbuffers.UOffsetT(rcv._tab.Offset(96))
    696 	if o != 0 {
    697 		rcv._tab.Union(obj, o)
    698 		return true
    699 	}
    700 	return false
    701 }
    702 
    703 func (rcv *Monster) VectorOfEnums(j int) Color {
    704 	o := flatbuffers.UOffsetT(rcv._tab.Offset(98))
    705 	if o != 0 {
    706 		a := rcv._tab.Vector(o)
    707 		return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))
    708 	}
    709 	return 0
    710 }
    711 
    712 func (rcv *Monster) VectorOfEnumsLength() int {
    713 	o := flatbuffers.UOffsetT(rcv._tab.Offset(98))
    714 	if o != 0 {
    715 		return rcv._tab.VectorLen(o)
    716 	}
    717 	return 0
    718 }
    719 
    720 func MonsterStart(builder *flatbuffers.Builder) {
    721 	builder.StartObject(48)
    722 }
    723 func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
    724 	builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
    725 }
    726 func MonsterAddMana(builder *flatbuffers.Builder, mana int16) {
    727 	builder.PrependInt16Slot(1, mana, 150)
    728 }
    729 func MonsterAddHp(builder *flatbuffers.Builder, hp int16) {
    730 	builder.PrependInt16Slot(2, hp, 100)
    731 }
    732 func MonsterAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
    733 	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(name), 0)
    734 }
    735 func MonsterAddInventory(builder *flatbuffers.Builder, inventory flatbuffers.UOffsetT) {
    736 	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(inventory), 0)
    737 }
    738 func MonsterStartInventoryVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    739 	return builder.StartVector(1, numElems, 1)
    740 }
    741 func MonsterAddColor(builder *flatbuffers.Builder, color int8) {
    742 	builder.PrependInt8Slot(6, color, 8)
    743 }
    744 func MonsterAddTestType(builder *flatbuffers.Builder, testType byte) {
    745 	builder.PrependByteSlot(7, testType, 0)
    746 }
    747 func MonsterAddTest(builder *flatbuffers.Builder, test flatbuffers.UOffsetT) {
    748 	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(test), 0)
    749 }
    750 func MonsterAddTest4(builder *flatbuffers.Builder, test4 flatbuffers.UOffsetT) {
    751 	builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(test4), 0)
    752 }
    753 func MonsterStartTest4Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    754 	return builder.StartVector(4, numElems, 2)
    755 }
    756 func MonsterAddTestarrayofstring(builder *flatbuffers.Builder, testarrayofstring flatbuffers.UOffsetT) {
    757 	builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(testarrayofstring), 0)
    758 }
    759 func MonsterStartTestarrayofstringVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    760 	return builder.StartVector(4, numElems, 4)
    761 }
    762 func MonsterAddTestarrayoftables(builder *flatbuffers.Builder, testarrayoftables flatbuffers.UOffsetT) {
    763 	builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(testarrayoftables), 0)
    764 }
    765 func MonsterStartTestarrayoftablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    766 	return builder.StartVector(4, numElems, 4)
    767 }
    768 func MonsterAddEnemy(builder *flatbuffers.Builder, enemy flatbuffers.UOffsetT) {
    769 	builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(enemy), 0)
    770 }
    771 func MonsterAddTestnestedflatbuffer(builder *flatbuffers.Builder, testnestedflatbuffer flatbuffers.UOffsetT) {
    772 	builder.PrependUOffsetTSlot(13, flatbuffers.UOffsetT(testnestedflatbuffer), 0)
    773 }
    774 func MonsterStartTestnestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    775 	return builder.StartVector(1, numElems, 1)
    776 }
    777 func MonsterAddTestempty(builder *flatbuffers.Builder, testempty flatbuffers.UOffsetT) {
    778 	builder.PrependUOffsetTSlot(14, flatbuffers.UOffsetT(testempty), 0)
    779 }
    780 func MonsterAddTestbool(builder *flatbuffers.Builder, testbool bool) {
    781 	builder.PrependBoolSlot(15, testbool, false)
    782 }
    783 func MonsterAddTesthashs32Fnv1(builder *flatbuffers.Builder, testhashs32Fnv1 int32) {
    784 	builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
    785 }
    786 func MonsterAddTesthashu32Fnv1(builder *flatbuffers.Builder, testhashu32Fnv1 uint32) {
    787 	builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
    788 }
    789 func MonsterAddTesthashs64Fnv1(builder *flatbuffers.Builder, testhashs64Fnv1 int64) {
    790 	builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
    791 }
    792 func MonsterAddTesthashu64Fnv1(builder *flatbuffers.Builder, testhashu64Fnv1 uint64) {
    793 	builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
    794 }
    795 func MonsterAddTesthashs32Fnv1a(builder *flatbuffers.Builder, testhashs32Fnv1a int32) {
    796 	builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
    797 }
    798 func MonsterAddTesthashu32Fnv1a(builder *flatbuffers.Builder, testhashu32Fnv1a uint32) {
    799 	builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
    800 }
    801 func MonsterAddTesthashs64Fnv1a(builder *flatbuffers.Builder, testhashs64Fnv1a int64) {
    802 	builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
    803 }
    804 func MonsterAddTesthashu64Fnv1a(builder *flatbuffers.Builder, testhashu64Fnv1a uint64) {
    805 	builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
    806 }
    807 func MonsterAddTestarrayofbools(builder *flatbuffers.Builder, testarrayofbools flatbuffers.UOffsetT) {
    808 	builder.PrependUOffsetTSlot(24, flatbuffers.UOffsetT(testarrayofbools), 0)
    809 }
    810 func MonsterStartTestarrayofboolsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    811 	return builder.StartVector(1, numElems, 1)
    812 }
    813 func MonsterAddTestf(builder *flatbuffers.Builder, testf float32) {
    814 	builder.PrependFloat32Slot(25, testf, 3.14159)
    815 }
    816 func MonsterAddTestf2(builder *flatbuffers.Builder, testf2 float32) {
    817 	builder.PrependFloat32Slot(26, testf2, 3.0)
    818 }
    819 func MonsterAddTestf3(builder *flatbuffers.Builder, testf3 float32) {
    820 	builder.PrependFloat32Slot(27, testf3, 0.0)
    821 }
    822 func MonsterAddTestarrayofstring2(builder *flatbuffers.Builder, testarrayofstring2 flatbuffers.UOffsetT) {
    823 	builder.PrependUOffsetTSlot(28, flatbuffers.UOffsetT(testarrayofstring2), 0)
    824 }
    825 func MonsterStartTestarrayofstring2Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    826 	return builder.StartVector(4, numElems, 4)
    827 }
    828 func MonsterAddTestarrayofsortedstruct(builder *flatbuffers.Builder, testarrayofsortedstruct flatbuffers.UOffsetT) {
    829 	builder.PrependUOffsetTSlot(29, flatbuffers.UOffsetT(testarrayofsortedstruct), 0)
    830 }
    831 func MonsterStartTestarrayofsortedstructVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    832 	return builder.StartVector(8, numElems, 4)
    833 }
    834 func MonsterAddFlex(builder *flatbuffers.Builder, flex flatbuffers.UOffsetT) {
    835 	builder.PrependUOffsetTSlot(30, flatbuffers.UOffsetT(flex), 0)
    836 }
    837 func MonsterStartFlexVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    838 	return builder.StartVector(1, numElems, 1)
    839 }
    840 func MonsterAddTest5(builder *flatbuffers.Builder, test5 flatbuffers.UOffsetT) {
    841 	builder.PrependUOffsetTSlot(31, flatbuffers.UOffsetT(test5), 0)
    842 }
    843 func MonsterStartTest5Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    844 	return builder.StartVector(4, numElems, 2)
    845 }
    846 func MonsterAddVectorOfLongs(builder *flatbuffers.Builder, vectorOfLongs flatbuffers.UOffsetT) {
    847 	builder.PrependUOffsetTSlot(32, flatbuffers.UOffsetT(vectorOfLongs), 0)
    848 }
    849 func MonsterStartVectorOfLongsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    850 	return builder.StartVector(8, numElems, 8)
    851 }
    852 func MonsterAddVectorOfDoubles(builder *flatbuffers.Builder, vectorOfDoubles flatbuffers.UOffsetT) {
    853 	builder.PrependUOffsetTSlot(33, flatbuffers.UOffsetT(vectorOfDoubles), 0)
    854 }
    855 func MonsterStartVectorOfDoublesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    856 	return builder.StartVector(8, numElems, 8)
    857 }
    858 func MonsterAddParentNamespaceTest(builder *flatbuffers.Builder, parentNamespaceTest flatbuffers.UOffsetT) {
    859 	builder.PrependUOffsetTSlot(34, flatbuffers.UOffsetT(parentNamespaceTest), 0)
    860 }
    861 func MonsterAddVectorOfReferrables(builder *flatbuffers.Builder, vectorOfReferrables flatbuffers.UOffsetT) {
    862 	builder.PrependUOffsetTSlot(35, flatbuffers.UOffsetT(vectorOfReferrables), 0)
    863 }
    864 func MonsterStartVectorOfReferrablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    865 	return builder.StartVector(4, numElems, 4)
    866 }
    867 func MonsterAddSingleWeakReference(builder *flatbuffers.Builder, singleWeakReference uint64) {
    868 	builder.PrependUint64Slot(36, singleWeakReference, 0)
    869 }
    870 func MonsterAddVectorOfWeakReferences(builder *flatbuffers.Builder, vectorOfWeakReferences flatbuffers.UOffsetT) {
    871 	builder.PrependUOffsetTSlot(37, flatbuffers.UOffsetT(vectorOfWeakReferences), 0)
    872 }
    873 func MonsterStartVectorOfWeakReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    874 	return builder.StartVector(8, numElems, 8)
    875 }
    876 func MonsterAddVectorOfStrongReferrables(builder *flatbuffers.Builder, vectorOfStrongReferrables flatbuffers.UOffsetT) {
    877 	builder.PrependUOffsetTSlot(38, flatbuffers.UOffsetT(vectorOfStrongReferrables), 0)
    878 }
    879 func MonsterStartVectorOfStrongReferrablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    880 	return builder.StartVector(4, numElems, 4)
    881 }
    882 func MonsterAddCoOwningReference(builder *flatbuffers.Builder, coOwningReference uint64) {
    883 	builder.PrependUint64Slot(39, coOwningReference, 0)
    884 }
    885 func MonsterAddVectorOfCoOwningReferences(builder *flatbuffers.Builder, vectorOfCoOwningReferences flatbuffers.UOffsetT) {
    886 	builder.PrependUOffsetTSlot(40, flatbuffers.UOffsetT(vectorOfCoOwningReferences), 0)
    887 }
    888 func MonsterStartVectorOfCoOwningReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    889 	return builder.StartVector(8, numElems, 8)
    890 }
    891 func MonsterAddNonOwningReference(builder *flatbuffers.Builder, nonOwningReference uint64) {
    892 	builder.PrependUint64Slot(41, nonOwningReference, 0)
    893 }
    894 func MonsterAddVectorOfNonOwningReferences(builder *flatbuffers.Builder, vectorOfNonOwningReferences flatbuffers.UOffsetT) {
    895 	builder.PrependUOffsetTSlot(42, flatbuffers.UOffsetT(vectorOfNonOwningReferences), 0)
    896 }
    897 func MonsterStartVectorOfNonOwningReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    898 	return builder.StartVector(8, numElems, 8)
    899 }
    900 func MonsterAddAnyUniqueType(builder *flatbuffers.Builder, anyUniqueType byte) {
    901 	builder.PrependByteSlot(43, anyUniqueType, 0)
    902 }
    903 func MonsterAddAnyUnique(builder *flatbuffers.Builder, anyUnique flatbuffers.UOffsetT) {
    904 	builder.PrependUOffsetTSlot(44, flatbuffers.UOffsetT(anyUnique), 0)
    905 }
    906 func MonsterAddAnyAmbiguousType(builder *flatbuffers.Builder, anyAmbiguousType byte) {
    907 	builder.PrependByteSlot(45, anyAmbiguousType, 0)
    908 }
    909 func MonsterAddAnyAmbiguous(builder *flatbuffers.Builder, anyAmbiguous flatbuffers.UOffsetT) {
    910 	builder.PrependUOffsetTSlot(46, flatbuffers.UOffsetT(anyAmbiguous), 0)
    911 }
    912 func MonsterAddVectorOfEnums(builder *flatbuffers.Builder, vectorOfEnums flatbuffers.UOffsetT) {
    913 	builder.PrependUOffsetTSlot(47, flatbuffers.UOffsetT(vectorOfEnums), 0)
    914 }
    915 func MonsterStartVectorOfEnumsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
    916 	return builder.StartVector(1, numElems, 1)
    917 }
    918 func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
    919 	return builder.EndObject()
    920 }
    921