1// Code generated by the FlatBuffers compiler. DO NOT EDIT. 2 3package Example 4 5import ( 6 "bytes" 7 flatbuffers "github.com/google/flatbuffers/go" 8 "math" 9 10 MyGame "MyGame" 11) 12 13/// an example documentation comment: "monster object" 14type MonsterT struct { 15 Pos *Vec3T `json:"pos"` 16 Mana int16 `json:"mana"` 17 Hp int16 `json:"hp"` 18 Name string `json:"name"` 19 Inventory []byte `json:"inventory"` 20 Color Color `json:"color"` 21 Test *AnyT `json:"test"` 22 Test4 []*TestT `json:"test4"` 23 Testarrayofstring []string `json:"testarrayofstring"` 24 Testarrayoftables []*MonsterT `json:"testarrayoftables"` 25 Enemy *MonsterT `json:"enemy"` 26 Testnestedflatbuffer []byte `json:"testnestedflatbuffer"` 27 Testempty *StatT `json:"testempty"` 28 Testbool bool `json:"testbool"` 29 Testhashs32Fnv1 int32 `json:"testhashs32_fnv1"` 30 Testhashu32Fnv1 uint32 `json:"testhashu32_fnv1"` 31 Testhashs64Fnv1 int64 `json:"testhashs64_fnv1"` 32 Testhashu64Fnv1 uint64 `json:"testhashu64_fnv1"` 33 Testhashs32Fnv1a int32 `json:"testhashs32_fnv1a"` 34 Testhashu32Fnv1a uint32 `json:"testhashu32_fnv1a"` 35 Testhashs64Fnv1a int64 `json:"testhashs64_fnv1a"` 36 Testhashu64Fnv1a uint64 `json:"testhashu64_fnv1a"` 37 Testarrayofbools []bool `json:"testarrayofbools"` 38 Testf float32 `json:"testf"` 39 Testf2 float32 `json:"testf2"` 40 Testf3 float32 `json:"testf3"` 41 Testarrayofstring2 []string `json:"testarrayofstring2"` 42 Testarrayofsortedstruct []*AbilityT `json:"testarrayofsortedstruct"` 43 Flex []byte `json:"flex"` 44 Test5 []*TestT `json:"test5"` 45 VectorOfLongs []int64 `json:"vector_of_longs"` 46 VectorOfDoubles []float64 `json:"vector_of_doubles"` 47 ParentNamespaceTest *MyGame.InParentNamespaceT `json:"parent_namespace_test"` 48 VectorOfReferrables []*ReferrableT `json:"vector_of_referrables"` 49 SingleWeakReference uint64 `json:"single_weak_reference"` 50 VectorOfWeakReferences []uint64 `json:"vector_of_weak_references"` 51 VectorOfStrongReferrables []*ReferrableT `json:"vector_of_strong_referrables"` 52 CoOwningReference uint64 `json:"co_owning_reference"` 53 VectorOfCoOwningReferences []uint64 `json:"vector_of_co_owning_references"` 54 NonOwningReference uint64 `json:"non_owning_reference"` 55 VectorOfNonOwningReferences []uint64 `json:"vector_of_non_owning_references"` 56 AnyUnique *AnyUniqueAliasesT `json:"any_unique"` 57 AnyAmbiguous *AnyAmbiguousAliasesT `json:"any_ambiguous"` 58 VectorOfEnums []Color `json:"vector_of_enums"` 59 SignedEnum Race `json:"signed_enum"` 60 Testrequirednestedflatbuffer []byte `json:"testrequirednestedflatbuffer"` 61 ScalarKeySortedTables []*StatT `json:"scalar_key_sorted_tables"` 62 NativeInline *TestT `json:"native_inline"` 63 LongEnumNonEnumDefault LongEnum `json:"long_enum_non_enum_default"` 64 LongEnumNormalDefault LongEnum `json:"long_enum_normal_default"` 65 NanDefault float32 `json:"nan_default"` 66 InfDefault float32 `json:"inf_default"` 67 PositiveInfDefault float32 `json:"positive_inf_default"` 68 InfinityDefault float32 `json:"infinity_default"` 69 PositiveInfinityDefault float32 `json:"positive_infinity_default"` 70 NegativeInfDefault float32 `json:"negative_inf_default"` 71 NegativeInfinityDefault float32 `json:"negative_infinity_default"` 72 DoubleInfDefault float64 `json:"double_inf_default"` 73} 74 75func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { 76 if t == nil { 77 return 0 78 } 79 nameOffset := flatbuffers.UOffsetT(0) 80 if t.Name != "" { 81 nameOffset = builder.CreateString(t.Name) 82 } 83 inventoryOffset := flatbuffers.UOffsetT(0) 84 if t.Inventory != nil { 85 inventoryOffset = builder.CreateByteString(t.Inventory) 86 } 87 testOffset := t.Test.Pack(builder) 88 89 test4Offset := flatbuffers.UOffsetT(0) 90 if t.Test4 != nil { 91 test4Length := len(t.Test4) 92 MonsterStartTest4Vector(builder, test4Length) 93 for j := test4Length - 1; j >= 0; j-- { 94 t.Test4[j].Pack(builder) 95 } 96 test4Offset = builder.EndVector(test4Length) 97 } 98 testarrayofstringOffset := flatbuffers.UOffsetT(0) 99 if t.Testarrayofstring != nil { 100 testarrayofstringLength := len(t.Testarrayofstring) 101 testarrayofstringOffsets := make([]flatbuffers.UOffsetT, testarrayofstringLength) 102 for j := 0; j < testarrayofstringLength; j++ { 103 testarrayofstringOffsets[j] = builder.CreateString(t.Testarrayofstring[j]) 104 } 105 MonsterStartTestarrayofstringVector(builder, testarrayofstringLength) 106 for j := testarrayofstringLength - 1; j >= 0; j-- { 107 builder.PrependUOffsetT(testarrayofstringOffsets[j]) 108 } 109 testarrayofstringOffset = builder.EndVector(testarrayofstringLength) 110 } 111 testarrayoftablesOffset := flatbuffers.UOffsetT(0) 112 if t.Testarrayoftables != nil { 113 testarrayoftablesLength := len(t.Testarrayoftables) 114 testarrayoftablesOffsets := make([]flatbuffers.UOffsetT, testarrayoftablesLength) 115 for j := 0; j < testarrayoftablesLength; j++ { 116 testarrayoftablesOffsets[j] = t.Testarrayoftables[j].Pack(builder) 117 } 118 MonsterStartTestarrayoftablesVector(builder, testarrayoftablesLength) 119 for j := testarrayoftablesLength - 1; j >= 0; j-- { 120 builder.PrependUOffsetT(testarrayoftablesOffsets[j]) 121 } 122 testarrayoftablesOffset = builder.EndVector(testarrayoftablesLength) 123 } 124 enemyOffset := t.Enemy.Pack(builder) 125 testnestedflatbufferOffset := flatbuffers.UOffsetT(0) 126 if t.Testnestedflatbuffer != nil { 127 testnestedflatbufferOffset = builder.CreateByteString(t.Testnestedflatbuffer) 128 } 129 testemptyOffset := t.Testempty.Pack(builder) 130 testarrayofboolsOffset := flatbuffers.UOffsetT(0) 131 if t.Testarrayofbools != nil { 132 testarrayofboolsLength := len(t.Testarrayofbools) 133 MonsterStartTestarrayofboolsVector(builder, testarrayofboolsLength) 134 for j := testarrayofboolsLength - 1; j >= 0; j-- { 135 builder.PrependBool(t.Testarrayofbools[j]) 136 } 137 testarrayofboolsOffset = builder.EndVector(testarrayofboolsLength) 138 } 139 testarrayofstring2Offset := flatbuffers.UOffsetT(0) 140 if t.Testarrayofstring2 != nil { 141 testarrayofstring2Length := len(t.Testarrayofstring2) 142 testarrayofstring2Offsets := make([]flatbuffers.UOffsetT, testarrayofstring2Length) 143 for j := 0; j < testarrayofstring2Length; j++ { 144 testarrayofstring2Offsets[j] = builder.CreateString(t.Testarrayofstring2[j]) 145 } 146 MonsterStartTestarrayofstring2Vector(builder, testarrayofstring2Length) 147 for j := testarrayofstring2Length - 1; j >= 0; j-- { 148 builder.PrependUOffsetT(testarrayofstring2Offsets[j]) 149 } 150 testarrayofstring2Offset = builder.EndVector(testarrayofstring2Length) 151 } 152 testarrayofsortedstructOffset := flatbuffers.UOffsetT(0) 153 if t.Testarrayofsortedstruct != nil { 154 testarrayofsortedstructLength := len(t.Testarrayofsortedstruct) 155 MonsterStartTestarrayofsortedstructVector(builder, testarrayofsortedstructLength) 156 for j := testarrayofsortedstructLength - 1; j >= 0; j-- { 157 t.Testarrayofsortedstruct[j].Pack(builder) 158 } 159 testarrayofsortedstructOffset = builder.EndVector(testarrayofsortedstructLength) 160 } 161 flexOffset := flatbuffers.UOffsetT(0) 162 if t.Flex != nil { 163 flexOffset = builder.CreateByteString(t.Flex) 164 } 165 test5Offset := flatbuffers.UOffsetT(0) 166 if t.Test5 != nil { 167 test5Length := len(t.Test5) 168 MonsterStartTest5Vector(builder, test5Length) 169 for j := test5Length - 1; j >= 0; j-- { 170 t.Test5[j].Pack(builder) 171 } 172 test5Offset = builder.EndVector(test5Length) 173 } 174 vectorOfLongsOffset := flatbuffers.UOffsetT(0) 175 if t.VectorOfLongs != nil { 176 vectorOfLongsLength := len(t.VectorOfLongs) 177 MonsterStartVectorOfLongsVector(builder, vectorOfLongsLength) 178 for j := vectorOfLongsLength - 1; j >= 0; j-- { 179 builder.PrependInt64(t.VectorOfLongs[j]) 180 } 181 vectorOfLongsOffset = builder.EndVector(vectorOfLongsLength) 182 } 183 vectorOfDoublesOffset := flatbuffers.UOffsetT(0) 184 if t.VectorOfDoubles != nil { 185 vectorOfDoublesLength := len(t.VectorOfDoubles) 186 MonsterStartVectorOfDoublesVector(builder, vectorOfDoublesLength) 187 for j := vectorOfDoublesLength - 1; j >= 0; j-- { 188 builder.PrependFloat64(t.VectorOfDoubles[j]) 189 } 190 vectorOfDoublesOffset = builder.EndVector(vectorOfDoublesLength) 191 } 192 parentNamespaceTestOffset := t.ParentNamespaceTest.Pack(builder) 193 vectorOfReferrablesOffset := flatbuffers.UOffsetT(0) 194 if t.VectorOfReferrables != nil { 195 vectorOfReferrablesLength := len(t.VectorOfReferrables) 196 vectorOfReferrablesOffsets := make([]flatbuffers.UOffsetT, vectorOfReferrablesLength) 197 for j := 0; j < vectorOfReferrablesLength; j++ { 198 vectorOfReferrablesOffsets[j] = t.VectorOfReferrables[j].Pack(builder) 199 } 200 MonsterStartVectorOfReferrablesVector(builder, vectorOfReferrablesLength) 201 for j := vectorOfReferrablesLength - 1; j >= 0; j-- { 202 builder.PrependUOffsetT(vectorOfReferrablesOffsets[j]) 203 } 204 vectorOfReferrablesOffset = builder.EndVector(vectorOfReferrablesLength) 205 } 206 vectorOfWeakReferencesOffset := flatbuffers.UOffsetT(0) 207 if t.VectorOfWeakReferences != nil { 208 vectorOfWeakReferencesLength := len(t.VectorOfWeakReferences) 209 MonsterStartVectorOfWeakReferencesVector(builder, vectorOfWeakReferencesLength) 210 for j := vectorOfWeakReferencesLength - 1; j >= 0; j-- { 211 builder.PrependUint64(t.VectorOfWeakReferences[j]) 212 } 213 vectorOfWeakReferencesOffset = builder.EndVector(vectorOfWeakReferencesLength) 214 } 215 vectorOfStrongReferrablesOffset := flatbuffers.UOffsetT(0) 216 if t.VectorOfStrongReferrables != nil { 217 vectorOfStrongReferrablesLength := len(t.VectorOfStrongReferrables) 218 vectorOfStrongReferrablesOffsets := make([]flatbuffers.UOffsetT, vectorOfStrongReferrablesLength) 219 for j := 0; j < vectorOfStrongReferrablesLength; j++ { 220 vectorOfStrongReferrablesOffsets[j] = t.VectorOfStrongReferrables[j].Pack(builder) 221 } 222 MonsterStartVectorOfStrongReferrablesVector(builder, vectorOfStrongReferrablesLength) 223 for j := vectorOfStrongReferrablesLength - 1; j >= 0; j-- { 224 builder.PrependUOffsetT(vectorOfStrongReferrablesOffsets[j]) 225 } 226 vectorOfStrongReferrablesOffset = builder.EndVector(vectorOfStrongReferrablesLength) 227 } 228 vectorOfCoOwningReferencesOffset := flatbuffers.UOffsetT(0) 229 if t.VectorOfCoOwningReferences != nil { 230 vectorOfCoOwningReferencesLength := len(t.VectorOfCoOwningReferences) 231 MonsterStartVectorOfCoOwningReferencesVector(builder, vectorOfCoOwningReferencesLength) 232 for j := vectorOfCoOwningReferencesLength - 1; j >= 0; j-- { 233 builder.PrependUint64(t.VectorOfCoOwningReferences[j]) 234 } 235 vectorOfCoOwningReferencesOffset = builder.EndVector(vectorOfCoOwningReferencesLength) 236 } 237 vectorOfNonOwningReferencesOffset := flatbuffers.UOffsetT(0) 238 if t.VectorOfNonOwningReferences != nil { 239 vectorOfNonOwningReferencesLength := len(t.VectorOfNonOwningReferences) 240 MonsterStartVectorOfNonOwningReferencesVector(builder, vectorOfNonOwningReferencesLength) 241 for j := vectorOfNonOwningReferencesLength - 1; j >= 0; j-- { 242 builder.PrependUint64(t.VectorOfNonOwningReferences[j]) 243 } 244 vectorOfNonOwningReferencesOffset = builder.EndVector(vectorOfNonOwningReferencesLength) 245 } 246 anyUniqueOffset := t.AnyUnique.Pack(builder) 247 248 anyAmbiguousOffset := t.AnyAmbiguous.Pack(builder) 249 250 vectorOfEnumsOffset := flatbuffers.UOffsetT(0) 251 if t.VectorOfEnums != nil { 252 vectorOfEnumsLength := len(t.VectorOfEnums) 253 MonsterStartVectorOfEnumsVector(builder, vectorOfEnumsLength) 254 for j := vectorOfEnumsLength - 1; j >= 0; j-- { 255 builder.PrependByte(byte(t.VectorOfEnums[j])) 256 } 257 vectorOfEnumsOffset = builder.EndVector(vectorOfEnumsLength) 258 } 259 testrequirednestedflatbufferOffset := flatbuffers.UOffsetT(0) 260 if t.Testrequirednestedflatbuffer != nil { 261 testrequirednestedflatbufferOffset = builder.CreateByteString(t.Testrequirednestedflatbuffer) 262 } 263 scalarKeySortedTablesOffset := flatbuffers.UOffsetT(0) 264 if t.ScalarKeySortedTables != nil { 265 scalarKeySortedTablesLength := len(t.ScalarKeySortedTables) 266 scalarKeySortedTablesOffsets := make([]flatbuffers.UOffsetT, scalarKeySortedTablesLength) 267 for j := 0; j < scalarKeySortedTablesLength; j++ { 268 scalarKeySortedTablesOffsets[j] = t.ScalarKeySortedTables[j].Pack(builder) 269 } 270 MonsterStartScalarKeySortedTablesVector(builder, scalarKeySortedTablesLength) 271 for j := scalarKeySortedTablesLength - 1; j >= 0; j-- { 272 builder.PrependUOffsetT(scalarKeySortedTablesOffsets[j]) 273 } 274 scalarKeySortedTablesOffset = builder.EndVector(scalarKeySortedTablesLength) 275 } 276 MonsterStart(builder) 277 posOffset := t.Pos.Pack(builder) 278 MonsterAddPos(builder, posOffset) 279 MonsterAddMana(builder, t.Mana) 280 MonsterAddHp(builder, t.Hp) 281 MonsterAddName(builder, nameOffset) 282 MonsterAddInventory(builder, inventoryOffset) 283 MonsterAddColor(builder, t.Color) 284 if t.Test != nil { 285 MonsterAddTestType(builder, t.Test.Type) 286 } 287 MonsterAddTest(builder, testOffset) 288 MonsterAddTest4(builder, test4Offset) 289 MonsterAddTestarrayofstring(builder, testarrayofstringOffset) 290 MonsterAddTestarrayoftables(builder, testarrayoftablesOffset) 291 MonsterAddEnemy(builder, enemyOffset) 292 MonsterAddTestnestedflatbuffer(builder, testnestedflatbufferOffset) 293 MonsterAddTestempty(builder, testemptyOffset) 294 MonsterAddTestbool(builder, t.Testbool) 295 MonsterAddTesthashs32Fnv1(builder, t.Testhashs32Fnv1) 296 MonsterAddTesthashu32Fnv1(builder, t.Testhashu32Fnv1) 297 MonsterAddTesthashs64Fnv1(builder, t.Testhashs64Fnv1) 298 MonsterAddTesthashu64Fnv1(builder, t.Testhashu64Fnv1) 299 MonsterAddTesthashs32Fnv1a(builder, t.Testhashs32Fnv1a) 300 MonsterAddTesthashu32Fnv1a(builder, t.Testhashu32Fnv1a) 301 MonsterAddTesthashs64Fnv1a(builder, t.Testhashs64Fnv1a) 302 MonsterAddTesthashu64Fnv1a(builder, t.Testhashu64Fnv1a) 303 MonsterAddTestarrayofbools(builder, testarrayofboolsOffset) 304 MonsterAddTestf(builder, t.Testf) 305 MonsterAddTestf2(builder, t.Testf2) 306 MonsterAddTestf3(builder, t.Testf3) 307 MonsterAddTestarrayofstring2(builder, testarrayofstring2Offset) 308 MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstructOffset) 309 MonsterAddFlex(builder, flexOffset) 310 MonsterAddTest5(builder, test5Offset) 311 MonsterAddVectorOfLongs(builder, vectorOfLongsOffset) 312 MonsterAddVectorOfDoubles(builder, vectorOfDoublesOffset) 313 MonsterAddParentNamespaceTest(builder, parentNamespaceTestOffset) 314 MonsterAddVectorOfReferrables(builder, vectorOfReferrablesOffset) 315 MonsterAddSingleWeakReference(builder, t.SingleWeakReference) 316 MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferencesOffset) 317 MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrablesOffset) 318 MonsterAddCoOwningReference(builder, t.CoOwningReference) 319 MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferencesOffset) 320 MonsterAddNonOwningReference(builder, t.NonOwningReference) 321 MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferencesOffset) 322 if t.AnyUnique != nil { 323 MonsterAddAnyUniqueType(builder, t.AnyUnique.Type) 324 } 325 MonsterAddAnyUnique(builder, anyUniqueOffset) 326 if t.AnyAmbiguous != nil { 327 MonsterAddAnyAmbiguousType(builder, t.AnyAmbiguous.Type) 328 } 329 MonsterAddAnyAmbiguous(builder, anyAmbiguousOffset) 330 MonsterAddVectorOfEnums(builder, vectorOfEnumsOffset) 331 MonsterAddSignedEnum(builder, t.SignedEnum) 332 MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset) 333 MonsterAddScalarKeySortedTables(builder, scalarKeySortedTablesOffset) 334 nativeInlineOffset := t.NativeInline.Pack(builder) 335 MonsterAddNativeInline(builder, nativeInlineOffset) 336 MonsterAddLongEnumNonEnumDefault(builder, t.LongEnumNonEnumDefault) 337 MonsterAddLongEnumNormalDefault(builder, t.LongEnumNormalDefault) 338 MonsterAddNanDefault(builder, t.NanDefault) 339 MonsterAddInfDefault(builder, t.InfDefault) 340 MonsterAddPositiveInfDefault(builder, t.PositiveInfDefault) 341 MonsterAddInfinityDefault(builder, t.InfinityDefault) 342 MonsterAddPositiveInfinityDefault(builder, t.PositiveInfinityDefault) 343 MonsterAddNegativeInfDefault(builder, t.NegativeInfDefault) 344 MonsterAddNegativeInfinityDefault(builder, t.NegativeInfinityDefault) 345 MonsterAddDoubleInfDefault(builder, t.DoubleInfDefault) 346 return MonsterEnd(builder) 347} 348 349func (rcv *Monster) UnPackTo(t *MonsterT) { 350 t.Pos = rcv.Pos(nil).UnPack() 351 t.Mana = rcv.Mana() 352 t.Hp = rcv.Hp() 353 t.Name = string(rcv.Name()) 354 t.Inventory = rcv.InventoryBytes() 355 t.Color = rcv.Color() 356 testTable := flatbuffers.Table{} 357 if rcv.Test(&testTable) { 358 t.Test = rcv.TestType().UnPack(testTable) 359 } 360 test4Length := rcv.Test4Length() 361 t.Test4 = make([]*TestT, test4Length) 362 for j := 0; j < test4Length; j++ { 363 x := Test{} 364 rcv.Test4(&x, j) 365 t.Test4[j] = x.UnPack() 366 } 367 testarrayofstringLength := rcv.TestarrayofstringLength() 368 t.Testarrayofstring = make([]string, testarrayofstringLength) 369 for j := 0; j < testarrayofstringLength; j++ { 370 t.Testarrayofstring[j] = string(rcv.Testarrayofstring(j)) 371 } 372 testarrayoftablesLength := rcv.TestarrayoftablesLength() 373 t.Testarrayoftables = make([]*MonsterT, testarrayoftablesLength) 374 for j := 0; j < testarrayoftablesLength; j++ { 375 x := Monster{} 376 rcv.Testarrayoftables(&x, j) 377 t.Testarrayoftables[j] = x.UnPack() 378 } 379 t.Enemy = rcv.Enemy(nil).UnPack() 380 t.Testnestedflatbuffer = rcv.TestnestedflatbufferBytes() 381 t.Testempty = rcv.Testempty(nil).UnPack() 382 t.Testbool = rcv.Testbool() 383 t.Testhashs32Fnv1 = rcv.Testhashs32Fnv1() 384 t.Testhashu32Fnv1 = rcv.Testhashu32Fnv1() 385 t.Testhashs64Fnv1 = rcv.Testhashs64Fnv1() 386 t.Testhashu64Fnv1 = rcv.Testhashu64Fnv1() 387 t.Testhashs32Fnv1a = rcv.Testhashs32Fnv1a() 388 t.Testhashu32Fnv1a = rcv.Testhashu32Fnv1a() 389 t.Testhashs64Fnv1a = rcv.Testhashs64Fnv1a() 390 t.Testhashu64Fnv1a = rcv.Testhashu64Fnv1a() 391 testarrayofboolsLength := rcv.TestarrayofboolsLength() 392 t.Testarrayofbools = make([]bool, testarrayofboolsLength) 393 for j := 0; j < testarrayofboolsLength; j++ { 394 t.Testarrayofbools[j] = rcv.Testarrayofbools(j) 395 } 396 t.Testf = rcv.Testf() 397 t.Testf2 = rcv.Testf2() 398 t.Testf3 = rcv.Testf3() 399 testarrayofstring2Length := rcv.Testarrayofstring2Length() 400 t.Testarrayofstring2 = make([]string, testarrayofstring2Length) 401 for j := 0; j < testarrayofstring2Length; j++ { 402 t.Testarrayofstring2[j] = string(rcv.Testarrayofstring2(j)) 403 } 404 testarrayofsortedstructLength := rcv.TestarrayofsortedstructLength() 405 t.Testarrayofsortedstruct = make([]*AbilityT, testarrayofsortedstructLength) 406 for j := 0; j < testarrayofsortedstructLength; j++ { 407 x := Ability{} 408 rcv.Testarrayofsortedstruct(&x, j) 409 t.Testarrayofsortedstruct[j] = x.UnPack() 410 } 411 t.Flex = rcv.FlexBytes() 412 test5Length := rcv.Test5Length() 413 t.Test5 = make([]*TestT, test5Length) 414 for j := 0; j < test5Length; j++ { 415 x := Test{} 416 rcv.Test5(&x, j) 417 t.Test5[j] = x.UnPack() 418 } 419 vectorOfLongsLength := rcv.VectorOfLongsLength() 420 t.VectorOfLongs = make([]int64, vectorOfLongsLength) 421 for j := 0; j < vectorOfLongsLength; j++ { 422 t.VectorOfLongs[j] = rcv.VectorOfLongs(j) 423 } 424 vectorOfDoublesLength := rcv.VectorOfDoublesLength() 425 t.VectorOfDoubles = make([]float64, vectorOfDoublesLength) 426 for j := 0; j < vectorOfDoublesLength; j++ { 427 t.VectorOfDoubles[j] = rcv.VectorOfDoubles(j) 428 } 429 t.ParentNamespaceTest = rcv.ParentNamespaceTest(nil).UnPack() 430 vectorOfReferrablesLength := rcv.VectorOfReferrablesLength() 431 t.VectorOfReferrables = make([]*ReferrableT, vectorOfReferrablesLength) 432 for j := 0; j < vectorOfReferrablesLength; j++ { 433 x := Referrable{} 434 rcv.VectorOfReferrables(&x, j) 435 t.VectorOfReferrables[j] = x.UnPack() 436 } 437 t.SingleWeakReference = rcv.SingleWeakReference() 438 vectorOfWeakReferencesLength := rcv.VectorOfWeakReferencesLength() 439 t.VectorOfWeakReferences = make([]uint64, vectorOfWeakReferencesLength) 440 for j := 0; j < vectorOfWeakReferencesLength; j++ { 441 t.VectorOfWeakReferences[j] = rcv.VectorOfWeakReferences(j) 442 } 443 vectorOfStrongReferrablesLength := rcv.VectorOfStrongReferrablesLength() 444 t.VectorOfStrongReferrables = make([]*ReferrableT, vectorOfStrongReferrablesLength) 445 for j := 0; j < vectorOfStrongReferrablesLength; j++ { 446 x := Referrable{} 447 rcv.VectorOfStrongReferrables(&x, j) 448 t.VectorOfStrongReferrables[j] = x.UnPack() 449 } 450 t.CoOwningReference = rcv.CoOwningReference() 451 vectorOfCoOwningReferencesLength := rcv.VectorOfCoOwningReferencesLength() 452 t.VectorOfCoOwningReferences = make([]uint64, vectorOfCoOwningReferencesLength) 453 for j := 0; j < vectorOfCoOwningReferencesLength; j++ { 454 t.VectorOfCoOwningReferences[j] = rcv.VectorOfCoOwningReferences(j) 455 } 456 t.NonOwningReference = rcv.NonOwningReference() 457 vectorOfNonOwningReferencesLength := rcv.VectorOfNonOwningReferencesLength() 458 t.VectorOfNonOwningReferences = make([]uint64, vectorOfNonOwningReferencesLength) 459 for j := 0; j < vectorOfNonOwningReferencesLength; j++ { 460 t.VectorOfNonOwningReferences[j] = rcv.VectorOfNonOwningReferences(j) 461 } 462 anyUniqueTable := flatbuffers.Table{} 463 if rcv.AnyUnique(&anyUniqueTable) { 464 t.AnyUnique = rcv.AnyUniqueType().UnPack(anyUniqueTable) 465 } 466 anyAmbiguousTable := flatbuffers.Table{} 467 if rcv.AnyAmbiguous(&anyAmbiguousTable) { 468 t.AnyAmbiguous = rcv.AnyAmbiguousType().UnPack(anyAmbiguousTable) 469 } 470 vectorOfEnumsLength := rcv.VectorOfEnumsLength() 471 t.VectorOfEnums = make([]Color, vectorOfEnumsLength) 472 for j := 0; j < vectorOfEnumsLength; j++ { 473 t.VectorOfEnums[j] = rcv.VectorOfEnums(j) 474 } 475 t.SignedEnum = rcv.SignedEnum() 476 t.Testrequirednestedflatbuffer = rcv.TestrequirednestedflatbufferBytes() 477 scalarKeySortedTablesLength := rcv.ScalarKeySortedTablesLength() 478 t.ScalarKeySortedTables = make([]*StatT, scalarKeySortedTablesLength) 479 for j := 0; j < scalarKeySortedTablesLength; j++ { 480 x := Stat{} 481 rcv.ScalarKeySortedTables(&x, j) 482 t.ScalarKeySortedTables[j] = x.UnPack() 483 } 484 t.NativeInline = rcv.NativeInline(nil).UnPack() 485 t.LongEnumNonEnumDefault = rcv.LongEnumNonEnumDefault() 486 t.LongEnumNormalDefault = rcv.LongEnumNormalDefault() 487 t.NanDefault = rcv.NanDefault() 488 t.InfDefault = rcv.InfDefault() 489 t.PositiveInfDefault = rcv.PositiveInfDefault() 490 t.InfinityDefault = rcv.InfinityDefault() 491 t.PositiveInfinityDefault = rcv.PositiveInfinityDefault() 492 t.NegativeInfDefault = rcv.NegativeInfDefault() 493 t.NegativeInfinityDefault = rcv.NegativeInfinityDefault() 494 t.DoubleInfDefault = rcv.DoubleInfDefault() 495} 496 497func (rcv *Monster) UnPack() *MonsterT { 498 if rcv == nil { 499 return nil 500 } 501 t := &MonsterT{} 502 rcv.UnPackTo(t) 503 return t 504} 505 506type Monster struct { 507 _tab flatbuffers.Table 508} 509 510const MonsterIdentifier = "MONS" 511 512func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster { 513 n := flatbuffers.GetUOffsetT(buf[offset:]) 514 x := &Monster{} 515 x.Init(buf, n+offset) 516 return x 517} 518 519func FinishMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { 520 identifierBytes := []byte(MonsterIdentifier) 521 builder.FinishWithFileIdentifier(offset, identifierBytes) 522} 523 524func MonsterBufferHasIdentifier(buf []byte) bool { 525 return flatbuffers.BufferHasIdentifier(buf, MonsterIdentifier) 526} 527 528func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster { 529 n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) 530 x := &Monster{} 531 x.Init(buf, n+offset+flatbuffers.SizeUint32) 532 return x 533} 534 535func FinishSizePrefixedMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { 536 identifierBytes := []byte(MonsterIdentifier) 537 builder.FinishSizePrefixedWithFileIdentifier(offset, identifierBytes) 538} 539 540func SizePrefixedMonsterBufferHasIdentifier(buf []byte) bool { 541 return flatbuffers.SizePrefixedBufferHasIdentifier(buf, MonsterIdentifier) 542} 543 544func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) { 545 rcv._tab.Bytes = buf 546 rcv._tab.Pos = i 547} 548 549func (rcv *Monster) Table() flatbuffers.Table { 550 return rcv._tab 551} 552 553func (rcv *Monster) Pos(obj *Vec3) *Vec3 { 554 o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 555 if o != 0 { 556 x := o + rcv._tab.Pos 557 if obj == nil { 558 obj = new(Vec3) 559 } 560 obj.Init(rcv._tab.Bytes, x) 561 return obj 562 } 563 return nil 564} 565 566func (rcv *Monster) Mana() int16 { 567 o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 568 if o != 0 { 569 return rcv._tab.GetInt16(o + rcv._tab.Pos) 570 } 571 return 150 572} 573 574func (rcv *Monster) MutateMana(n int16) bool { 575 return rcv._tab.MutateInt16Slot(6, n) 576} 577 578func (rcv *Monster) Hp() int16 { 579 o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 580 if o != 0 { 581 return rcv._tab.GetInt16(o + rcv._tab.Pos) 582 } 583 return 100 584} 585 586func (rcv *Monster) MutateHp(n int16) bool { 587 return rcv._tab.MutateInt16Slot(8, n) 588} 589 590func (rcv *Monster) Name() []byte { 591 o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 592 if o != 0 { 593 return rcv._tab.ByteVector(o + rcv._tab.Pos) 594 } 595 return nil 596} 597 598func MonsterKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { 599 obj1 := &Monster{} 600 obj2 := &Monster{} 601 obj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1) 602 obj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2) 603 return string(obj1.Name()) < string(obj2.Name()) 604} 605 606func (rcv *Monster) LookupByKey(key string, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { 607 span := flatbuffers.GetUOffsetT(buf[vectorLocation-4:]) 608 start := flatbuffers.UOffsetT(0) 609 bKey := []byte(key) 610 for span != 0 { 611 middle := span / 2 612 tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+4*(start+middle)) 613 obj := &Monster{} 614 obj.Init(buf, tableOffset) 615 comp := bytes.Compare(obj.Name(), bKey) 616 if comp > 0 { 617 span = middle 618 } else if comp < 0 { 619 middle += 1 620 start += middle 621 span -= middle 622 } else { 623 rcv.Init(buf, tableOffset) 624 return true 625 } 626 } 627 return false 628} 629 630func (rcv *Monster) Inventory(j int) byte { 631 o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 632 if o != 0 { 633 a := rcv._tab.Vector(o) 634 return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) 635 } 636 return 0 637} 638 639func (rcv *Monster) InventoryLength() int { 640 o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 641 if o != 0 { 642 return rcv._tab.VectorLen(o) 643 } 644 return 0 645} 646 647func (rcv *Monster) InventoryBytes() []byte { 648 o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 649 if o != 0 { 650 return rcv._tab.ByteVector(o + rcv._tab.Pos) 651 } 652 return nil 653} 654 655func (rcv *Monster) MutateInventory(j int, n byte) bool { 656 o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 657 if o != 0 { 658 a := rcv._tab.Vector(o) 659 return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) 660 } 661 return false 662} 663 664func (rcv *Monster) Color() Color { 665 o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) 666 if o != 0 { 667 return Color(rcv._tab.GetByte(o + rcv._tab.Pos)) 668 } 669 return 8 670} 671 672func (rcv *Monster) MutateColor(n Color) bool { 673 return rcv._tab.MutateByteSlot(16, byte(n)) 674} 675 676func (rcv *Monster) TestType() Any { 677 o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) 678 if o != 0 { 679 return Any(rcv._tab.GetByte(o + rcv._tab.Pos)) 680 } 681 return 0 682} 683 684func (rcv *Monster) MutateTestType(n Any) bool { 685 return rcv._tab.MutateByteSlot(18, byte(n)) 686} 687 688func (rcv *Monster) Test(obj *flatbuffers.Table) bool { 689 o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) 690 if o != 0 { 691 rcv._tab.Union(obj, o) 692 return true 693 } 694 return false 695} 696 697func (rcv *Monster) Test4(obj *Test, j int) bool { 698 o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) 699 if o != 0 { 700 x := rcv._tab.Vector(o) 701 x += flatbuffers.UOffsetT(j) * 4 702 obj.Init(rcv._tab.Bytes, x) 703 return true 704 } 705 return false 706} 707 708func (rcv *Monster) Test4Length() int { 709 o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) 710 if o != 0 { 711 return rcv._tab.VectorLen(o) 712 } 713 return 0 714} 715 716func (rcv *Monster) Testarrayofstring(j int) []byte { 717 o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) 718 if o != 0 { 719 a := rcv._tab.Vector(o) 720 return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) 721 } 722 return nil 723} 724 725func (rcv *Monster) TestarrayofstringLength() int { 726 o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) 727 if o != 0 { 728 return rcv._tab.VectorLen(o) 729 } 730 return 0 731} 732 733/// an example documentation comment: this will end up in the generated code 734/// multiline too 735func (rcv *Monster) Testarrayoftables(obj *Monster, j int) bool { 736 o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) 737 if o != 0 { 738 x := rcv._tab.Vector(o) 739 x += flatbuffers.UOffsetT(j) * 4 740 x = rcv._tab.Indirect(x) 741 obj.Init(rcv._tab.Bytes, x) 742 return true 743 } 744 return false 745} 746 747func (rcv *Monster) TestarrayoftablesByKey(obj *Monster, key string) bool { 748 o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) 749 if o != 0 { 750 x := rcv._tab.Vector(o) 751 return obj.LookupByKey(key, x, rcv._tab.Bytes) 752 } 753 return false 754} 755 756func (rcv *Monster) TestarrayoftablesLength() int { 757 o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) 758 if o != 0 { 759 return rcv._tab.VectorLen(o) 760 } 761 return 0 762} 763 764/// an example documentation comment: this will end up in the generated code 765/// multiline too 766func (rcv *Monster) Enemy(obj *Monster) *Monster { 767 o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) 768 if o != 0 { 769 x := rcv._tab.Indirect(o + rcv._tab.Pos) 770 if obj == nil { 771 obj = new(Monster) 772 } 773 obj.Init(rcv._tab.Bytes, x) 774 return obj 775 } 776 return nil 777} 778 779func (rcv *Monster) Testnestedflatbuffer(j int) byte { 780 o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) 781 if o != 0 { 782 a := rcv._tab.Vector(o) 783 return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) 784 } 785 return 0 786} 787 788func (rcv *Monster) TestnestedflatbufferLength() int { 789 o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) 790 if o != 0 { 791 return rcv._tab.VectorLen(o) 792 } 793 return 0 794} 795 796func (rcv *Monster) TestnestedflatbufferBytes() []byte { 797 o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) 798 if o != 0 { 799 return rcv._tab.ByteVector(o + rcv._tab.Pos) 800 } 801 return nil 802} 803 804func (rcv *Monster) MutateTestnestedflatbuffer(j int, n byte) bool { 805 o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) 806 if o != 0 { 807 a := rcv._tab.Vector(o) 808 return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) 809 } 810 return false 811} 812 813func (rcv *Monster) Testempty(obj *Stat) *Stat { 814 o := flatbuffers.UOffsetT(rcv._tab.Offset(32)) 815 if o != 0 { 816 x := rcv._tab.Indirect(o + rcv._tab.Pos) 817 if obj == nil { 818 obj = new(Stat) 819 } 820 obj.Init(rcv._tab.Bytes, x) 821 return obj 822 } 823 return nil 824} 825 826func (rcv *Monster) Testbool() bool { 827 o := flatbuffers.UOffsetT(rcv._tab.Offset(34)) 828 if o != 0 { 829 return rcv._tab.GetBool(o + rcv._tab.Pos) 830 } 831 return false 832} 833 834func (rcv *Monster) MutateTestbool(n bool) bool { 835 return rcv._tab.MutateBoolSlot(34, n) 836} 837 838func (rcv *Monster) Testhashs32Fnv1() int32 { 839 o := flatbuffers.UOffsetT(rcv._tab.Offset(36)) 840 if o != 0 { 841 return rcv._tab.GetInt32(o + rcv._tab.Pos) 842 } 843 return 0 844} 845 846func (rcv *Monster) MutateTesthashs32Fnv1(n int32) bool { 847 return rcv._tab.MutateInt32Slot(36, n) 848} 849 850func (rcv *Monster) Testhashu32Fnv1() uint32 { 851 o := flatbuffers.UOffsetT(rcv._tab.Offset(38)) 852 if o != 0 { 853 return rcv._tab.GetUint32(o + rcv._tab.Pos) 854 } 855 return 0 856} 857 858func (rcv *Monster) MutateTesthashu32Fnv1(n uint32) bool { 859 return rcv._tab.MutateUint32Slot(38, n) 860} 861 862func (rcv *Monster) Testhashs64Fnv1() int64 { 863 o := flatbuffers.UOffsetT(rcv._tab.Offset(40)) 864 if o != 0 { 865 return rcv._tab.GetInt64(o + rcv._tab.Pos) 866 } 867 return 0 868} 869 870func (rcv *Monster) MutateTesthashs64Fnv1(n int64) bool { 871 return rcv._tab.MutateInt64Slot(40, n) 872} 873 874func (rcv *Monster) Testhashu64Fnv1() uint64 { 875 o := flatbuffers.UOffsetT(rcv._tab.Offset(42)) 876 if o != 0 { 877 return rcv._tab.GetUint64(o + rcv._tab.Pos) 878 } 879 return 0 880} 881 882func (rcv *Monster) MutateTesthashu64Fnv1(n uint64) bool { 883 return rcv._tab.MutateUint64Slot(42, n) 884} 885 886func (rcv *Monster) Testhashs32Fnv1a() int32 { 887 o := flatbuffers.UOffsetT(rcv._tab.Offset(44)) 888 if o != 0 { 889 return rcv._tab.GetInt32(o + rcv._tab.Pos) 890 } 891 return 0 892} 893 894func (rcv *Monster) MutateTesthashs32Fnv1a(n int32) bool { 895 return rcv._tab.MutateInt32Slot(44, n) 896} 897 898func (rcv *Monster) Testhashu32Fnv1a() uint32 { 899 o := flatbuffers.UOffsetT(rcv._tab.Offset(46)) 900 if o != 0 { 901 return rcv._tab.GetUint32(o + rcv._tab.Pos) 902 } 903 return 0 904} 905 906func (rcv *Monster) MutateTesthashu32Fnv1a(n uint32) bool { 907 return rcv._tab.MutateUint32Slot(46, n) 908} 909 910func (rcv *Monster) Testhashs64Fnv1a() int64 { 911 o := flatbuffers.UOffsetT(rcv._tab.Offset(48)) 912 if o != 0 { 913 return rcv._tab.GetInt64(o + rcv._tab.Pos) 914 } 915 return 0 916} 917 918func (rcv *Monster) MutateTesthashs64Fnv1a(n int64) bool { 919 return rcv._tab.MutateInt64Slot(48, n) 920} 921 922func (rcv *Monster) Testhashu64Fnv1a() uint64 { 923 o := flatbuffers.UOffsetT(rcv._tab.Offset(50)) 924 if o != 0 { 925 return rcv._tab.GetUint64(o + rcv._tab.Pos) 926 } 927 return 0 928} 929 930func (rcv *Monster) MutateTesthashu64Fnv1a(n uint64) bool { 931 return rcv._tab.MutateUint64Slot(50, n) 932} 933 934func (rcv *Monster) Testarrayofbools(j int) bool { 935 o := flatbuffers.UOffsetT(rcv._tab.Offset(52)) 936 if o != 0 { 937 a := rcv._tab.Vector(o) 938 return rcv._tab.GetBool(a + flatbuffers.UOffsetT(j*1)) 939 } 940 return false 941} 942 943func (rcv *Monster) TestarrayofboolsLength() int { 944 o := flatbuffers.UOffsetT(rcv._tab.Offset(52)) 945 if o != 0 { 946 return rcv._tab.VectorLen(o) 947 } 948 return 0 949} 950 951func (rcv *Monster) MutateTestarrayofbools(j int, n bool) bool { 952 o := flatbuffers.UOffsetT(rcv._tab.Offset(52)) 953 if o != 0 { 954 a := rcv._tab.Vector(o) 955 return rcv._tab.MutateBool(a+flatbuffers.UOffsetT(j*1), n) 956 } 957 return false 958} 959 960func (rcv *Monster) Testf() float32 { 961 o := flatbuffers.UOffsetT(rcv._tab.Offset(54)) 962 if o != 0 { 963 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 964 } 965 return 3.14159 966} 967 968func (rcv *Monster) MutateTestf(n float32) bool { 969 return rcv._tab.MutateFloat32Slot(54, n) 970} 971 972func (rcv *Monster) Testf2() float32 { 973 o := flatbuffers.UOffsetT(rcv._tab.Offset(56)) 974 if o != 0 { 975 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 976 } 977 return 3.0 978} 979 980func (rcv *Monster) MutateTestf2(n float32) bool { 981 return rcv._tab.MutateFloat32Slot(56, n) 982} 983 984func (rcv *Monster) Testf3() float32 { 985 o := flatbuffers.UOffsetT(rcv._tab.Offset(58)) 986 if o != 0 { 987 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 988 } 989 return 0.0 990} 991 992func (rcv *Monster) MutateTestf3(n float32) bool { 993 return rcv._tab.MutateFloat32Slot(58, n) 994} 995 996func (rcv *Monster) Testarrayofstring2(j int) []byte { 997 o := flatbuffers.UOffsetT(rcv._tab.Offset(60)) 998 if o != 0 { 999 a := rcv._tab.Vector(o) 1000 return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) 1001 } 1002 return nil 1003} 1004 1005func (rcv *Monster) Testarrayofstring2Length() int { 1006 o := flatbuffers.UOffsetT(rcv._tab.Offset(60)) 1007 if o != 0 { 1008 return rcv._tab.VectorLen(o) 1009 } 1010 return 0 1011} 1012 1013func (rcv *Monster) Testarrayofsortedstruct(obj *Ability, j int) bool { 1014 o := flatbuffers.UOffsetT(rcv._tab.Offset(62)) 1015 if o != 0 { 1016 x := rcv._tab.Vector(o) 1017 x += flatbuffers.UOffsetT(j) * 8 1018 obj.Init(rcv._tab.Bytes, x) 1019 return true 1020 } 1021 return false 1022} 1023 1024func (rcv *Monster) TestarrayofsortedstructLength() int { 1025 o := flatbuffers.UOffsetT(rcv._tab.Offset(62)) 1026 if o != 0 { 1027 return rcv._tab.VectorLen(o) 1028 } 1029 return 0 1030} 1031 1032func (rcv *Monster) Flex(j int) byte { 1033 o := flatbuffers.UOffsetT(rcv._tab.Offset(64)) 1034 if o != 0 { 1035 a := rcv._tab.Vector(o) 1036 return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) 1037 } 1038 return 0 1039} 1040 1041func (rcv *Monster) FlexLength() int { 1042 o := flatbuffers.UOffsetT(rcv._tab.Offset(64)) 1043 if o != 0 { 1044 return rcv._tab.VectorLen(o) 1045 } 1046 return 0 1047} 1048 1049func (rcv *Monster) FlexBytes() []byte { 1050 o := flatbuffers.UOffsetT(rcv._tab.Offset(64)) 1051 if o != 0 { 1052 return rcv._tab.ByteVector(o + rcv._tab.Pos) 1053 } 1054 return nil 1055} 1056 1057func (rcv *Monster) MutateFlex(j int, n byte) bool { 1058 o := flatbuffers.UOffsetT(rcv._tab.Offset(64)) 1059 if o != 0 { 1060 a := rcv._tab.Vector(o) 1061 return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) 1062 } 1063 return false 1064} 1065 1066func (rcv *Monster) Test5(obj *Test, j int) bool { 1067 o := flatbuffers.UOffsetT(rcv._tab.Offset(66)) 1068 if o != 0 { 1069 x := rcv._tab.Vector(o) 1070 x += flatbuffers.UOffsetT(j) * 4 1071 obj.Init(rcv._tab.Bytes, x) 1072 return true 1073 } 1074 return false 1075} 1076 1077func (rcv *Monster) Test5Length() int { 1078 o := flatbuffers.UOffsetT(rcv._tab.Offset(66)) 1079 if o != 0 { 1080 return rcv._tab.VectorLen(o) 1081 } 1082 return 0 1083} 1084 1085func (rcv *Monster) VectorOfLongs(j int) int64 { 1086 o := flatbuffers.UOffsetT(rcv._tab.Offset(68)) 1087 if o != 0 { 1088 a := rcv._tab.Vector(o) 1089 return rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8)) 1090 } 1091 return 0 1092} 1093 1094func (rcv *Monster) VectorOfLongsLength() int { 1095 o := flatbuffers.UOffsetT(rcv._tab.Offset(68)) 1096 if o != 0 { 1097 return rcv._tab.VectorLen(o) 1098 } 1099 return 0 1100} 1101 1102func (rcv *Monster) MutateVectorOfLongs(j int, n int64) bool { 1103 o := flatbuffers.UOffsetT(rcv._tab.Offset(68)) 1104 if o != 0 { 1105 a := rcv._tab.Vector(o) 1106 return rcv._tab.MutateInt64(a+flatbuffers.UOffsetT(j*8), n) 1107 } 1108 return false 1109} 1110 1111func (rcv *Monster) VectorOfDoubles(j int) float64 { 1112 o := flatbuffers.UOffsetT(rcv._tab.Offset(70)) 1113 if o != 0 { 1114 a := rcv._tab.Vector(o) 1115 return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) 1116 } 1117 return 0 1118} 1119 1120func (rcv *Monster) VectorOfDoublesLength() int { 1121 o := flatbuffers.UOffsetT(rcv._tab.Offset(70)) 1122 if o != 0 { 1123 return rcv._tab.VectorLen(o) 1124 } 1125 return 0 1126} 1127 1128func (rcv *Monster) MutateVectorOfDoubles(j int, n float64) bool { 1129 o := flatbuffers.UOffsetT(rcv._tab.Offset(70)) 1130 if o != 0 { 1131 a := rcv._tab.Vector(o) 1132 return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n) 1133 } 1134 return false 1135} 1136 1137func (rcv *Monster) ParentNamespaceTest(obj *MyGame.InParentNamespace) *MyGame.InParentNamespace { 1138 o := flatbuffers.UOffsetT(rcv._tab.Offset(72)) 1139 if o != 0 { 1140 x := rcv._tab.Indirect(o + rcv._tab.Pos) 1141 if obj == nil { 1142 obj = new(MyGame.InParentNamespace) 1143 } 1144 obj.Init(rcv._tab.Bytes, x) 1145 return obj 1146 } 1147 return nil 1148} 1149 1150func (rcv *Monster) VectorOfReferrables(obj *Referrable, j int) bool { 1151 o := flatbuffers.UOffsetT(rcv._tab.Offset(74)) 1152 if o != 0 { 1153 x := rcv._tab.Vector(o) 1154 x += flatbuffers.UOffsetT(j) * 4 1155 x = rcv._tab.Indirect(x) 1156 obj.Init(rcv._tab.Bytes, x) 1157 return true 1158 } 1159 return false 1160} 1161 1162func (rcv *Monster) VectorOfReferrablesByKey(obj *Referrable, key uint64) bool { 1163 o := flatbuffers.UOffsetT(rcv._tab.Offset(74)) 1164 if o != 0 { 1165 x := rcv._tab.Vector(o) 1166 return obj.LookupByKey(key, x, rcv._tab.Bytes) 1167 } 1168 return false 1169} 1170 1171func (rcv *Monster) VectorOfReferrablesLength() int { 1172 o := flatbuffers.UOffsetT(rcv._tab.Offset(74)) 1173 if o != 0 { 1174 return rcv._tab.VectorLen(o) 1175 } 1176 return 0 1177} 1178 1179func (rcv *Monster) SingleWeakReference() uint64 { 1180 o := flatbuffers.UOffsetT(rcv._tab.Offset(76)) 1181 if o != 0 { 1182 return rcv._tab.GetUint64(o + rcv._tab.Pos) 1183 } 1184 return 0 1185} 1186 1187func (rcv *Monster) MutateSingleWeakReference(n uint64) bool { 1188 return rcv._tab.MutateUint64Slot(76, n) 1189} 1190 1191func (rcv *Monster) VectorOfWeakReferences(j int) uint64 { 1192 o := flatbuffers.UOffsetT(rcv._tab.Offset(78)) 1193 if o != 0 { 1194 a := rcv._tab.Vector(o) 1195 return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) 1196 } 1197 return 0 1198} 1199 1200func (rcv *Monster) VectorOfWeakReferencesLength() int { 1201 o := flatbuffers.UOffsetT(rcv._tab.Offset(78)) 1202 if o != 0 { 1203 return rcv._tab.VectorLen(o) 1204 } 1205 return 0 1206} 1207 1208func (rcv *Monster) MutateVectorOfWeakReferences(j int, n uint64) bool { 1209 o := flatbuffers.UOffsetT(rcv._tab.Offset(78)) 1210 if o != 0 { 1211 a := rcv._tab.Vector(o) 1212 return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) 1213 } 1214 return false 1215} 1216 1217func (rcv *Monster) VectorOfStrongReferrables(obj *Referrable, j int) bool { 1218 o := flatbuffers.UOffsetT(rcv._tab.Offset(80)) 1219 if o != 0 { 1220 x := rcv._tab.Vector(o) 1221 x += flatbuffers.UOffsetT(j) * 4 1222 x = rcv._tab.Indirect(x) 1223 obj.Init(rcv._tab.Bytes, x) 1224 return true 1225 } 1226 return false 1227} 1228 1229func (rcv *Monster) VectorOfStrongReferrablesByKey(obj *Referrable, key uint64) bool { 1230 o := flatbuffers.UOffsetT(rcv._tab.Offset(80)) 1231 if o != 0 { 1232 x := rcv._tab.Vector(o) 1233 return obj.LookupByKey(key, x, rcv._tab.Bytes) 1234 } 1235 return false 1236} 1237 1238func (rcv *Monster) VectorOfStrongReferrablesLength() int { 1239 o := flatbuffers.UOffsetT(rcv._tab.Offset(80)) 1240 if o != 0 { 1241 return rcv._tab.VectorLen(o) 1242 } 1243 return 0 1244} 1245 1246func (rcv *Monster) CoOwningReference() uint64 { 1247 o := flatbuffers.UOffsetT(rcv._tab.Offset(82)) 1248 if o != 0 { 1249 return rcv._tab.GetUint64(o + rcv._tab.Pos) 1250 } 1251 return 0 1252} 1253 1254func (rcv *Monster) MutateCoOwningReference(n uint64) bool { 1255 return rcv._tab.MutateUint64Slot(82, n) 1256} 1257 1258func (rcv *Monster) VectorOfCoOwningReferences(j int) uint64 { 1259 o := flatbuffers.UOffsetT(rcv._tab.Offset(84)) 1260 if o != 0 { 1261 a := rcv._tab.Vector(o) 1262 return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) 1263 } 1264 return 0 1265} 1266 1267func (rcv *Monster) VectorOfCoOwningReferencesLength() int { 1268 o := flatbuffers.UOffsetT(rcv._tab.Offset(84)) 1269 if o != 0 { 1270 return rcv._tab.VectorLen(o) 1271 } 1272 return 0 1273} 1274 1275func (rcv *Monster) MutateVectorOfCoOwningReferences(j int, n uint64) bool { 1276 o := flatbuffers.UOffsetT(rcv._tab.Offset(84)) 1277 if o != 0 { 1278 a := rcv._tab.Vector(o) 1279 return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) 1280 } 1281 return false 1282} 1283 1284func (rcv *Monster) NonOwningReference() uint64 { 1285 o := flatbuffers.UOffsetT(rcv._tab.Offset(86)) 1286 if o != 0 { 1287 return rcv._tab.GetUint64(o + rcv._tab.Pos) 1288 } 1289 return 0 1290} 1291 1292func (rcv *Monster) MutateNonOwningReference(n uint64) bool { 1293 return rcv._tab.MutateUint64Slot(86, n) 1294} 1295 1296func (rcv *Monster) VectorOfNonOwningReferences(j int) uint64 { 1297 o := flatbuffers.UOffsetT(rcv._tab.Offset(88)) 1298 if o != 0 { 1299 a := rcv._tab.Vector(o) 1300 return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) 1301 } 1302 return 0 1303} 1304 1305func (rcv *Monster) VectorOfNonOwningReferencesLength() int { 1306 o := flatbuffers.UOffsetT(rcv._tab.Offset(88)) 1307 if o != 0 { 1308 return rcv._tab.VectorLen(o) 1309 } 1310 return 0 1311} 1312 1313func (rcv *Monster) MutateVectorOfNonOwningReferences(j int, n uint64) bool { 1314 o := flatbuffers.UOffsetT(rcv._tab.Offset(88)) 1315 if o != 0 { 1316 a := rcv._tab.Vector(o) 1317 return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) 1318 } 1319 return false 1320} 1321 1322func (rcv *Monster) AnyUniqueType() AnyUniqueAliases { 1323 o := flatbuffers.UOffsetT(rcv._tab.Offset(90)) 1324 if o != 0 { 1325 return AnyUniqueAliases(rcv._tab.GetByte(o + rcv._tab.Pos)) 1326 } 1327 return 0 1328} 1329 1330func (rcv *Monster) MutateAnyUniqueType(n AnyUniqueAliases) bool { 1331 return rcv._tab.MutateByteSlot(90, byte(n)) 1332} 1333 1334func (rcv *Monster) AnyUnique(obj *flatbuffers.Table) bool { 1335 o := flatbuffers.UOffsetT(rcv._tab.Offset(92)) 1336 if o != 0 { 1337 rcv._tab.Union(obj, o) 1338 return true 1339 } 1340 return false 1341} 1342 1343func (rcv *Monster) AnyAmbiguousType() AnyAmbiguousAliases { 1344 o := flatbuffers.UOffsetT(rcv._tab.Offset(94)) 1345 if o != 0 { 1346 return AnyAmbiguousAliases(rcv._tab.GetByte(o + rcv._tab.Pos)) 1347 } 1348 return 0 1349} 1350 1351func (rcv *Monster) MutateAnyAmbiguousType(n AnyAmbiguousAliases) bool { 1352 return rcv._tab.MutateByteSlot(94, byte(n)) 1353} 1354 1355func (rcv *Monster) AnyAmbiguous(obj *flatbuffers.Table) bool { 1356 o := flatbuffers.UOffsetT(rcv._tab.Offset(96)) 1357 if o != 0 { 1358 rcv._tab.Union(obj, o) 1359 return true 1360 } 1361 return false 1362} 1363 1364func (rcv *Monster) VectorOfEnums(j int) Color { 1365 o := flatbuffers.UOffsetT(rcv._tab.Offset(98)) 1366 if o != 0 { 1367 a := rcv._tab.Vector(o) 1368 return Color(rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))) 1369 } 1370 return 0 1371} 1372 1373func (rcv *Monster) VectorOfEnumsLength() int { 1374 o := flatbuffers.UOffsetT(rcv._tab.Offset(98)) 1375 if o != 0 { 1376 return rcv._tab.VectorLen(o) 1377 } 1378 return 0 1379} 1380 1381func (rcv *Monster) VectorOfEnumsBytes() []byte { 1382 o := flatbuffers.UOffsetT(rcv._tab.Offset(98)) 1383 if o != 0 { 1384 return rcv._tab.ByteVector(o + rcv._tab.Pos) 1385 } 1386 return nil 1387} 1388 1389func (rcv *Monster) MutateVectorOfEnums(j int, n Color) bool { 1390 o := flatbuffers.UOffsetT(rcv._tab.Offset(98)) 1391 if o != 0 { 1392 a := rcv._tab.Vector(o) 1393 return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), byte(n)) 1394 } 1395 return false 1396} 1397 1398func (rcv *Monster) SignedEnum() Race { 1399 o := flatbuffers.UOffsetT(rcv._tab.Offset(100)) 1400 if o != 0 { 1401 return Race(rcv._tab.GetInt8(o + rcv._tab.Pos)) 1402 } 1403 return -1 1404} 1405 1406func (rcv *Monster) MutateSignedEnum(n Race) bool { 1407 return rcv._tab.MutateInt8Slot(100, int8(n)) 1408} 1409 1410func (rcv *Monster) Testrequirednestedflatbuffer(j int) byte { 1411 o := flatbuffers.UOffsetT(rcv._tab.Offset(102)) 1412 if o != 0 { 1413 a := rcv._tab.Vector(o) 1414 return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) 1415 } 1416 return 0 1417} 1418 1419func (rcv *Monster) TestrequirednestedflatbufferLength() int { 1420 o := flatbuffers.UOffsetT(rcv._tab.Offset(102)) 1421 if o != 0 { 1422 return rcv._tab.VectorLen(o) 1423 } 1424 return 0 1425} 1426 1427func (rcv *Monster) TestrequirednestedflatbufferBytes() []byte { 1428 o := flatbuffers.UOffsetT(rcv._tab.Offset(102)) 1429 if o != 0 { 1430 return rcv._tab.ByteVector(o + rcv._tab.Pos) 1431 } 1432 return nil 1433} 1434 1435func (rcv *Monster) MutateTestrequirednestedflatbuffer(j int, n byte) bool { 1436 o := flatbuffers.UOffsetT(rcv._tab.Offset(102)) 1437 if o != 0 { 1438 a := rcv._tab.Vector(o) 1439 return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) 1440 } 1441 return false 1442} 1443 1444func (rcv *Monster) ScalarKeySortedTables(obj *Stat, j int) bool { 1445 o := flatbuffers.UOffsetT(rcv._tab.Offset(104)) 1446 if o != 0 { 1447 x := rcv._tab.Vector(o) 1448 x += flatbuffers.UOffsetT(j) * 4 1449 x = rcv._tab.Indirect(x) 1450 obj.Init(rcv._tab.Bytes, x) 1451 return true 1452 } 1453 return false 1454} 1455 1456func (rcv *Monster) ScalarKeySortedTablesByKey(obj *Stat, key uint16) bool { 1457 o := flatbuffers.UOffsetT(rcv._tab.Offset(104)) 1458 if o != 0 { 1459 x := rcv._tab.Vector(o) 1460 return obj.LookupByKey(key, x, rcv._tab.Bytes) 1461 } 1462 return false 1463} 1464 1465func (rcv *Monster) ScalarKeySortedTablesLength() int { 1466 o := flatbuffers.UOffsetT(rcv._tab.Offset(104)) 1467 if o != 0 { 1468 return rcv._tab.VectorLen(o) 1469 } 1470 return 0 1471} 1472 1473func (rcv *Monster) NativeInline(obj *Test) *Test { 1474 o := flatbuffers.UOffsetT(rcv._tab.Offset(106)) 1475 if o != 0 { 1476 x := o + rcv._tab.Pos 1477 if obj == nil { 1478 obj = new(Test) 1479 } 1480 obj.Init(rcv._tab.Bytes, x) 1481 return obj 1482 } 1483 return nil 1484} 1485 1486func (rcv *Monster) LongEnumNonEnumDefault() LongEnum { 1487 o := flatbuffers.UOffsetT(rcv._tab.Offset(108)) 1488 if o != 0 { 1489 return LongEnum(rcv._tab.GetUint64(o + rcv._tab.Pos)) 1490 } 1491 return 0 1492} 1493 1494func (rcv *Monster) MutateLongEnumNonEnumDefault(n LongEnum) bool { 1495 return rcv._tab.MutateUint64Slot(108, uint64(n)) 1496} 1497 1498func (rcv *Monster) LongEnumNormalDefault() LongEnum { 1499 o := flatbuffers.UOffsetT(rcv._tab.Offset(110)) 1500 if o != 0 { 1501 return LongEnum(rcv._tab.GetUint64(o + rcv._tab.Pos)) 1502 } 1503 return 2 1504} 1505 1506func (rcv *Monster) MutateLongEnumNormalDefault(n LongEnum) bool { 1507 return rcv._tab.MutateUint64Slot(110, uint64(n)) 1508} 1509 1510func (rcv *Monster) NanDefault() float32 { 1511 o := flatbuffers.UOffsetT(rcv._tab.Offset(112)) 1512 if o != 0 { 1513 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 1514 } 1515 return float32(math.NaN()) 1516} 1517 1518func (rcv *Monster) MutateNanDefault(n float32) bool { 1519 return rcv._tab.MutateFloat32Slot(112, n) 1520} 1521 1522func (rcv *Monster) InfDefault() float32 { 1523 o := flatbuffers.UOffsetT(rcv._tab.Offset(114)) 1524 if o != 0 { 1525 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 1526 } 1527 return float32(math.Inf(1)) 1528} 1529 1530func (rcv *Monster) MutateInfDefault(n float32) bool { 1531 return rcv._tab.MutateFloat32Slot(114, n) 1532} 1533 1534func (rcv *Monster) PositiveInfDefault() float32 { 1535 o := flatbuffers.UOffsetT(rcv._tab.Offset(116)) 1536 if o != 0 { 1537 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 1538 } 1539 return float32(math.Inf(1)) 1540} 1541 1542func (rcv *Monster) MutatePositiveInfDefault(n float32) bool { 1543 return rcv._tab.MutateFloat32Slot(116, n) 1544} 1545 1546func (rcv *Monster) InfinityDefault() float32 { 1547 o := flatbuffers.UOffsetT(rcv._tab.Offset(118)) 1548 if o != 0 { 1549 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 1550 } 1551 return float32(math.Inf(1)) 1552} 1553 1554func (rcv *Monster) MutateInfinityDefault(n float32) bool { 1555 return rcv._tab.MutateFloat32Slot(118, n) 1556} 1557 1558func (rcv *Monster) PositiveInfinityDefault() float32 { 1559 o := flatbuffers.UOffsetT(rcv._tab.Offset(120)) 1560 if o != 0 { 1561 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 1562 } 1563 return float32(math.Inf(1)) 1564} 1565 1566func (rcv *Monster) MutatePositiveInfinityDefault(n float32) bool { 1567 return rcv._tab.MutateFloat32Slot(120, n) 1568} 1569 1570func (rcv *Monster) NegativeInfDefault() float32 { 1571 o := flatbuffers.UOffsetT(rcv._tab.Offset(122)) 1572 if o != 0 { 1573 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 1574 } 1575 return float32(math.Inf(-1)) 1576} 1577 1578func (rcv *Monster) MutateNegativeInfDefault(n float32) bool { 1579 return rcv._tab.MutateFloat32Slot(122, n) 1580} 1581 1582func (rcv *Monster) NegativeInfinityDefault() float32 { 1583 o := flatbuffers.UOffsetT(rcv._tab.Offset(124)) 1584 if o != 0 { 1585 return rcv._tab.GetFloat32(o + rcv._tab.Pos) 1586 } 1587 return float32(math.Inf(-1)) 1588} 1589 1590func (rcv *Monster) MutateNegativeInfinityDefault(n float32) bool { 1591 return rcv._tab.MutateFloat32Slot(124, n) 1592} 1593 1594func (rcv *Monster) DoubleInfDefault() float64 { 1595 o := flatbuffers.UOffsetT(rcv._tab.Offset(126)) 1596 if o != 0 { 1597 return rcv._tab.GetFloat64(o + rcv._tab.Pos) 1598 } 1599 return float64(math.Inf(1)) 1600} 1601 1602func (rcv *Monster) MutateDoubleInfDefault(n float64) bool { 1603 return rcv._tab.MutateFloat64Slot(126, n) 1604} 1605 1606func MonsterStart(builder *flatbuffers.Builder) { 1607 builder.StartObject(62) 1608} 1609func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) { 1610 builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0) 1611} 1612func MonsterAddMana(builder *flatbuffers.Builder, mana int16) { 1613 builder.PrependInt16Slot(1, mana, 150) 1614} 1615func MonsterAddHp(builder *flatbuffers.Builder, hp int16) { 1616 builder.PrependInt16Slot(2, hp, 100) 1617} 1618func MonsterAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { 1619 builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(name), 0) 1620} 1621func MonsterAddInventory(builder *flatbuffers.Builder, inventory flatbuffers.UOffsetT) { 1622 builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(inventory), 0) 1623} 1624func MonsterStartInventoryVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1625 return builder.StartVector(1, numElems, 1) 1626} 1627func MonsterAddColor(builder *flatbuffers.Builder, color Color) { 1628 builder.PrependByteSlot(6, byte(color), 8) 1629} 1630func MonsterAddTestType(builder *flatbuffers.Builder, testType Any) { 1631 builder.PrependByteSlot(7, byte(testType), 0) 1632} 1633func MonsterAddTest(builder *flatbuffers.Builder, test flatbuffers.UOffsetT) { 1634 builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(test), 0) 1635} 1636func MonsterAddTest4(builder *flatbuffers.Builder, test4 flatbuffers.UOffsetT) { 1637 builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(test4), 0) 1638} 1639func MonsterStartTest4Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1640 return builder.StartVector(4, numElems, 2) 1641} 1642func MonsterAddTestarrayofstring(builder *flatbuffers.Builder, testarrayofstring flatbuffers.UOffsetT) { 1643 builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(testarrayofstring), 0) 1644} 1645func MonsterStartTestarrayofstringVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1646 return builder.StartVector(4, numElems, 4) 1647} 1648func MonsterAddTestarrayoftables(builder *flatbuffers.Builder, testarrayoftables flatbuffers.UOffsetT) { 1649 builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(testarrayoftables), 0) 1650} 1651func MonsterStartTestarrayoftablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1652 return builder.StartVector(4, numElems, 4) 1653} 1654func MonsterAddEnemy(builder *flatbuffers.Builder, enemy flatbuffers.UOffsetT) { 1655 builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(enemy), 0) 1656} 1657func MonsterAddTestnestedflatbuffer(builder *flatbuffers.Builder, testnestedflatbuffer flatbuffers.UOffsetT) { 1658 builder.PrependUOffsetTSlot(13, flatbuffers.UOffsetT(testnestedflatbuffer), 0) 1659} 1660func MonsterStartTestnestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1661 return builder.StartVector(1, numElems, 1) 1662} 1663func MonsterAddTestempty(builder *flatbuffers.Builder, testempty flatbuffers.UOffsetT) { 1664 builder.PrependUOffsetTSlot(14, flatbuffers.UOffsetT(testempty), 0) 1665} 1666func MonsterAddTestbool(builder *flatbuffers.Builder, testbool bool) { 1667 builder.PrependBoolSlot(15, testbool, false) 1668} 1669func MonsterAddTesthashs32Fnv1(builder *flatbuffers.Builder, testhashs32Fnv1 int32) { 1670 builder.PrependInt32Slot(16, testhashs32Fnv1, 0) 1671} 1672func MonsterAddTesthashu32Fnv1(builder *flatbuffers.Builder, testhashu32Fnv1 uint32) { 1673 builder.PrependUint32Slot(17, testhashu32Fnv1, 0) 1674} 1675func MonsterAddTesthashs64Fnv1(builder *flatbuffers.Builder, testhashs64Fnv1 int64) { 1676 builder.PrependInt64Slot(18, testhashs64Fnv1, 0) 1677} 1678func MonsterAddTesthashu64Fnv1(builder *flatbuffers.Builder, testhashu64Fnv1 uint64) { 1679 builder.PrependUint64Slot(19, testhashu64Fnv1, 0) 1680} 1681func MonsterAddTesthashs32Fnv1a(builder *flatbuffers.Builder, testhashs32Fnv1a int32) { 1682 builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) 1683} 1684func MonsterAddTesthashu32Fnv1a(builder *flatbuffers.Builder, testhashu32Fnv1a uint32) { 1685 builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) 1686} 1687func MonsterAddTesthashs64Fnv1a(builder *flatbuffers.Builder, testhashs64Fnv1a int64) { 1688 builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) 1689} 1690func MonsterAddTesthashu64Fnv1a(builder *flatbuffers.Builder, testhashu64Fnv1a uint64) { 1691 builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) 1692} 1693func MonsterAddTestarrayofbools(builder *flatbuffers.Builder, testarrayofbools flatbuffers.UOffsetT) { 1694 builder.PrependUOffsetTSlot(24, flatbuffers.UOffsetT(testarrayofbools), 0) 1695} 1696func MonsterStartTestarrayofboolsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1697 return builder.StartVector(1, numElems, 1) 1698} 1699func MonsterAddTestf(builder *flatbuffers.Builder, testf float32) { 1700 builder.PrependFloat32Slot(25, testf, 3.14159) 1701} 1702func MonsterAddTestf2(builder *flatbuffers.Builder, testf2 float32) { 1703 builder.PrependFloat32Slot(26, testf2, 3.0) 1704} 1705func MonsterAddTestf3(builder *flatbuffers.Builder, testf3 float32) { 1706 builder.PrependFloat32Slot(27, testf3, 0.0) 1707} 1708func MonsterAddTestarrayofstring2(builder *flatbuffers.Builder, testarrayofstring2 flatbuffers.UOffsetT) { 1709 builder.PrependUOffsetTSlot(28, flatbuffers.UOffsetT(testarrayofstring2), 0) 1710} 1711func MonsterStartTestarrayofstring2Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1712 return builder.StartVector(4, numElems, 4) 1713} 1714func MonsterAddTestarrayofsortedstruct(builder *flatbuffers.Builder, testarrayofsortedstruct flatbuffers.UOffsetT) { 1715 builder.PrependUOffsetTSlot(29, flatbuffers.UOffsetT(testarrayofsortedstruct), 0) 1716} 1717func MonsterStartTestarrayofsortedstructVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1718 return builder.StartVector(8, numElems, 4) 1719} 1720func MonsterAddFlex(builder *flatbuffers.Builder, flex flatbuffers.UOffsetT) { 1721 builder.PrependUOffsetTSlot(30, flatbuffers.UOffsetT(flex), 0) 1722} 1723func MonsterStartFlexVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1724 return builder.StartVector(1, numElems, 1) 1725} 1726func MonsterAddTest5(builder *flatbuffers.Builder, test5 flatbuffers.UOffsetT) { 1727 builder.PrependUOffsetTSlot(31, flatbuffers.UOffsetT(test5), 0) 1728} 1729func MonsterStartTest5Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1730 return builder.StartVector(4, numElems, 2) 1731} 1732func MonsterAddVectorOfLongs(builder *flatbuffers.Builder, vectorOfLongs flatbuffers.UOffsetT) { 1733 builder.PrependUOffsetTSlot(32, flatbuffers.UOffsetT(vectorOfLongs), 0) 1734} 1735func MonsterStartVectorOfLongsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1736 return builder.StartVector(8, numElems, 8) 1737} 1738func MonsterAddVectorOfDoubles(builder *flatbuffers.Builder, vectorOfDoubles flatbuffers.UOffsetT) { 1739 builder.PrependUOffsetTSlot(33, flatbuffers.UOffsetT(vectorOfDoubles), 0) 1740} 1741func MonsterStartVectorOfDoublesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1742 return builder.StartVector(8, numElems, 8) 1743} 1744func MonsterAddParentNamespaceTest(builder *flatbuffers.Builder, parentNamespaceTest flatbuffers.UOffsetT) { 1745 builder.PrependUOffsetTSlot(34, flatbuffers.UOffsetT(parentNamespaceTest), 0) 1746} 1747func MonsterAddVectorOfReferrables(builder *flatbuffers.Builder, vectorOfReferrables flatbuffers.UOffsetT) { 1748 builder.PrependUOffsetTSlot(35, flatbuffers.UOffsetT(vectorOfReferrables), 0) 1749} 1750func MonsterStartVectorOfReferrablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1751 return builder.StartVector(4, numElems, 4) 1752} 1753func MonsterAddSingleWeakReference(builder *flatbuffers.Builder, singleWeakReference uint64) { 1754 builder.PrependUint64Slot(36, singleWeakReference, 0) 1755} 1756func MonsterAddVectorOfWeakReferences(builder *flatbuffers.Builder, vectorOfWeakReferences flatbuffers.UOffsetT) { 1757 builder.PrependUOffsetTSlot(37, flatbuffers.UOffsetT(vectorOfWeakReferences), 0) 1758} 1759func MonsterStartVectorOfWeakReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1760 return builder.StartVector(8, numElems, 8) 1761} 1762func MonsterAddVectorOfStrongReferrables(builder *flatbuffers.Builder, vectorOfStrongReferrables flatbuffers.UOffsetT) { 1763 builder.PrependUOffsetTSlot(38, flatbuffers.UOffsetT(vectorOfStrongReferrables), 0) 1764} 1765func MonsterStartVectorOfStrongReferrablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1766 return builder.StartVector(4, numElems, 4) 1767} 1768func MonsterAddCoOwningReference(builder *flatbuffers.Builder, coOwningReference uint64) { 1769 builder.PrependUint64Slot(39, coOwningReference, 0) 1770} 1771func MonsterAddVectorOfCoOwningReferences(builder *flatbuffers.Builder, vectorOfCoOwningReferences flatbuffers.UOffsetT) { 1772 builder.PrependUOffsetTSlot(40, flatbuffers.UOffsetT(vectorOfCoOwningReferences), 0) 1773} 1774func MonsterStartVectorOfCoOwningReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1775 return builder.StartVector(8, numElems, 8) 1776} 1777func MonsterAddNonOwningReference(builder *flatbuffers.Builder, nonOwningReference uint64) { 1778 builder.PrependUint64Slot(41, nonOwningReference, 0) 1779} 1780func MonsterAddVectorOfNonOwningReferences(builder *flatbuffers.Builder, vectorOfNonOwningReferences flatbuffers.UOffsetT) { 1781 builder.PrependUOffsetTSlot(42, flatbuffers.UOffsetT(vectorOfNonOwningReferences), 0) 1782} 1783func MonsterStartVectorOfNonOwningReferencesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1784 return builder.StartVector(8, numElems, 8) 1785} 1786func MonsterAddAnyUniqueType(builder *flatbuffers.Builder, anyUniqueType AnyUniqueAliases) { 1787 builder.PrependByteSlot(43, byte(anyUniqueType), 0) 1788} 1789func MonsterAddAnyUnique(builder *flatbuffers.Builder, anyUnique flatbuffers.UOffsetT) { 1790 builder.PrependUOffsetTSlot(44, flatbuffers.UOffsetT(anyUnique), 0) 1791} 1792func MonsterAddAnyAmbiguousType(builder *flatbuffers.Builder, anyAmbiguousType AnyAmbiguousAliases) { 1793 builder.PrependByteSlot(45, byte(anyAmbiguousType), 0) 1794} 1795func MonsterAddAnyAmbiguous(builder *flatbuffers.Builder, anyAmbiguous flatbuffers.UOffsetT) { 1796 builder.PrependUOffsetTSlot(46, flatbuffers.UOffsetT(anyAmbiguous), 0) 1797} 1798func MonsterAddVectorOfEnums(builder *flatbuffers.Builder, vectorOfEnums flatbuffers.UOffsetT) { 1799 builder.PrependUOffsetTSlot(47, flatbuffers.UOffsetT(vectorOfEnums), 0) 1800} 1801func MonsterStartVectorOfEnumsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1802 return builder.StartVector(1, numElems, 1) 1803} 1804func MonsterAddSignedEnum(builder *flatbuffers.Builder, signedEnum Race) { 1805 builder.PrependInt8Slot(48, int8(signedEnum), -1) 1806} 1807func MonsterAddTestrequirednestedflatbuffer(builder *flatbuffers.Builder, testrequirednestedflatbuffer flatbuffers.UOffsetT) { 1808 builder.PrependUOffsetTSlot(49, flatbuffers.UOffsetT(testrequirednestedflatbuffer), 0) 1809} 1810func MonsterStartTestrequirednestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1811 return builder.StartVector(1, numElems, 1) 1812} 1813func MonsterAddScalarKeySortedTables(builder *flatbuffers.Builder, scalarKeySortedTables flatbuffers.UOffsetT) { 1814 builder.PrependUOffsetTSlot(50, flatbuffers.UOffsetT(scalarKeySortedTables), 0) 1815} 1816func MonsterStartScalarKeySortedTablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { 1817 return builder.StartVector(4, numElems, 4) 1818} 1819func MonsterAddNativeInline(builder *flatbuffers.Builder, nativeInline flatbuffers.UOffsetT) { 1820 builder.PrependStructSlot(51, flatbuffers.UOffsetT(nativeInline), 0) 1821} 1822func MonsterAddLongEnumNonEnumDefault(builder *flatbuffers.Builder, longEnumNonEnumDefault LongEnum) { 1823 builder.PrependUint64Slot(52, uint64(longEnumNonEnumDefault), 0) 1824} 1825func MonsterAddLongEnumNormalDefault(builder *flatbuffers.Builder, longEnumNormalDefault LongEnum) { 1826 builder.PrependUint64Slot(53, uint64(longEnumNormalDefault), 2) 1827} 1828func MonsterAddNanDefault(builder *flatbuffers.Builder, nanDefault float32) { 1829 builder.PrependFloat32Slot(54, nanDefault, float32(math.NaN())) 1830} 1831func MonsterAddInfDefault(builder *flatbuffers.Builder, infDefault float32) { 1832 builder.PrependFloat32Slot(55, infDefault, float32(math.Inf(1))) 1833} 1834func MonsterAddPositiveInfDefault(builder *flatbuffers.Builder, positiveInfDefault float32) { 1835 builder.PrependFloat32Slot(56, positiveInfDefault, float32(math.Inf(1))) 1836} 1837func MonsterAddInfinityDefault(builder *flatbuffers.Builder, infinityDefault float32) { 1838 builder.PrependFloat32Slot(57, infinityDefault, float32(math.Inf(1))) 1839} 1840func MonsterAddPositiveInfinityDefault(builder *flatbuffers.Builder, positiveInfinityDefault float32) { 1841 builder.PrependFloat32Slot(58, positiveInfinityDefault, float32(math.Inf(1))) 1842} 1843func MonsterAddNegativeInfDefault(builder *flatbuffers.Builder, negativeInfDefault float32) { 1844 builder.PrependFloat32Slot(59, negativeInfDefault, float32(math.Inf(-1))) 1845} 1846func MonsterAddNegativeInfinityDefault(builder *flatbuffers.Builder, negativeInfinityDefault float32) { 1847 builder.PrependFloat32Slot(60, negativeInfinityDefault, float32(math.Inf(-1))) 1848} 1849func MonsterAddDoubleInfDefault(builder *flatbuffers.Builder, doubleInfDefault float64) { 1850 builder.PrependFloat64Slot(61, doubleInfDefault, float64(math.Inf(1))) 1851} 1852func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { 1853 return builder.EndObject() 1854} 1855