mirror of
https://github.com/google/flatbuffers.git
synced 2025-04-08 01:02:04 +08:00
735 lines
32 KiB
Nim
735 lines
32 KiB
Nim
#[ MyGame.Example.Monster
|
|
Automatically generated by the FlatBuffers compiler, do not modify.
|
|
Or modify. I'm a message, not a cop.
|
|
|
|
flatc version: 24.3.7
|
|
|
|
Declared by :
|
|
Rooting type : MyGame.Example.Monster ()
|
|
]#
|
|
|
|
import ../InParentNamespace as MyGame_InParentNamespace
|
|
import Ability as MyGame_Example_Ability
|
|
import Any as MyGame_Example_Any
|
|
import AnyAmbiguousAliases as MyGame_Example_AnyAmbiguousAliases
|
|
import AnyUniqueAliases as MyGame_Example_AnyUniqueAliases
|
|
import Color as MyGame_Example_Color
|
|
import LongEnum as MyGame_Example_LongEnum
|
|
import Race as MyGame_Example_Race
|
|
import Referrable as MyGame_Example_Referrable
|
|
import Stat as MyGame_Example_Stat
|
|
import Test as MyGame_Example_Test
|
|
import Vec3 as MyGame_Example_Vec3
|
|
import flatbuffers
|
|
import std/options
|
|
|
|
# an example documentation comment: "monster object"
|
|
type Monster* = object of FlatObj
|
|
func pos*(self: Monster): Option[MyGame_Example_Vec3.Vec3] =
|
|
let o = self.tab.Offset(4)
|
|
if o != 0:
|
|
return some(MyGame_Example_Vec3.Vec3(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o)))
|
|
func mana*(self: Monster): int16 =
|
|
let o = self.tab.Offset(6)
|
|
if o != 0:
|
|
return Get[int16](self.tab, self.tab.Pos + o)
|
|
return 150
|
|
func `mana=`*(self: var Monster, n: int16): bool =
|
|
return self.tab.MutateSlot(6, n)
|
|
func hp*(self: Monster): int16 =
|
|
let o = self.tab.Offset(8)
|
|
if o != 0:
|
|
return Get[int16](self.tab, self.tab.Pos + o)
|
|
return 100
|
|
func `hp=`*(self: var Monster, n: int16): bool =
|
|
return self.tab.MutateSlot(8, n)
|
|
func name*(self: Monster): string =
|
|
let o = self.tab.Offset(10)
|
|
if o != 0:
|
|
return self.tab.String(self.tab.Pos + o)
|
|
return ""
|
|
func inventoryLength*(self: Monster): int =
|
|
let o = self.tab.Offset(14)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func inventory*(self: Monster, j: int): uint8 =
|
|
let o = self.tab.Offset(14)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 1.uoffset
|
|
return Get[uint8](self.tab, x)
|
|
func inventory*(self: Monster): seq[uint8] =
|
|
let len = self.inventoryLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.inventory(i))
|
|
func color*(self: Monster): MyGame_Example_Color.Color =
|
|
let o = self.tab.Offset(16)
|
|
if o != 0:
|
|
return MyGame_Example_Color.Color(Get[uint8](self.tab, self.tab.Pos + o))
|
|
return type(result)(8)
|
|
func `color=`*(self: var Monster, n: MyGame_Example_Color.Color): bool =
|
|
return self.tab.MutateSlot(16, n)
|
|
func testType*(self: Monster): MyGame_Example_Any.Any =
|
|
let o = self.tab.Offset(18)
|
|
if o != 0:
|
|
return MyGame_Example_Any.Any(Get[uint8](self.tab, self.tab.Pos + o))
|
|
return type(result)(0)
|
|
func `testType=`*(self: var Monster, n: MyGame_Example_Any.Any): bool =
|
|
return self.tab.MutateSlot(18, n)
|
|
func test*(self: Monster): Option[Vtable] =
|
|
let o = self.tab.Offset(20)
|
|
if o != 0:
|
|
return some(self.tab.Union(o))
|
|
func test4Length*(self: Monster): int =
|
|
let o = self.tab.Offset(22)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func test4*(self: Monster, j: int): MyGame_Example_Test.Test =
|
|
let o = self.tab.Offset(22)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))
|
|
func test4*(self: Monster): seq[MyGame_Example_Test.Test] =
|
|
let len = self.test4Length
|
|
for i in countup(0, len - 1):
|
|
result.add(self.test4(i))
|
|
func testarrayofstringLength*(self: Monster): int =
|
|
let o = self.tab.Offset(24)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func testarrayofstring*(self: Monster, j: int): string =
|
|
let o = self.tab.Offset(24)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return self.tab.String(x)
|
|
func testarrayofstring*(self: Monster): seq[string] =
|
|
let len = self.testarrayofstringLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.testarrayofstring(i))
|
|
func testarrayoftablesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(26)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func testarrayoftables*(self: Monster, j: int): Monster =
|
|
let o = self.tab.Offset(26)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return Monster(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))
|
|
func testarrayoftables*(self: Monster): seq[Monster] =
|
|
let len = self.testarrayoftablesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.testarrayoftables(i))
|
|
func enemy*(self: Monster): Option[Monster] =
|
|
let o = self.tab.Offset(28)
|
|
if o != 0:
|
|
return some(Monster(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o)))
|
|
func testnestedflatbufferLength*(self: Monster): int =
|
|
let o = self.tab.Offset(30)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func testnestedflatbuffer*(self: Monster, j: int): uint8 =
|
|
let o = self.tab.Offset(30)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 1.uoffset
|
|
return Get[uint8](self.tab, x)
|
|
func testnestedflatbuffer*(self: Monster): seq[uint8] =
|
|
let len = self.testnestedflatbufferLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.testnestedflatbuffer(i))
|
|
func testempty*(self: Monster): Option[MyGame_Example_Stat.Stat] =
|
|
let o = self.tab.Offset(32)
|
|
if o != 0:
|
|
return some(MyGame_Example_Stat.Stat(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o)))
|
|
func testbool*(self: Monster): bool =
|
|
let o = self.tab.Offset(34)
|
|
if o != 0:
|
|
return Get[bool](self.tab, self.tab.Pos + o)
|
|
return false
|
|
func `testbool=`*(self: var Monster, n: bool): bool =
|
|
return self.tab.MutateSlot(34, n)
|
|
func testhashs32Fnv1*(self: Monster): int32 =
|
|
let o = self.tab.Offset(36)
|
|
if o != 0:
|
|
return Get[int32](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashs32Fnv1=`*(self: var Monster, n: int32): bool =
|
|
return self.tab.MutateSlot(36, n)
|
|
func testhashu32Fnv1*(self: Monster): uint32 =
|
|
let o = self.tab.Offset(38)
|
|
if o != 0:
|
|
return Get[uint32](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashu32Fnv1=`*(self: var Monster, n: uint32): bool =
|
|
return self.tab.MutateSlot(38, n)
|
|
func testhashs64Fnv1*(self: Monster): int64 =
|
|
let o = self.tab.Offset(40)
|
|
if o != 0:
|
|
return Get[int64](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashs64Fnv1=`*(self: var Monster, n: int64): bool =
|
|
return self.tab.MutateSlot(40, n)
|
|
func testhashu64Fnv1*(self: Monster): uint64 =
|
|
let o = self.tab.Offset(42)
|
|
if o != 0:
|
|
return Get[uint64](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashu64Fnv1=`*(self: var Monster, n: uint64): bool =
|
|
return self.tab.MutateSlot(42, n)
|
|
func testhashs32Fnv1a*(self: Monster): int32 =
|
|
let o = self.tab.Offset(44)
|
|
if o != 0:
|
|
return Get[int32](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashs32Fnv1a=`*(self: var Monster, n: int32): bool =
|
|
return self.tab.MutateSlot(44, n)
|
|
func testhashu32Fnv1a*(self: Monster): uint32 =
|
|
let o = self.tab.Offset(46)
|
|
if o != 0:
|
|
return Get[uint32](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashu32Fnv1a=`*(self: var Monster, n: uint32): bool =
|
|
return self.tab.MutateSlot(46, n)
|
|
func testhashs64Fnv1a*(self: Monster): int64 =
|
|
let o = self.tab.Offset(48)
|
|
if o != 0:
|
|
return Get[int64](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashs64Fnv1a=`*(self: var Monster, n: int64): bool =
|
|
return self.tab.MutateSlot(48, n)
|
|
func testhashu64Fnv1a*(self: Monster): uint64 =
|
|
let o = self.tab.Offset(50)
|
|
if o != 0:
|
|
return Get[uint64](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `testhashu64Fnv1a=`*(self: var Monster, n: uint64): bool =
|
|
return self.tab.MutateSlot(50, n)
|
|
func testarrayofboolsLength*(self: Monster): int =
|
|
let o = self.tab.Offset(52)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func testarrayofbools*(self: Monster, j: int): bool =
|
|
let o = self.tab.Offset(52)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 1.uoffset
|
|
return Get[bool](self.tab, x)
|
|
func testarrayofbools*(self: Monster): seq[bool] =
|
|
let len = self.testarrayofboolsLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.testarrayofbools(i))
|
|
func testf*(self: Monster): float32 =
|
|
let o = self.tab.Offset(54)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return 3.14159
|
|
func `testf=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(54, n)
|
|
func testf2*(self: Monster): float32 =
|
|
let o = self.tab.Offset(56)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return 3.0
|
|
func `testf2=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(56, n)
|
|
func testf3*(self: Monster): float32 =
|
|
let o = self.tab.Offset(58)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return 0.0
|
|
func `testf3=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(58, n)
|
|
func testarrayofstring2Length*(self: Monster): int =
|
|
let o = self.tab.Offset(60)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func testarrayofstring2*(self: Monster, j: int): string =
|
|
let o = self.tab.Offset(60)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return self.tab.String(x)
|
|
func testarrayofstring2*(self: Monster): seq[string] =
|
|
let len = self.testarrayofstring2Length
|
|
for i in countup(0, len - 1):
|
|
result.add(self.testarrayofstring2(i))
|
|
func testarrayofsortedstructLength*(self: Monster): int =
|
|
let o = self.tab.Offset(62)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func testarrayofsortedstruct*(self: Monster, j: int): MyGame_Example_Ability.Ability =
|
|
let o = self.tab.Offset(62)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 8.uoffset
|
|
return MyGame_Example_Ability.Ability(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))
|
|
func testarrayofsortedstruct*(self: Monster): seq[MyGame_Example_Ability.Ability] =
|
|
let len = self.testarrayofsortedstructLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.testarrayofsortedstruct(i))
|
|
func flexLength*(self: Monster): int =
|
|
let o = self.tab.Offset(64)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func flex*(self: Monster, j: int): uint8 =
|
|
let o = self.tab.Offset(64)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 1.uoffset
|
|
return Get[uint8](self.tab, x)
|
|
func flex*(self: Monster): seq[uint8] =
|
|
let len = self.flexLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.flex(i))
|
|
func test5Length*(self: Monster): int =
|
|
let o = self.tab.Offset(66)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func test5*(self: Monster, j: int): MyGame_Example_Test.Test =
|
|
let o = self.tab.Offset(66)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))
|
|
func test5*(self: Monster): seq[MyGame_Example_Test.Test] =
|
|
let len = self.test5Length
|
|
for i in countup(0, len - 1):
|
|
result.add(self.test5(i))
|
|
func vectorOfLongsLength*(self: Monster): int =
|
|
let o = self.tab.Offset(68)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfLongs*(self: Monster, j: int): int64 =
|
|
let o = self.tab.Offset(68)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 8.uoffset
|
|
return Get[int64](self.tab, x)
|
|
func vectorOfLongs*(self: Monster): seq[int64] =
|
|
let len = self.vectorOfLongsLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfLongs(i))
|
|
func vectorOfDoublesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(70)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfDoubles*(self: Monster, j: int): float64 =
|
|
let o = self.tab.Offset(70)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 8.uoffset
|
|
return Get[float64](self.tab, x)
|
|
func vectorOfDoubles*(self: Monster): seq[float64] =
|
|
let len = self.vectorOfDoublesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfDoubles(i))
|
|
func parentNamespaceTest*(self: Monster): Option[MyGame_InParentNamespace.InParentNamespace] =
|
|
let o = self.tab.Offset(72)
|
|
if o != 0:
|
|
return some(MyGame_InParentNamespace.InParentNamespace(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o)))
|
|
func vectorOfReferrablesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(74)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfReferrables*(self: Monster, j: int): MyGame_Example_Referrable.Referrable =
|
|
let o = self.tab.Offset(74)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return MyGame_Example_Referrable.Referrable(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))
|
|
func vectorOfReferrables*(self: Monster): seq[MyGame_Example_Referrable.Referrable] =
|
|
let len = self.vectorOfReferrablesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfReferrables(i))
|
|
func singleWeakReference*(self: Monster): uint64 =
|
|
let o = self.tab.Offset(76)
|
|
if o != 0:
|
|
return Get[uint64](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `singleWeakReference=`*(self: var Monster, n: uint64): bool =
|
|
return self.tab.MutateSlot(76, n)
|
|
func vectorOfWeakReferencesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(78)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfWeakReferences*(self: Monster, j: int): uint64 =
|
|
let o = self.tab.Offset(78)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 8.uoffset
|
|
return Get[uint64](self.tab, x)
|
|
func vectorOfWeakReferences*(self: Monster): seq[uint64] =
|
|
let len = self.vectorOfWeakReferencesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfWeakReferences(i))
|
|
func vectorOfStrongReferrablesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(80)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfStrongReferrables*(self: Monster, j: int): MyGame_Example_Referrable.Referrable =
|
|
let o = self.tab.Offset(80)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return MyGame_Example_Referrable.Referrable(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))
|
|
func vectorOfStrongReferrables*(self: Monster): seq[MyGame_Example_Referrable.Referrable] =
|
|
let len = self.vectorOfStrongReferrablesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfStrongReferrables(i))
|
|
func coOwningReference*(self: Monster): uint64 =
|
|
let o = self.tab.Offset(82)
|
|
if o != 0:
|
|
return Get[uint64](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `coOwningReference=`*(self: var Monster, n: uint64): bool =
|
|
return self.tab.MutateSlot(82, n)
|
|
func vectorOfCoOwningReferencesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(84)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfCoOwningReferences*(self: Monster, j: int): uint64 =
|
|
let o = self.tab.Offset(84)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 8.uoffset
|
|
return Get[uint64](self.tab, x)
|
|
func vectorOfCoOwningReferences*(self: Monster): seq[uint64] =
|
|
let len = self.vectorOfCoOwningReferencesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfCoOwningReferences(i))
|
|
func nonOwningReference*(self: Monster): uint64 =
|
|
let o = self.tab.Offset(86)
|
|
if o != 0:
|
|
return Get[uint64](self.tab, self.tab.Pos + o)
|
|
return 0
|
|
func `nonOwningReference=`*(self: var Monster, n: uint64): bool =
|
|
return self.tab.MutateSlot(86, n)
|
|
func vectorOfNonOwningReferencesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(88)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfNonOwningReferences*(self: Monster, j: int): uint64 =
|
|
let o = self.tab.Offset(88)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 8.uoffset
|
|
return Get[uint64](self.tab, x)
|
|
func vectorOfNonOwningReferences*(self: Monster): seq[uint64] =
|
|
let len = self.vectorOfNonOwningReferencesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfNonOwningReferences(i))
|
|
func anyUniqueType*(self: Monster): MyGame_Example_AnyUniqueAliases.AnyUniqueAliases =
|
|
let o = self.tab.Offset(90)
|
|
if o != 0:
|
|
return MyGame_Example_AnyUniqueAliases.AnyUniqueAliases(Get[uint8](self.tab, self.tab.Pos + o))
|
|
return type(result)(0)
|
|
func `anyUniqueType=`*(self: var Monster, n: MyGame_Example_AnyUniqueAliases.AnyUniqueAliases): bool =
|
|
return self.tab.MutateSlot(90, n)
|
|
func anyUnique*(self: Monster): Option[Vtable] =
|
|
let o = self.tab.Offset(92)
|
|
if o != 0:
|
|
return some(self.tab.Union(o))
|
|
func anyAmbiguousType*(self: Monster): MyGame_Example_AnyAmbiguousAliases.AnyAmbiguousAliases =
|
|
let o = self.tab.Offset(94)
|
|
if o != 0:
|
|
return MyGame_Example_AnyAmbiguousAliases.AnyAmbiguousAliases(Get[uint8](self.tab, self.tab.Pos + o))
|
|
return type(result)(0)
|
|
func `anyAmbiguousType=`*(self: var Monster, n: MyGame_Example_AnyAmbiguousAliases.AnyAmbiguousAliases): bool =
|
|
return self.tab.MutateSlot(94, n)
|
|
func anyAmbiguous*(self: Monster): Option[Vtable] =
|
|
let o = self.tab.Offset(96)
|
|
if o != 0:
|
|
return some(self.tab.Union(o))
|
|
func vectorOfEnumsLength*(self: Monster): int =
|
|
let o = self.tab.Offset(98)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func vectorOfEnums*(self: Monster, j: int): MyGame_Example_Color.Color =
|
|
let o = self.tab.Offset(98)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 1.uoffset
|
|
return MyGame_Example_Color.Color(Get[uint8](self.tab, x))
|
|
func vectorOfEnums*(self: Monster): seq[MyGame_Example_Color.Color] =
|
|
let len = self.vectorOfEnumsLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.vectorOfEnums(i))
|
|
func signedEnum*(self: Monster): MyGame_Example_Race.Race =
|
|
let o = self.tab.Offset(100)
|
|
if o != 0:
|
|
return MyGame_Example_Race.Race(Get[int8](self.tab, self.tab.Pos + o))
|
|
return type(result)(-1)
|
|
func `signedEnum=`*(self: var Monster, n: MyGame_Example_Race.Race): bool =
|
|
return self.tab.MutateSlot(100, n)
|
|
func testrequirednestedflatbufferLength*(self: Monster): int =
|
|
let o = self.tab.Offset(102)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func testrequirednestedflatbuffer*(self: Monster, j: int): uint8 =
|
|
let o = self.tab.Offset(102)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 1.uoffset
|
|
return Get[uint8](self.tab, x)
|
|
func testrequirednestedflatbuffer*(self: Monster): seq[uint8] =
|
|
let len = self.testrequirednestedflatbufferLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.testrequirednestedflatbuffer(i))
|
|
func scalarKeySortedTablesLength*(self: Monster): int =
|
|
let o = self.tab.Offset(104)
|
|
if o != 0:
|
|
return self.tab.VectorLen(o)
|
|
func scalarKeySortedTables*(self: Monster, j: int): MyGame_Example_Stat.Stat =
|
|
let o = self.tab.Offset(104)
|
|
if o != 0:
|
|
var x = self.tab.Vector(o)
|
|
x += j.uoffset * 4.uoffset
|
|
return MyGame_Example_Stat.Stat(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))
|
|
func scalarKeySortedTables*(self: Monster): seq[MyGame_Example_Stat.Stat] =
|
|
let len = self.scalarKeySortedTablesLength
|
|
for i in countup(0, len - 1):
|
|
result.add(self.scalarKeySortedTables(i))
|
|
func nativeInline*(self: Monster): Option[MyGame_Example_Test.Test] =
|
|
let o = self.tab.Offset(106)
|
|
if o != 0:
|
|
return some(MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o)))
|
|
func longEnumNonEnumDefault*(self: Monster): MyGame_Example_LongEnum.LongEnum =
|
|
let o = self.tab.Offset(108)
|
|
if o != 0:
|
|
return MyGame_Example_LongEnum.LongEnum(Get[uint64](self.tab, self.tab.Pos + o))
|
|
return type(result)(0)
|
|
func `longEnumNonEnumDefault=`*(self: var Monster, n: MyGame_Example_LongEnum.LongEnum): bool =
|
|
return self.tab.MutateSlot(108, n)
|
|
func longEnumNormalDefault*(self: Monster): MyGame_Example_LongEnum.LongEnum =
|
|
let o = self.tab.Offset(110)
|
|
if o != 0:
|
|
return MyGame_Example_LongEnum.LongEnum(Get[uint64](self.tab, self.tab.Pos + o))
|
|
return type(result)(2)
|
|
func `longEnumNormalDefault=`*(self: var Monster, n: MyGame_Example_LongEnum.LongEnum): bool =
|
|
return self.tab.MutateSlot(110, n)
|
|
func nanDefault*(self: Monster): float32 =
|
|
let o = self.tab.Offset(112)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return NaN
|
|
func `nanDefault=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(112, n)
|
|
func infDefault*(self: Monster): float32 =
|
|
let o = self.tab.Offset(114)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return Inf
|
|
func `infDefault=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(114, n)
|
|
func positiveInfDefault*(self: Monster): float32 =
|
|
let o = self.tab.Offset(116)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return Inf
|
|
func `positiveInfDefault=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(116, n)
|
|
func infinityDefault*(self: Monster): float32 =
|
|
let o = self.tab.Offset(118)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return Inf
|
|
func `infinityDefault=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(118, n)
|
|
func positiveInfinityDefault*(self: Monster): float32 =
|
|
let o = self.tab.Offset(120)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return Inf
|
|
func `positiveInfinityDefault=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(120, n)
|
|
func negativeInfDefault*(self: Monster): float32 =
|
|
let o = self.tab.Offset(122)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return -Inf
|
|
func `negativeInfDefault=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(122, n)
|
|
func negativeInfinityDefault*(self: Monster): float32 =
|
|
let o = self.tab.Offset(124)
|
|
if o != 0:
|
|
return Get[float32](self.tab, self.tab.Pos + o)
|
|
return -Inf
|
|
func `negativeInfinityDefault=`*(self: var Monster, n: float32): bool =
|
|
return self.tab.MutateSlot(124, n)
|
|
func doubleInfDefault*(self: Monster): float64 =
|
|
let o = self.tab.Offset(126)
|
|
if o != 0:
|
|
return Get[float64](self.tab, self.tab.Pos + o)
|
|
return Inf
|
|
func `doubleInfDefault=`*(self: var Monster, n: float64): bool =
|
|
return self.tab.MutateSlot(126, n)
|
|
proc MonsterStart*(builder: var Builder) =
|
|
builder.StartObject(62)
|
|
proc MonsterAddpos*(builder: var Builder, pos: uoffset) =
|
|
builder.PrependStructSlot(0, pos, default(uoffset))
|
|
proc MonsterAddmana*(builder: var Builder, mana: int16) =
|
|
builder.PrependSlot(1, mana, default(int16))
|
|
proc MonsterAddhp*(builder: var Builder, hp: int16) =
|
|
builder.PrependSlot(2, hp, default(int16))
|
|
proc MonsterAddname*(builder: var Builder, name: uoffset) =
|
|
builder.PrependSlot(3, name, default(uoffset))
|
|
proc MonsterAddinventory*(builder: var Builder, inventory: uoffset) =
|
|
builder.PrependSlot(5, inventory, default(uoffset))
|
|
proc MonsterStartinventoryVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(1, numElems, 1)
|
|
proc MonsterAddcolor*(builder: var Builder, color: uint8) =
|
|
builder.PrependSlot(6, color, default(uint8))
|
|
proc MonsterAddtestType*(builder: var Builder, testType: uint8) =
|
|
builder.PrependSlot(7, testType, default(uint8))
|
|
proc MonsterAddtest*(builder: var Builder, test: uoffset) =
|
|
builder.PrependSlot(8, test, default(uoffset))
|
|
proc MonsterAddtest4*(builder: var Builder, test4: uoffset) =
|
|
builder.PrependSlot(9, test4, default(uoffset))
|
|
proc MonsterStarttest4Vector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 2)
|
|
proc MonsterAddtestarrayofstring*(builder: var Builder, testarrayofstring: uoffset) =
|
|
builder.PrependSlot(10, testarrayofstring, default(uoffset))
|
|
proc MonsterStarttestarrayofstringVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 4)
|
|
proc MonsterAddtestarrayoftables*(builder: var Builder, testarrayoftables: uoffset) =
|
|
builder.PrependSlot(11, testarrayoftables, default(uoffset))
|
|
proc MonsterStarttestarrayoftablesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 4)
|
|
proc MonsterAddenemy*(builder: var Builder, enemy: uoffset) =
|
|
builder.PrependStructSlot(12, enemy, default(uoffset))
|
|
proc MonsterAddtestnestedflatbuffer*(builder: var Builder, testnestedflatbuffer: uoffset) =
|
|
builder.PrependSlot(13, testnestedflatbuffer, default(uoffset))
|
|
proc MonsterStarttestnestedflatbufferVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(1, numElems, 1)
|
|
proc MonsterAddtestempty*(builder: var Builder, testempty: uoffset) =
|
|
builder.PrependStructSlot(14, testempty, default(uoffset))
|
|
proc MonsterAddtestbool*(builder: var Builder, testbool: bool) =
|
|
builder.PrependSlot(15, testbool, default(bool))
|
|
proc MonsterAddtesthashs32Fnv1*(builder: var Builder, testhashs32Fnv1: int32) =
|
|
builder.PrependSlot(16, testhashs32Fnv1, default(int32))
|
|
proc MonsterAddtesthashu32Fnv1*(builder: var Builder, testhashu32Fnv1: uint32) =
|
|
builder.PrependSlot(17, testhashu32Fnv1, default(uint32))
|
|
proc MonsterAddtesthashs64Fnv1*(builder: var Builder, testhashs64Fnv1: int64) =
|
|
builder.PrependSlot(18, testhashs64Fnv1, default(int64))
|
|
proc MonsterAddtesthashu64Fnv1*(builder: var Builder, testhashu64Fnv1: uint64) =
|
|
builder.PrependSlot(19, testhashu64Fnv1, default(uint64))
|
|
proc MonsterAddtesthashs32Fnv1a*(builder: var Builder, testhashs32Fnv1a: int32) =
|
|
builder.PrependSlot(20, testhashs32Fnv1a, default(int32))
|
|
proc MonsterAddtesthashu32Fnv1a*(builder: var Builder, testhashu32Fnv1a: uint32) =
|
|
builder.PrependSlot(21, testhashu32Fnv1a, default(uint32))
|
|
proc MonsterAddtesthashs64Fnv1a*(builder: var Builder, testhashs64Fnv1a: int64) =
|
|
builder.PrependSlot(22, testhashs64Fnv1a, default(int64))
|
|
proc MonsterAddtesthashu64Fnv1a*(builder: var Builder, testhashu64Fnv1a: uint64) =
|
|
builder.PrependSlot(23, testhashu64Fnv1a, default(uint64))
|
|
proc MonsterAddtestarrayofbools*(builder: var Builder, testarrayofbools: uoffset) =
|
|
builder.PrependSlot(24, testarrayofbools, default(uoffset))
|
|
proc MonsterStarttestarrayofboolsVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(1, numElems, 1)
|
|
proc MonsterAddtestf*(builder: var Builder, testf: float32) =
|
|
builder.PrependSlot(25, testf, default(float32))
|
|
proc MonsterAddtestf2*(builder: var Builder, testf2: float32) =
|
|
builder.PrependSlot(26, testf2, default(float32))
|
|
proc MonsterAddtestf3*(builder: var Builder, testf3: float32) =
|
|
builder.PrependSlot(27, testf3, default(float32))
|
|
proc MonsterAddtestarrayofstring2*(builder: var Builder, testarrayofstring2: uoffset) =
|
|
builder.PrependSlot(28, testarrayofstring2, default(uoffset))
|
|
proc MonsterStarttestarrayofstring2Vector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 4)
|
|
proc MonsterAddtestarrayofsortedstruct*(builder: var Builder, testarrayofsortedstruct: uoffset) =
|
|
builder.PrependSlot(29, testarrayofsortedstruct, default(uoffset))
|
|
proc MonsterStarttestarrayofsortedstructVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(8, numElems, 4)
|
|
proc MonsterAddflex*(builder: var Builder, flex: uoffset) =
|
|
builder.PrependSlot(30, flex, default(uoffset))
|
|
proc MonsterStartflexVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(1, numElems, 1)
|
|
proc MonsterAddtest5*(builder: var Builder, test5: uoffset) =
|
|
builder.PrependSlot(31, test5, default(uoffset))
|
|
proc MonsterStarttest5Vector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 2)
|
|
proc MonsterAddvectorOfLongs*(builder: var Builder, vectorOfLongs: uoffset) =
|
|
builder.PrependSlot(32, vectorOfLongs, default(uoffset))
|
|
proc MonsterStartvectorOfLongsVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(8, numElems, 8)
|
|
proc MonsterAddvectorOfDoubles*(builder: var Builder, vectorOfDoubles: uoffset) =
|
|
builder.PrependSlot(33, vectorOfDoubles, default(uoffset))
|
|
proc MonsterStartvectorOfDoublesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(8, numElems, 8)
|
|
proc MonsterAddparentNamespaceTest*(builder: var Builder, parentNamespaceTest: uoffset) =
|
|
builder.PrependStructSlot(34, parentNamespaceTest, default(uoffset))
|
|
proc MonsterAddvectorOfReferrables*(builder: var Builder, vectorOfReferrables: uoffset) =
|
|
builder.PrependSlot(35, vectorOfReferrables, default(uoffset))
|
|
proc MonsterStartvectorOfReferrablesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 4)
|
|
proc MonsterAddsingleWeakReference*(builder: var Builder, singleWeakReference: uint64) =
|
|
builder.PrependSlot(36, singleWeakReference, default(uint64))
|
|
proc MonsterAddvectorOfWeakReferences*(builder: var Builder, vectorOfWeakReferences: uoffset) =
|
|
builder.PrependSlot(37, vectorOfWeakReferences, default(uoffset))
|
|
proc MonsterStartvectorOfWeakReferencesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(8, numElems, 8)
|
|
proc MonsterAddvectorOfStrongReferrables*(builder: var Builder, vectorOfStrongReferrables: uoffset) =
|
|
builder.PrependSlot(38, vectorOfStrongReferrables, default(uoffset))
|
|
proc MonsterStartvectorOfStrongReferrablesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 4)
|
|
proc MonsterAddcoOwningReference*(builder: var Builder, coOwningReference: uint64) =
|
|
builder.PrependSlot(39, coOwningReference, default(uint64))
|
|
proc MonsterAddvectorOfCoOwningReferences*(builder: var Builder, vectorOfCoOwningReferences: uoffset) =
|
|
builder.PrependSlot(40, vectorOfCoOwningReferences, default(uoffset))
|
|
proc MonsterStartvectorOfCoOwningReferencesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(8, numElems, 8)
|
|
proc MonsterAddnonOwningReference*(builder: var Builder, nonOwningReference: uint64) =
|
|
builder.PrependSlot(41, nonOwningReference, default(uint64))
|
|
proc MonsterAddvectorOfNonOwningReferences*(builder: var Builder, vectorOfNonOwningReferences: uoffset) =
|
|
builder.PrependSlot(42, vectorOfNonOwningReferences, default(uoffset))
|
|
proc MonsterStartvectorOfNonOwningReferencesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(8, numElems, 8)
|
|
proc MonsterAddanyUniqueType*(builder: var Builder, anyUniqueType: uint8) =
|
|
builder.PrependSlot(43, anyUniqueType, default(uint8))
|
|
proc MonsterAddanyUnique*(builder: var Builder, anyUnique: uoffset) =
|
|
builder.PrependSlot(44, anyUnique, default(uoffset))
|
|
proc MonsterAddanyAmbiguousType*(builder: var Builder, anyAmbiguousType: uint8) =
|
|
builder.PrependSlot(45, anyAmbiguousType, default(uint8))
|
|
proc MonsterAddanyAmbiguous*(builder: var Builder, anyAmbiguous: uoffset) =
|
|
builder.PrependSlot(46, anyAmbiguous, default(uoffset))
|
|
proc MonsterAddvectorOfEnums*(builder: var Builder, vectorOfEnums: uoffset) =
|
|
builder.PrependSlot(47, vectorOfEnums, default(uoffset))
|
|
proc MonsterStartvectorOfEnumsVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(1, numElems, 1)
|
|
proc MonsterAddsignedEnum*(builder: var Builder, signedEnum: int8) =
|
|
builder.PrependSlot(48, signedEnum, default(int8))
|
|
proc MonsterAddtestrequirednestedflatbuffer*(builder: var Builder, testrequirednestedflatbuffer: uoffset) =
|
|
builder.PrependSlot(49, testrequirednestedflatbuffer, default(uoffset))
|
|
proc MonsterStarttestrequirednestedflatbufferVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(1, numElems, 1)
|
|
proc MonsterAddscalarKeySortedTables*(builder: var Builder, scalarKeySortedTables: uoffset) =
|
|
builder.PrependSlot(50, scalarKeySortedTables, default(uoffset))
|
|
proc MonsterStartscalarKeySortedTablesVector*(builder: var Builder, numElems: uoffset) =
|
|
builder.StartVector(4, numElems, 4)
|
|
proc MonsterAddnativeInline*(builder: var Builder, nativeInline: uoffset) =
|
|
builder.PrependStructSlot(51, nativeInline, default(uoffset))
|
|
proc MonsterAddlongEnumNonEnumDefault*(builder: var Builder, longEnumNonEnumDefault: uint64) =
|
|
builder.PrependSlot(52, longEnumNonEnumDefault, default(uint64))
|
|
proc MonsterAddlongEnumNormalDefault*(builder: var Builder, longEnumNormalDefault: uint64) =
|
|
builder.PrependSlot(53, longEnumNormalDefault, default(uint64))
|
|
proc MonsterAddnanDefault*(builder: var Builder, nanDefault: float32) =
|
|
builder.PrependSlot(54, nanDefault, default(float32))
|
|
proc MonsterAddinfDefault*(builder: var Builder, infDefault: float32) =
|
|
builder.PrependSlot(55, infDefault, default(float32))
|
|
proc MonsterAddpositiveInfDefault*(builder: var Builder, positiveInfDefault: float32) =
|
|
builder.PrependSlot(56, positiveInfDefault, default(float32))
|
|
proc MonsterAddinfinityDefault*(builder: var Builder, infinityDefault: float32) =
|
|
builder.PrependSlot(57, infinityDefault, default(float32))
|
|
proc MonsterAddpositiveInfinityDefault*(builder: var Builder, positiveInfinityDefault: float32) =
|
|
builder.PrependSlot(58, positiveInfinityDefault, default(float32))
|
|
proc MonsterAddnegativeInfDefault*(builder: var Builder, negativeInfDefault: float32) =
|
|
builder.PrependSlot(59, negativeInfDefault, default(float32))
|
|
proc MonsterAddnegativeInfinityDefault*(builder: var Builder, negativeInfinityDefault: float32) =
|
|
builder.PrependSlot(60, negativeInfinityDefault, default(float32))
|
|
proc MonsterAdddoubleInfDefault*(builder: var Builder, doubleInfDefault: float64) =
|
|
builder.PrependSlot(61, doubleInfDefault, default(float64))
|
|
proc MonsterEnd*(builder: var Builder): uoffset =
|
|
return builder.EndObject()
|