mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-09 06:30:54 +00:00
[Go] Object API support (#5339)
* start * works for current usages! * unpack: vector of struct * optimize byte slice * support nested struct * support null table * support struct * support union * update generated code * grumble * fix compiler warning * update generated code * wrap type in namespace * bug * wrap in namespace * enum byte arrays * generate struct for unions * basic testing * remove branching * fix assert * pack vector of fixed structs correctly * omit null vectors * Refactor Union Pack and UnPack methods Remove append usage to increase code efficiency when dealing with large vectors * generate goldens
This commit is contained in:
iceboy
committed by
Wouter van Oortmerssen
Wouter van Oortmerssen
parent
521e255ad9
commit
32254b7acd
@@ -6,6 +6,23 @@ import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type AbilityT struct {
|
||||
Id uint32
|
||||
Distance uint32
|
||||
}
|
||||
|
||||
func AbilityPack(builder *flatbuffers.Builder, t *AbilityT) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
return CreateAbility(builder, t.Id, t.Distance)
|
||||
}
|
||||
func (rcv *Ability) UnPack() *AbilityT {
|
||||
if rcv == nil { return nil }
|
||||
t := &AbilityT{}
|
||||
t.Id = rcv.Id()
|
||||
t.Distance = rcv.Distance()
|
||||
return t
|
||||
}
|
||||
|
||||
type Ability struct {
|
||||
_tab flatbuffers.Struct
|
||||
}
|
||||
|
||||
@@ -2,7 +2,48 @@
|
||||
|
||||
package Example
|
||||
|
||||
import "strconv"
|
||||
import (
|
||||
"strconv"
|
||||
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
|
||||
MyGame__Example2 "MyGame/Example2"
|
||||
)
|
||||
|
||||
type AnyT struct {
|
||||
Type Any
|
||||
Value interface{}
|
||||
}
|
||||
|
||||
func AnyPack(builder *flatbuffers.Builder, t *AnyT) flatbuffers.UOffsetT {
|
||||
if t == nil {
|
||||
return 0
|
||||
}
|
||||
switch t.Type {
|
||||
case AnyMonster:
|
||||
return MonsterPack(builder, t.Value.(*MonsterT))
|
||||
case AnyTestSimpleTableWithEnum:
|
||||
return TestSimpleTableWithEnumPack(builder, t.Value.(*TestSimpleTableWithEnumT))
|
||||
case AnyMyGame_Example2_Monster:
|
||||
return MyGame__Example2.MonsterPack(builder, t.Value.(*MyGame__Example2.MonsterT))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func AnyUnPack(t Any, table flatbuffers.Table) *AnyT {
|
||||
switch t {
|
||||
case AnyMonster:
|
||||
x := Monster{_tab: table}
|
||||
return &AnyT{ Type: AnyMonster, Value: x.UnPack() }
|
||||
case AnyTestSimpleTableWithEnum:
|
||||
x := TestSimpleTableWithEnum{_tab: table}
|
||||
return &AnyT{ Type: AnyTestSimpleTableWithEnum, Value: x.UnPack() }
|
||||
case AnyMyGame_Example2_Monster:
|
||||
x := Monster{_tab: table}
|
||||
return &AnyT{ Type: AnyMyGame_Example2_Monster, Value: x.UnPack() }
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type Any byte
|
||||
|
||||
|
||||
@@ -2,7 +2,46 @@
|
||||
|
||||
package Example
|
||||
|
||||
import "strconv"
|
||||
import (
|
||||
"strconv"
|
||||
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type AnyAmbiguousAliasesT struct {
|
||||
Type AnyAmbiguousAliases
|
||||
Value interface{}
|
||||
}
|
||||
|
||||
func AnyAmbiguousAliasesPack(builder *flatbuffers.Builder, t *AnyAmbiguousAliasesT) flatbuffers.UOffsetT {
|
||||
if t == nil {
|
||||
return 0
|
||||
}
|
||||
switch t.Type {
|
||||
case AnyAmbiguousAliasesM1:
|
||||
return MonsterPack(builder, t.Value.(*MonsterT))
|
||||
case AnyAmbiguousAliasesM2:
|
||||
return MonsterPack(builder, t.Value.(*MonsterT))
|
||||
case AnyAmbiguousAliasesM3:
|
||||
return MonsterPack(builder, t.Value.(*MonsterT))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func AnyAmbiguousAliasesUnPack(t AnyAmbiguousAliases, table flatbuffers.Table) *AnyAmbiguousAliasesT {
|
||||
switch t {
|
||||
case AnyAmbiguousAliasesM1:
|
||||
x := Monster{_tab: table}
|
||||
return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM1, Value: x.UnPack() }
|
||||
case AnyAmbiguousAliasesM2:
|
||||
x := Monster{_tab: table}
|
||||
return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM2, Value: x.UnPack() }
|
||||
case AnyAmbiguousAliasesM3:
|
||||
x := Monster{_tab: table}
|
||||
return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM3, Value: x.UnPack() }
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type AnyAmbiguousAliases byte
|
||||
|
||||
|
||||
@@ -2,7 +2,48 @@
|
||||
|
||||
package Example
|
||||
|
||||
import "strconv"
|
||||
import (
|
||||
"strconv"
|
||||
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
|
||||
MyGame__Example2 "MyGame/Example2"
|
||||
)
|
||||
|
||||
type AnyUniqueAliasesT struct {
|
||||
Type AnyUniqueAliases
|
||||
Value interface{}
|
||||
}
|
||||
|
||||
func AnyUniqueAliasesPack(builder *flatbuffers.Builder, t *AnyUniqueAliasesT) flatbuffers.UOffsetT {
|
||||
if t == nil {
|
||||
return 0
|
||||
}
|
||||
switch t.Type {
|
||||
case AnyUniqueAliasesM:
|
||||
return MonsterPack(builder, t.Value.(*MonsterT))
|
||||
case AnyUniqueAliasesTS:
|
||||
return TestSimpleTableWithEnumPack(builder, t.Value.(*TestSimpleTableWithEnumT))
|
||||
case AnyUniqueAliasesM2:
|
||||
return MyGame__Example2.MonsterPack(builder, t.Value.(*MyGame__Example2.MonsterT))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func AnyUniqueAliasesUnPack(t AnyUniqueAliases, table flatbuffers.Table) *AnyUniqueAliasesT {
|
||||
switch t {
|
||||
case AnyUniqueAliasesM:
|
||||
x := Monster{_tab: table}
|
||||
return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM, Value: x.UnPack() }
|
||||
case AnyUniqueAliasesTS:
|
||||
x := TestSimpleTableWithEnum{_tab: table}
|
||||
return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesTS, Value: x.UnPack() }
|
||||
case AnyUniqueAliasesM2:
|
||||
x := Monster{_tab: table}
|
||||
return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM2, Value: x.UnPack() }
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type AnyUniqueAliases byte
|
||||
|
||||
|
||||
@@ -9,6 +9,424 @@ import (
|
||||
)
|
||||
|
||||
/// an example documentation comment: monster object
|
||||
type MonsterT struct {
|
||||
Pos *Vec3T
|
||||
Mana int16
|
||||
Hp int16
|
||||
Name string
|
||||
Inventory []byte
|
||||
Color Color
|
||||
Test *AnyT
|
||||
Test4 []*TestT
|
||||
Testarrayofstring []string
|
||||
Testarrayoftables []*MonsterT
|
||||
Enemy *MonsterT
|
||||
Testnestedflatbuffer []byte
|
||||
Testempty *StatT
|
||||
Testbool bool
|
||||
Testhashs32Fnv1 int32
|
||||
Testhashu32Fnv1 uint32
|
||||
Testhashs64Fnv1 int64
|
||||
Testhashu64Fnv1 uint64
|
||||
Testhashs32Fnv1a int32
|
||||
Testhashu32Fnv1a uint32
|
||||
Testhashs64Fnv1a int64
|
||||
Testhashu64Fnv1a uint64
|
||||
Testarrayofbools []bool
|
||||
Testf float32
|
||||
Testf2 float32
|
||||
Testf3 float32
|
||||
Testarrayofstring2 []string
|
||||
Testarrayofsortedstruct []*AbilityT
|
||||
Flex []byte
|
||||
Test5 []*TestT
|
||||
VectorOfLongs []int64
|
||||
VectorOfDoubles []float64
|
||||
ParentNamespaceTest *MyGame.InParentNamespaceT
|
||||
VectorOfReferrables []*ReferrableT
|
||||
SingleWeakReference uint64
|
||||
VectorOfWeakReferences []uint64
|
||||
VectorOfStrongReferrables []*ReferrableT
|
||||
CoOwningReference uint64
|
||||
VectorOfCoOwningReferences []uint64
|
||||
NonOwningReference uint64
|
||||
VectorOfNonOwningReferences []uint64
|
||||
AnyUnique *AnyUniqueAliasesT
|
||||
AnyAmbiguous *AnyAmbiguousAliasesT
|
||||
VectorOfEnums []Color
|
||||
SignedEnum Race
|
||||
}
|
||||
|
||||
func MonsterPack(builder *flatbuffers.Builder, t *MonsterT) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
nameOffset := builder.CreateString(t.Name)
|
||||
inventoryOffset := flatbuffers.UOffsetT(0)
|
||||
if t.Inventory != nil {
|
||||
inventoryOffset = builder.CreateByteString(t.Inventory)
|
||||
}
|
||||
testOffset := AnyPack(builder, t.Test)
|
||||
|
||||
test4Offset := flatbuffers.UOffsetT(0)
|
||||
if t.Test4 != nil {
|
||||
test4Length := len(t.Test4)
|
||||
MonsterStartTest4Vector(builder, test4Length)
|
||||
for j := test4Length - 1; j >= 0; j-- {
|
||||
TestPack(builder, t.Test4[j])
|
||||
}
|
||||
test4Offset = builder.EndVector(test4Length)
|
||||
}
|
||||
testarrayofstringOffset := flatbuffers.UOffsetT(0)
|
||||
if t.Testarrayofstring != nil {
|
||||
testarrayofstringLength := len(t.Testarrayofstring)
|
||||
testarrayofstringOffsets := make([]flatbuffers.UOffsetT, testarrayofstringLength)
|
||||
for j := 0; j < testarrayofstringLength; j++ {
|
||||
testarrayofstringOffsets[j] = builder.CreateString(t.Testarrayofstring[j])
|
||||
}
|
||||
MonsterStartTestarrayofstringVector(builder, testarrayofstringLength)
|
||||
for j := testarrayofstringLength - 1; j >= 0; j-- {
|
||||
builder.PrependUOffsetT(testarrayofstringOffsets[j])
|
||||
}
|
||||
testarrayofstringOffset = builder.EndVector(testarrayofstringLength)
|
||||
}
|
||||
testarrayoftablesOffset := flatbuffers.UOffsetT(0)
|
||||
if t.Testarrayoftables != nil {
|
||||
testarrayoftablesLength := len(t.Testarrayoftables)
|
||||
testarrayoftablesOffsets := make([]flatbuffers.UOffsetT, testarrayoftablesLength)
|
||||
for j := 0; j < testarrayoftablesLength; j++ {
|
||||
testarrayoftablesOffsets[j] = MonsterPack(builder, t.Testarrayoftables[j])
|
||||
}
|
||||
MonsterStartTestarrayoftablesVector(builder, testarrayoftablesLength)
|
||||
for j := testarrayoftablesLength - 1; j >= 0; j-- {
|
||||
builder.PrependUOffsetT(testarrayoftablesOffsets[j])
|
||||
}
|
||||
testarrayoftablesOffset = builder.EndVector(testarrayoftablesLength)
|
||||
}
|
||||
enemyOffset := MonsterPack(builder, t.Enemy)
|
||||
testnestedflatbufferOffset := flatbuffers.UOffsetT(0)
|
||||
if t.Testnestedflatbuffer != nil {
|
||||
testnestedflatbufferOffset = builder.CreateByteString(t.Testnestedflatbuffer)
|
||||
}
|
||||
testemptyOffset := StatPack(builder, t.Testempty)
|
||||
testarrayofboolsOffset := flatbuffers.UOffsetT(0)
|
||||
if t.Testarrayofbools != nil {
|
||||
testarrayofboolsLength := len(t.Testarrayofbools)
|
||||
MonsterStartTestarrayofboolsVector(builder, testarrayofboolsLength)
|
||||
for j := testarrayofboolsLength - 1; j >= 0; j-- {
|
||||
builder.PrependBool(t.Testarrayofbools[j])
|
||||
}
|
||||
testarrayofboolsOffset = builder.EndVector(testarrayofboolsLength)
|
||||
}
|
||||
testarrayofstring2Offset := flatbuffers.UOffsetT(0)
|
||||
if t.Testarrayofstring2 != nil {
|
||||
testarrayofstring2Length := len(t.Testarrayofstring2)
|
||||
testarrayofstring2Offsets := make([]flatbuffers.UOffsetT, testarrayofstring2Length)
|
||||
for j := 0; j < testarrayofstring2Length; j++ {
|
||||
testarrayofstring2Offsets[j] = builder.CreateString(t.Testarrayofstring2[j])
|
||||
}
|
||||
MonsterStartTestarrayofstring2Vector(builder, testarrayofstring2Length)
|
||||
for j := testarrayofstring2Length - 1; j >= 0; j-- {
|
||||
builder.PrependUOffsetT(testarrayofstring2Offsets[j])
|
||||
}
|
||||
testarrayofstring2Offset = builder.EndVector(testarrayofstring2Length)
|
||||
}
|
||||
testarrayofsortedstructOffset := flatbuffers.UOffsetT(0)
|
||||
if t.Testarrayofsortedstruct != nil {
|
||||
testarrayofsortedstructLength := len(t.Testarrayofsortedstruct)
|
||||
MonsterStartTestarrayofsortedstructVector(builder, testarrayofsortedstructLength)
|
||||
for j := testarrayofsortedstructLength - 1; j >= 0; j-- {
|
||||
AbilityPack(builder, t.Testarrayofsortedstruct[j])
|
||||
}
|
||||
testarrayofsortedstructOffset = builder.EndVector(testarrayofsortedstructLength)
|
||||
}
|
||||
flexOffset := flatbuffers.UOffsetT(0)
|
||||
if t.Flex != nil {
|
||||
flexOffset = builder.CreateByteString(t.Flex)
|
||||
}
|
||||
test5Offset := flatbuffers.UOffsetT(0)
|
||||
if t.Test5 != nil {
|
||||
test5Length := len(t.Test5)
|
||||
MonsterStartTest5Vector(builder, test5Length)
|
||||
for j := test5Length - 1; j >= 0; j-- {
|
||||
TestPack(builder, t.Test5[j])
|
||||
}
|
||||
test5Offset = builder.EndVector(test5Length)
|
||||
}
|
||||
vectorOfLongsOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfLongs != nil {
|
||||
vectorOfLongsLength := len(t.VectorOfLongs)
|
||||
MonsterStartVectorOfLongsVector(builder, vectorOfLongsLength)
|
||||
for j := vectorOfLongsLength - 1; j >= 0; j-- {
|
||||
builder.PrependInt64(t.VectorOfLongs[j])
|
||||
}
|
||||
vectorOfLongsOffset = builder.EndVector(vectorOfLongsLength)
|
||||
}
|
||||
vectorOfDoublesOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfDoubles != nil {
|
||||
vectorOfDoublesLength := len(t.VectorOfDoubles)
|
||||
MonsterStartVectorOfDoublesVector(builder, vectorOfDoublesLength)
|
||||
for j := vectorOfDoublesLength - 1; j >= 0; j-- {
|
||||
builder.PrependFloat64(t.VectorOfDoubles[j])
|
||||
}
|
||||
vectorOfDoublesOffset = builder.EndVector(vectorOfDoublesLength)
|
||||
}
|
||||
parentNamespaceTestOffset := MyGame.InParentNamespacePack(builder, t.ParentNamespaceTest)
|
||||
vectorOfReferrablesOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfReferrables != nil {
|
||||
vectorOfReferrablesLength := len(t.VectorOfReferrables)
|
||||
vectorOfReferrablesOffsets := make([]flatbuffers.UOffsetT, vectorOfReferrablesLength)
|
||||
for j := 0; j < vectorOfReferrablesLength; j++ {
|
||||
vectorOfReferrablesOffsets[j] = ReferrablePack(builder, t.VectorOfReferrables[j])
|
||||
}
|
||||
MonsterStartVectorOfReferrablesVector(builder, vectorOfReferrablesLength)
|
||||
for j := vectorOfReferrablesLength - 1; j >= 0; j-- {
|
||||
builder.PrependUOffsetT(vectorOfReferrablesOffsets[j])
|
||||
}
|
||||
vectorOfReferrablesOffset = builder.EndVector(vectorOfReferrablesLength)
|
||||
}
|
||||
vectorOfWeakReferencesOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfWeakReferences != nil {
|
||||
vectorOfWeakReferencesLength := len(t.VectorOfWeakReferences)
|
||||
MonsterStartVectorOfWeakReferencesVector(builder, vectorOfWeakReferencesLength)
|
||||
for j := vectorOfWeakReferencesLength - 1; j >= 0; j-- {
|
||||
builder.PrependUint64(t.VectorOfWeakReferences[j])
|
||||
}
|
||||
vectorOfWeakReferencesOffset = builder.EndVector(vectorOfWeakReferencesLength)
|
||||
}
|
||||
vectorOfStrongReferrablesOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfStrongReferrables != nil {
|
||||
vectorOfStrongReferrablesLength := len(t.VectorOfStrongReferrables)
|
||||
vectorOfStrongReferrablesOffsets := make([]flatbuffers.UOffsetT, vectorOfStrongReferrablesLength)
|
||||
for j := 0; j < vectorOfStrongReferrablesLength; j++ {
|
||||
vectorOfStrongReferrablesOffsets[j] = ReferrablePack(builder, t.VectorOfStrongReferrables[j])
|
||||
}
|
||||
MonsterStartVectorOfStrongReferrablesVector(builder, vectorOfStrongReferrablesLength)
|
||||
for j := vectorOfStrongReferrablesLength - 1; j >= 0; j-- {
|
||||
builder.PrependUOffsetT(vectorOfStrongReferrablesOffsets[j])
|
||||
}
|
||||
vectorOfStrongReferrablesOffset = builder.EndVector(vectorOfStrongReferrablesLength)
|
||||
}
|
||||
vectorOfCoOwningReferencesOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfCoOwningReferences != nil {
|
||||
vectorOfCoOwningReferencesLength := len(t.VectorOfCoOwningReferences)
|
||||
MonsterStartVectorOfCoOwningReferencesVector(builder, vectorOfCoOwningReferencesLength)
|
||||
for j := vectorOfCoOwningReferencesLength - 1; j >= 0; j-- {
|
||||
builder.PrependUint64(t.VectorOfCoOwningReferences[j])
|
||||
}
|
||||
vectorOfCoOwningReferencesOffset = builder.EndVector(vectorOfCoOwningReferencesLength)
|
||||
}
|
||||
vectorOfNonOwningReferencesOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfNonOwningReferences != nil {
|
||||
vectorOfNonOwningReferencesLength := len(t.VectorOfNonOwningReferences)
|
||||
MonsterStartVectorOfNonOwningReferencesVector(builder, vectorOfNonOwningReferencesLength)
|
||||
for j := vectorOfNonOwningReferencesLength - 1; j >= 0; j-- {
|
||||
builder.PrependUint64(t.VectorOfNonOwningReferences[j])
|
||||
}
|
||||
vectorOfNonOwningReferencesOffset = builder.EndVector(vectorOfNonOwningReferencesLength)
|
||||
}
|
||||
anyUniqueOffset := AnyUniqueAliasesPack(builder, t.AnyUnique)
|
||||
|
||||
anyAmbiguousOffset := AnyAmbiguousAliasesPack(builder, t.AnyAmbiguous)
|
||||
|
||||
vectorOfEnumsOffset := flatbuffers.UOffsetT(0)
|
||||
if t.VectorOfEnums != nil {
|
||||
vectorOfEnumsLength := len(t.VectorOfEnums)
|
||||
MonsterStartVectorOfEnumsVector(builder, vectorOfEnumsLength)
|
||||
for j := vectorOfEnumsLength - 1; j >= 0; j-- {
|
||||
builder.PrependByte(byte(t.VectorOfEnums[j]))
|
||||
}
|
||||
vectorOfEnumsOffset = builder.EndVector(vectorOfEnumsLength)
|
||||
}
|
||||
MonsterStart(builder)
|
||||
posOffset := Vec3Pack(builder, t.Pos)
|
||||
MonsterAddPos(builder, posOffset)
|
||||
MonsterAddMana(builder, t.Mana)
|
||||
MonsterAddHp(builder, t.Hp)
|
||||
MonsterAddName(builder, nameOffset)
|
||||
MonsterAddInventory(builder, inventoryOffset)
|
||||
MonsterAddColor(builder, t.Color)
|
||||
if t.Test != nil {
|
||||
MonsterAddTestType(builder, t.Test.Type)
|
||||
}
|
||||
MonsterAddTest(builder, testOffset)
|
||||
MonsterAddTest4(builder, test4Offset)
|
||||
MonsterAddTestarrayofstring(builder, testarrayofstringOffset)
|
||||
MonsterAddTestarrayoftables(builder, testarrayoftablesOffset)
|
||||
MonsterAddEnemy(builder, enemyOffset)
|
||||
MonsterAddTestnestedflatbuffer(builder, testnestedflatbufferOffset)
|
||||
MonsterAddTestempty(builder, testemptyOffset)
|
||||
MonsterAddTestbool(builder, t.Testbool)
|
||||
MonsterAddTesthashs32Fnv1(builder, t.Testhashs32Fnv1)
|
||||
MonsterAddTesthashu32Fnv1(builder, t.Testhashu32Fnv1)
|
||||
MonsterAddTesthashs64Fnv1(builder, t.Testhashs64Fnv1)
|
||||
MonsterAddTesthashu64Fnv1(builder, t.Testhashu64Fnv1)
|
||||
MonsterAddTesthashs32Fnv1a(builder, t.Testhashs32Fnv1a)
|
||||
MonsterAddTesthashu32Fnv1a(builder, t.Testhashu32Fnv1a)
|
||||
MonsterAddTesthashs64Fnv1a(builder, t.Testhashs64Fnv1a)
|
||||
MonsterAddTesthashu64Fnv1a(builder, t.Testhashu64Fnv1a)
|
||||
MonsterAddTestarrayofbools(builder, testarrayofboolsOffset)
|
||||
MonsterAddTestf(builder, t.Testf)
|
||||
MonsterAddTestf2(builder, t.Testf2)
|
||||
MonsterAddTestf3(builder, t.Testf3)
|
||||
MonsterAddTestarrayofstring2(builder, testarrayofstring2Offset)
|
||||
MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstructOffset)
|
||||
MonsterAddFlex(builder, flexOffset)
|
||||
MonsterAddTest5(builder, test5Offset)
|
||||
MonsterAddVectorOfLongs(builder, vectorOfLongsOffset)
|
||||
MonsterAddVectorOfDoubles(builder, vectorOfDoublesOffset)
|
||||
MonsterAddParentNamespaceTest(builder, parentNamespaceTestOffset)
|
||||
MonsterAddVectorOfReferrables(builder, vectorOfReferrablesOffset)
|
||||
MonsterAddSingleWeakReference(builder, t.SingleWeakReference)
|
||||
MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferencesOffset)
|
||||
MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrablesOffset)
|
||||
MonsterAddCoOwningReference(builder, t.CoOwningReference)
|
||||
MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferencesOffset)
|
||||
MonsterAddNonOwningReference(builder, t.NonOwningReference)
|
||||
MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferencesOffset)
|
||||
if t.AnyUnique != nil {
|
||||
MonsterAddAnyUniqueType(builder, t.AnyUnique.Type)
|
||||
}
|
||||
MonsterAddAnyUnique(builder, anyUniqueOffset)
|
||||
if t.AnyAmbiguous != nil {
|
||||
MonsterAddAnyAmbiguousType(builder, t.AnyAmbiguous.Type)
|
||||
}
|
||||
MonsterAddAnyAmbiguous(builder, anyAmbiguousOffset)
|
||||
MonsterAddVectorOfEnums(builder, vectorOfEnumsOffset)
|
||||
MonsterAddSignedEnum(builder, t.SignedEnum)
|
||||
return MonsterEnd(builder)
|
||||
}
|
||||
|
||||
func (rcv *Monster) UnPack() *MonsterT {
|
||||
if rcv == nil { return nil }
|
||||
t := &MonsterT{}
|
||||
t.Pos = rcv.Pos(nil).UnPack()
|
||||
t.Mana = rcv.Mana()
|
||||
t.Hp = rcv.Hp()
|
||||
t.Name = string(rcv.Name())
|
||||
t.Inventory = rcv.InventoryBytes()
|
||||
t.Color = rcv.Color()
|
||||
testTable := flatbuffers.Table{}
|
||||
if rcv.Test(&testTable) {
|
||||
t.Test = AnyUnPack(rcv.TestType(), testTable)
|
||||
}
|
||||
test4Length := rcv.Test4Length()
|
||||
t.Test4 = make([]*TestT, test4Length)
|
||||
for j := 0; j < test4Length; j++ {
|
||||
x := Test{}
|
||||
rcv.Test4(&x, j)
|
||||
t.Test4[j] = x.UnPack()
|
||||
}
|
||||
testarrayofstringLength := rcv.TestarrayofstringLength()
|
||||
t.Testarrayofstring = make([]string, testarrayofstringLength)
|
||||
for j := 0; j < testarrayofstringLength; j++ {
|
||||
t.Testarrayofstring[j] = string(rcv.Testarrayofstring(j))
|
||||
}
|
||||
testarrayoftablesLength := rcv.TestarrayoftablesLength()
|
||||
t.Testarrayoftables = make([]*MonsterT, testarrayoftablesLength)
|
||||
for j := 0; j < testarrayoftablesLength; j++ {
|
||||
x := Monster{}
|
||||
rcv.Testarrayoftables(&x, j)
|
||||
t.Testarrayoftables[j] = x.UnPack()
|
||||
}
|
||||
t.Enemy = rcv.Enemy(nil).UnPack()
|
||||
t.Testnestedflatbuffer = rcv.TestnestedflatbufferBytes()
|
||||
t.Testempty = rcv.Testempty(nil).UnPack()
|
||||
t.Testbool = rcv.Testbool()
|
||||
t.Testhashs32Fnv1 = rcv.Testhashs32Fnv1()
|
||||
t.Testhashu32Fnv1 = rcv.Testhashu32Fnv1()
|
||||
t.Testhashs64Fnv1 = rcv.Testhashs64Fnv1()
|
||||
t.Testhashu64Fnv1 = rcv.Testhashu64Fnv1()
|
||||
t.Testhashs32Fnv1a = rcv.Testhashs32Fnv1a()
|
||||
t.Testhashu32Fnv1a = rcv.Testhashu32Fnv1a()
|
||||
t.Testhashs64Fnv1a = rcv.Testhashs64Fnv1a()
|
||||
t.Testhashu64Fnv1a = rcv.Testhashu64Fnv1a()
|
||||
testarrayofboolsLength := rcv.TestarrayofboolsLength()
|
||||
t.Testarrayofbools = make([]bool, testarrayofboolsLength)
|
||||
for j := 0; j < testarrayofboolsLength; j++ {
|
||||
t.Testarrayofbools[j] = rcv.Testarrayofbools(j)
|
||||
}
|
||||
t.Testf = rcv.Testf()
|
||||
t.Testf2 = rcv.Testf2()
|
||||
t.Testf3 = rcv.Testf3()
|
||||
testarrayofstring2Length := rcv.Testarrayofstring2Length()
|
||||
t.Testarrayofstring2 = make([]string, testarrayofstring2Length)
|
||||
for j := 0; j < testarrayofstring2Length; j++ {
|
||||
t.Testarrayofstring2[j] = string(rcv.Testarrayofstring2(j))
|
||||
}
|
||||
testarrayofsortedstructLength := rcv.TestarrayofsortedstructLength()
|
||||
t.Testarrayofsortedstruct = make([]*AbilityT, testarrayofsortedstructLength)
|
||||
for j := 0; j < testarrayofsortedstructLength; j++ {
|
||||
x := Ability{}
|
||||
rcv.Testarrayofsortedstruct(&x, j)
|
||||
t.Testarrayofsortedstruct[j] = x.UnPack()
|
||||
}
|
||||
t.Flex = rcv.FlexBytes()
|
||||
test5Length := rcv.Test5Length()
|
||||
t.Test5 = make([]*TestT, test5Length)
|
||||
for j := 0; j < test5Length; j++ {
|
||||
x := Test{}
|
||||
rcv.Test5(&x, j)
|
||||
t.Test5[j] = x.UnPack()
|
||||
}
|
||||
vectorOfLongsLength := rcv.VectorOfLongsLength()
|
||||
t.VectorOfLongs = make([]int64, vectorOfLongsLength)
|
||||
for j := 0; j < vectorOfLongsLength; j++ {
|
||||
t.VectorOfLongs[j] = rcv.VectorOfLongs(j)
|
||||
}
|
||||
vectorOfDoublesLength := rcv.VectorOfDoublesLength()
|
||||
t.VectorOfDoubles = make([]float64, vectorOfDoublesLength)
|
||||
for j := 0; j < vectorOfDoublesLength; j++ {
|
||||
t.VectorOfDoubles[j] = rcv.VectorOfDoubles(j)
|
||||
}
|
||||
t.ParentNamespaceTest = rcv.ParentNamespaceTest(nil).UnPack()
|
||||
vectorOfReferrablesLength := rcv.VectorOfReferrablesLength()
|
||||
t.VectorOfReferrables = make([]*ReferrableT, vectorOfReferrablesLength)
|
||||
for j := 0; j < vectorOfReferrablesLength; j++ {
|
||||
x := Referrable{}
|
||||
rcv.VectorOfReferrables(&x, j)
|
||||
t.VectorOfReferrables[j] = x.UnPack()
|
||||
}
|
||||
t.SingleWeakReference = rcv.SingleWeakReference()
|
||||
vectorOfWeakReferencesLength := rcv.VectorOfWeakReferencesLength()
|
||||
t.VectorOfWeakReferences = make([]uint64, vectorOfWeakReferencesLength)
|
||||
for j := 0; j < vectorOfWeakReferencesLength; j++ {
|
||||
t.VectorOfWeakReferences[j] = rcv.VectorOfWeakReferences(j)
|
||||
}
|
||||
vectorOfStrongReferrablesLength := rcv.VectorOfStrongReferrablesLength()
|
||||
t.VectorOfStrongReferrables = make([]*ReferrableT, vectorOfStrongReferrablesLength)
|
||||
for j := 0; j < vectorOfStrongReferrablesLength; j++ {
|
||||
x := Referrable{}
|
||||
rcv.VectorOfStrongReferrables(&x, j)
|
||||
t.VectorOfStrongReferrables[j] = x.UnPack()
|
||||
}
|
||||
t.CoOwningReference = rcv.CoOwningReference()
|
||||
vectorOfCoOwningReferencesLength := rcv.VectorOfCoOwningReferencesLength()
|
||||
t.VectorOfCoOwningReferences = make([]uint64, vectorOfCoOwningReferencesLength)
|
||||
for j := 0; j < vectorOfCoOwningReferencesLength; j++ {
|
||||
t.VectorOfCoOwningReferences[j] = rcv.VectorOfCoOwningReferences(j)
|
||||
}
|
||||
t.NonOwningReference = rcv.NonOwningReference()
|
||||
vectorOfNonOwningReferencesLength := rcv.VectorOfNonOwningReferencesLength()
|
||||
t.VectorOfNonOwningReferences = make([]uint64, vectorOfNonOwningReferencesLength)
|
||||
for j := 0; j < vectorOfNonOwningReferencesLength; j++ {
|
||||
t.VectorOfNonOwningReferences[j] = rcv.VectorOfNonOwningReferences(j)
|
||||
}
|
||||
anyUniqueTable := flatbuffers.Table{}
|
||||
if rcv.AnyUnique(&anyUniqueTable) {
|
||||
t.AnyUnique = AnyUniqueAliasesUnPack(rcv.AnyUniqueType(), anyUniqueTable)
|
||||
}
|
||||
anyAmbiguousTable := flatbuffers.Table{}
|
||||
if rcv.AnyAmbiguous(&anyAmbiguousTable) {
|
||||
t.AnyAmbiguous = AnyAmbiguousAliasesUnPack(rcv.AnyAmbiguousType(), anyAmbiguousTable)
|
||||
}
|
||||
vectorOfEnumsLength := rcv.VectorOfEnumsLength()
|
||||
t.VectorOfEnums = make([]Color, vectorOfEnumsLength)
|
||||
for j := 0; j < vectorOfEnumsLength; j++ {
|
||||
t.VectorOfEnums[j] = rcv.VectorOfEnums(j)
|
||||
}
|
||||
t.SignedEnum = rcv.SignedEnum()
|
||||
return t
|
||||
}
|
||||
|
||||
type Monster struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
@@ -6,6 +6,24 @@ import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type ReferrableT struct {
|
||||
Id uint64
|
||||
}
|
||||
|
||||
func ReferrablePack(builder *flatbuffers.Builder, t *ReferrableT) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
ReferrableStart(builder)
|
||||
ReferrableAddId(builder, t.Id)
|
||||
return ReferrableEnd(builder)
|
||||
}
|
||||
|
||||
func (rcv *Referrable) UnPack() *ReferrableT {
|
||||
if rcv == nil { return nil }
|
||||
t := &ReferrableT{}
|
||||
t.Id = rcv.Id()
|
||||
return t
|
||||
}
|
||||
|
||||
type Referrable struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
@@ -6,6 +6,31 @@ import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type StatT struct {
|
||||
Id string
|
||||
Val int64
|
||||
Count uint16
|
||||
}
|
||||
|
||||
func StatPack(builder *flatbuffers.Builder, t *StatT) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
idOffset := builder.CreateString(t.Id)
|
||||
StatStart(builder)
|
||||
StatAddId(builder, idOffset)
|
||||
StatAddVal(builder, t.Val)
|
||||
StatAddCount(builder, t.Count)
|
||||
return StatEnd(builder)
|
||||
}
|
||||
|
||||
func (rcv *Stat) UnPack() *StatT {
|
||||
if rcv == nil { return nil }
|
||||
t := &StatT{}
|
||||
t.Id = string(rcv.Id())
|
||||
t.Val = rcv.Val()
|
||||
t.Count = rcv.Count()
|
||||
return t
|
||||
}
|
||||
|
||||
type Stat struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
@@ -6,6 +6,23 @@ import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type TestT struct {
|
||||
A int16
|
||||
B int8
|
||||
}
|
||||
|
||||
func TestPack(builder *flatbuffers.Builder, t *TestT) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
return CreateTest(builder, t.A, t.B)
|
||||
}
|
||||
func (rcv *Test) UnPack() *TestT {
|
||||
if rcv == nil { return nil }
|
||||
t := &TestT{}
|
||||
t.A = rcv.A()
|
||||
t.B = rcv.B()
|
||||
return t
|
||||
}
|
||||
|
||||
type Test struct {
|
||||
_tab flatbuffers.Struct
|
||||
}
|
||||
|
||||
@@ -6,6 +6,24 @@ import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type TestSimpleTableWithEnumT struct {
|
||||
Color Color
|
||||
}
|
||||
|
||||
func TestSimpleTableWithEnumPack(builder *flatbuffers.Builder, t *TestSimpleTableWithEnumT) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
TestSimpleTableWithEnumStart(builder)
|
||||
TestSimpleTableWithEnumAddColor(builder, t.Color)
|
||||
return TestSimpleTableWithEnumEnd(builder)
|
||||
}
|
||||
|
||||
func (rcv *TestSimpleTableWithEnum) UnPack() *TestSimpleTableWithEnumT {
|
||||
if rcv == nil { return nil }
|
||||
t := &TestSimpleTableWithEnumT{}
|
||||
t.Color = rcv.Color()
|
||||
return t
|
||||
}
|
||||
|
||||
type TestSimpleTableWithEnum struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
@@ -6,6 +6,83 @@ import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type TypeAliasesT struct {
|
||||
I8 int8
|
||||
U8 byte
|
||||
I16 int16
|
||||
U16 uint16
|
||||
I32 int32
|
||||
U32 uint32
|
||||
I64 int64
|
||||
U64 uint64
|
||||
F32 float32
|
||||
F64 float64
|
||||
V8 []int8
|
||||
Vf64 []float64
|
||||
}
|
||||
|
||||
func TypeAliasesPack(builder *flatbuffers.Builder, t *TypeAliasesT) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
v8Offset := flatbuffers.UOffsetT(0)
|
||||
if t.V8 != nil {
|
||||
v8Length := len(t.V8)
|
||||
TypeAliasesStartV8Vector(builder, v8Length)
|
||||
for j := v8Length - 1; j >= 0; j-- {
|
||||
builder.PrependInt8(t.V8[j])
|
||||
}
|
||||
v8Offset = builder.EndVector(v8Length)
|
||||
}
|
||||
vf64Offset := flatbuffers.UOffsetT(0)
|
||||
if t.Vf64 != nil {
|
||||
vf64Length := len(t.Vf64)
|
||||
TypeAliasesStartVf64Vector(builder, vf64Length)
|
||||
for j := vf64Length - 1; j >= 0; j-- {
|
||||
builder.PrependFloat64(t.Vf64[j])
|
||||
}
|
||||
vf64Offset = builder.EndVector(vf64Length)
|
||||
}
|
||||
TypeAliasesStart(builder)
|
||||
TypeAliasesAddI8(builder, t.I8)
|
||||
TypeAliasesAddU8(builder, t.U8)
|
||||
TypeAliasesAddI16(builder, t.I16)
|
||||
TypeAliasesAddU16(builder, t.U16)
|
||||
TypeAliasesAddI32(builder, t.I32)
|
||||
TypeAliasesAddU32(builder, t.U32)
|
||||
TypeAliasesAddI64(builder, t.I64)
|
||||
TypeAliasesAddU64(builder, t.U64)
|
||||
TypeAliasesAddF32(builder, t.F32)
|
||||
TypeAliasesAddF64(builder, t.F64)
|
||||
TypeAliasesAddV8(builder, v8Offset)
|
||||
TypeAliasesAddVf64(builder, vf64Offset)
|
||||
return TypeAliasesEnd(builder)
|
||||
}
|
||||
|
||||
func (rcv *TypeAliases) UnPack() *TypeAliasesT {
|
||||
if rcv == nil { return nil }
|
||||
t := &TypeAliasesT{}
|
||||
t.I8 = rcv.I8()
|
||||
t.U8 = rcv.U8()
|
||||
t.I16 = rcv.I16()
|
||||
t.U16 = rcv.U16()
|
||||
t.I32 = rcv.I32()
|
||||
t.U32 = rcv.U32()
|
||||
t.I64 = rcv.I64()
|
||||
t.U64 = rcv.U64()
|
||||
t.F32 = rcv.F32()
|
||||
t.F64 = rcv.F64()
|
||||
v8Length := rcv.V8Length()
|
||||
t.V8 = make([]int8, v8Length)
|
||||
for j := 0; j < v8Length; j++ {
|
||||
t.V8[j] = rcv.V8(j)
|
||||
}
|
||||
vf64Length := rcv.Vf64Length()
|
||||
t.Vf64 = make([]float64, vf64Length)
|
||||
for j := 0; j < vf64Length; j++ {
|
||||
t.Vf64[j] = rcv.Vf64(j)
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
type TypeAliases struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
@@ -6,6 +6,31 @@ import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type Vec3T struct {
|
||||
X float32
|
||||
Y float32
|
||||
Z float32
|
||||
Test1 float64
|
||||
Test2 Color
|
||||
Test3 *TestT
|
||||
}
|
||||
|
||||
func Vec3Pack(builder *flatbuffers.Builder, t *Vec3T) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
return CreateVec3(builder, t.X, t.Y, t.Z, t.Test1, t.Test2, t.Test3.A, t.Test3.B)
|
||||
}
|
||||
func (rcv *Vec3) UnPack() *Vec3T {
|
||||
if rcv == nil { return nil }
|
||||
t := &Vec3T{}
|
||||
t.X = rcv.X()
|
||||
t.Y = rcv.Y()
|
||||
t.Z = rcv.Z()
|
||||
t.Test1 = rcv.Test1()
|
||||
t.Test2 = rcv.Test2()
|
||||
t.Test3 = rcv.Test3(nil).UnPack()
|
||||
return t
|
||||
}
|
||||
|
||||
type Vec3 struct {
|
||||
_tab flatbuffers.Struct
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user