mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-21 09:05:44 +00:00
[C#] support Object API (#5710)
* [C#] support Object API * fix sign-compare * fix indent * add new line before for loop. * using auto whenever possible * reduce the amout of blank lines. * wip: support vectors of union * done: support unions of vectors * set C# version to 4.0 * remove null propagation operator * remove auto property initializer * remove expression-bodied method * remove pattern matching * add Example2 to NetTest.sh * separate JavaUsage.md and CsharpUsage.md from JavaCsharpUsage.md * add C# Object based API notes. * support vs2010. * remove range based for loop. * remove System.Linq * fix indent * CreateSharedString to CreateString * check shared attribute * snake case
This commit is contained in:
mugisoba
@@ -1,4 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup>
|
||||
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
|
||||
@@ -9,6 +9,7 @@
|
||||
<RootNamespace>FlatBuffers.Test</RootNamespace>
|
||||
<AssemblyName>FlatBuffers.Test</AssemblyName>
|
||||
<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
|
||||
<LangVersion>4</LangVersion>
|
||||
<FileAlignment>512</FileAlignment>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
|
||||
@@ -66,6 +67,9 @@
|
||||
<Compile Include="..\..\net\FlatBuffers\Table.cs">
|
||||
<Link>FlatBuffers\Table.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\MyGame\Example2\Monster.cs">
|
||||
<Link>MyGame\Example2\Monster.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\MyGame\Example\Any.cs">
|
||||
<Link>MyGame\Example\Any.cs</Link>
|
||||
</Compile>
|
||||
@@ -96,6 +100,9 @@
|
||||
<Compile Include="..\MyGame\Example\TestSimpleTableWithEnum.cs">
|
||||
<Link>MyGame\Example\TestSimpleTableWithEnum.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\MyGame\Example\TypeAliases.cs">
|
||||
<Link>MyGame\Example\TypeAliases.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\MyGame\Example\Vec3.cs">
|
||||
<Link>MyGame\Example\Vec3.cs</Link>
|
||||
</Compile>
|
||||
@@ -129,6 +136,21 @@
|
||||
<Compile Include="..\namespace_test\NamespaceA\TableInFirstNS.cs">
|
||||
<Link>NamespaceA\TableInFirstNS.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\union_vector\Attacker.cs">
|
||||
<Link>union_vector\Attacker.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\union_vector\BookReader.cs">
|
||||
<Link>union_vector\BookReader.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\union_vector\Character.cs">
|
||||
<Link>union_vector\Character.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\union_vector\Movie.cs">
|
||||
<Link>union_vector\Movie.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\union_vector\Rapunzel.cs">
|
||||
<Link>union_vector\Rapunzel.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="Assert.cs" />
|
||||
<Compile Include="ByteBufferTests.cs" />
|
||||
<Compile Include="FlatBufferBuilderTests.cs" />
|
||||
@@ -156,4 +178,4 @@
|
||||
<Target Name="AfterBuild">
|
||||
</Target>
|
||||
-->
|
||||
</Project>
|
||||
</Project>
|
||||
@@ -187,6 +187,7 @@ namespace FlatBuffers.Test
|
||||
Assert.AreEqual(pos.X, 1.0f);
|
||||
|
||||
TestBuffer(dataBuffer);
|
||||
TestObjectAPI(Monster.GetRootAsMonster(dataBuffer));
|
||||
}
|
||||
|
||||
private void TestBuffer(ByteBuffer bb)
|
||||
@@ -275,7 +276,7 @@ namespace FlatBuffers.Test
|
||||
Assert.IsTrue(monster.GetTestarrayofboolsBytes().HasValue);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
[FlatBuffersTestMethod]
|
||||
public void CanReadCppGeneratedWireFile()
|
||||
@@ -283,6 +284,7 @@ namespace FlatBuffers.Test
|
||||
var data = File.ReadAllBytes(@"Resources/monsterdata_test.mon");
|
||||
var bb = new ByteBuffer(data);
|
||||
TestBuffer(bb);
|
||||
TestObjectAPI(Monster.GetRootAsMonster(bb));
|
||||
}
|
||||
|
||||
[FlatBuffersTestMethod]
|
||||
@@ -311,6 +313,8 @@ namespace FlatBuffers.Test
|
||||
var mons = Monster.GetRootAsMonster(fbb.DataBuffer);
|
||||
var colors = mons.GetVectorOfEnumsArray();
|
||||
Assert.ArrayEqual(colorVec, colors);
|
||||
|
||||
TestObjectAPI(mons);
|
||||
}
|
||||
|
||||
[FlatBuffersTestMethod]
|
||||
@@ -350,6 +354,9 @@ namespace FlatBuffers.Test
|
||||
Assert.AreEqual(nestedMonsterMana, nestedMonster.Mana);
|
||||
Assert.AreEqual(nestedMonsterHp, nestedMonster.Hp);
|
||||
Assert.AreEqual(nestedMonsterName, nestedMonster.Name);
|
||||
|
||||
TestObjectAPI(mons);
|
||||
TestObjectAPI(nestedMonster);
|
||||
}
|
||||
|
||||
[FlatBuffersTestMethod]
|
||||
@@ -400,26 +407,392 @@ namespace FlatBuffers.Test
|
||||
|
||||
ArrayTable table = ArrayTable.GetRootAsArrayTable(builder.DataBuffer);
|
||||
|
||||
Assert.AreEqual(table.A?.A, 0.5f);
|
||||
for (int i = 0; i < 15; i++) Assert.AreEqual(table.A?.B(i), i);
|
||||
Assert.AreEqual(table.A?.C, (sbyte)1);
|
||||
Assert.AreEqual(table.A?.D(0).A(0), 1);
|
||||
Assert.AreEqual(table.A?.D(0).A(1), 2);
|
||||
Assert.AreEqual(table.A?.D(1).A(0), 3);
|
||||
Assert.AreEqual(table.A?.D(1).A(1), 4);
|
||||
Assert.AreEqual(table.A?.D(0).B, TestEnum.B);
|
||||
Assert.AreEqual(table.A?.D(1).B, TestEnum.C);
|
||||
Assert.AreEqual(table.A?.D(0).C(0), TestEnum.A);
|
||||
Assert.AreEqual(table.A?.D(0).C(1), TestEnum.B);
|
||||
Assert.AreEqual(table.A?.D(1).C(0), TestEnum.C);
|
||||
Assert.AreEqual(table.A?.D(1).C(1), TestEnum.B);
|
||||
Assert.AreEqual(table.A?.D(0).D(0), -1);
|
||||
Assert.AreEqual(table.A?.D(0).D(1), 1);
|
||||
Assert.AreEqual(table.A?.D(1).D(0), -2);
|
||||
Assert.AreEqual(table.A?.D(1).D(1), 2);
|
||||
Assert.AreEqual(table.A?.E, 2);
|
||||
Assert.AreEqual(table.A?.F(0), -1);
|
||||
Assert.AreEqual(table.A?.F(1), 1);
|
||||
Assert.AreEqual(table.A.Value.A, 0.5f);
|
||||
for (int i = 0; i < 15; i++) Assert.AreEqual(table.A.Value.B(i), i);
|
||||
Assert.AreEqual(table.A.Value.C, (sbyte)1);
|
||||
Assert.AreEqual(table.A.Value.D(0).A(0), 1);
|
||||
Assert.AreEqual(table.A.Value.D(0).A(1), 2);
|
||||
Assert.AreEqual(table.A.Value.D(1).A(0), 3);
|
||||
Assert.AreEqual(table.A.Value.D(1).A(1), 4);
|
||||
Assert.AreEqual(table.A.Value.D(0).B, TestEnum.B);
|
||||
Assert.AreEqual(table.A.Value.D(1).B, TestEnum.C);
|
||||
Assert.AreEqual(table.A.Value.D(0).C(0), TestEnum.A);
|
||||
Assert.AreEqual(table.A.Value.D(0).C(1), TestEnum.B);
|
||||
Assert.AreEqual(table.A.Value.D(1).C(0), TestEnum.C);
|
||||
Assert.AreEqual(table.A.Value.D(1).C(1), TestEnum.B);
|
||||
Assert.AreEqual(table.A.Value.D(0).D(0), -1);
|
||||
Assert.AreEqual(table.A.Value.D(0).D(1), 1);
|
||||
Assert.AreEqual(table.A.Value.D(1).D(0), -2);
|
||||
Assert.AreEqual(table.A.Value.D(1).D(1), 2);
|
||||
Assert.AreEqual(table.A.Value.E, 2);
|
||||
Assert.AreEqual(table.A.Value.F(0), -1);
|
||||
Assert.AreEqual(table.A.Value.F(1), 1);
|
||||
|
||||
TestObjectAPI(table);
|
||||
}
|
||||
|
||||
[FlatBuffersTestMethod]
|
||||
public void TestUnionVector()
|
||||
{
|
||||
var fbb = new FlatBufferBuilder(100);
|
||||
var rapunzel = Rapunzel.CreateRapunzel(fbb, 40).Value;
|
||||
|
||||
var characterTypes = new[]
|
||||
{
|
||||
Character.MuLan,
|
||||
Character.Belle,
|
||||
Character.Other,
|
||||
};
|
||||
var characterTypesOffset = Movie.CreateCharactersTypeVector(fbb, characterTypes);
|
||||
|
||||
var characters = new[]
|
||||
{
|
||||
Attacker.CreateAttacker(fbb, 10).Value,
|
||||
BookReader.CreateBookReader(fbb, 20).Value,
|
||||
fbb.CreateSharedString("Chip").Value,
|
||||
};
|
||||
var charactersOffset = Movie.CreateCharactersVector(fbb, characters);
|
||||
|
||||
var movieOffset = Movie.CreateMovie(
|
||||
fbb,
|
||||
Character.Rapunzel,
|
||||
rapunzel,
|
||||
characterTypesOffset,
|
||||
charactersOffset);
|
||||
Movie.FinishMovieBuffer(fbb, movieOffset);
|
||||
|
||||
var movie = Movie.GetRootAsMovie(fbb.DataBuffer);
|
||||
Assert.AreEqual(Character.Rapunzel, movie.MainCharacterType);
|
||||
Assert.AreEqual(40, movie.MainCharacter<Rapunzel>().Value.HairLength);
|
||||
|
||||
Assert.AreEqual(3, movie.CharactersLength);
|
||||
Assert.AreEqual(Character.MuLan, movie.CharactersType(0));
|
||||
Assert.AreEqual(10, movie.Characters<Attacker>(0).Value.SwordAttackDamage);
|
||||
Assert.AreEqual(Character.Belle, movie.CharactersType(1));
|
||||
Assert.AreEqual(20, movie.Characters<BookReader>(1).Value.BooksRead);
|
||||
Assert.AreEqual(Character.Other, movie.CharactersType(2));
|
||||
Assert.AreEqual("Chip", movie.CharactersAsString(2));
|
||||
|
||||
TestObjectAPI(movie);
|
||||
}
|
||||
|
||||
private void AreEqual(Monster a, MonsterT b)
|
||||
{
|
||||
Assert.AreEqual(a.Hp, b.Hp);
|
||||
Assert.AreEqual(a.Mana, b.Mana);
|
||||
Assert.AreEqual(a.Name, b.Name);
|
||||
|
||||
var posA = a.Pos;
|
||||
var posB = b.Pos;
|
||||
if (posA != null)
|
||||
{
|
||||
Assert.AreEqual(posA.Value.X, posB.X);
|
||||
Assert.AreEqual(posA.Value.Y, posB.Y);
|
||||
Assert.AreEqual(posA.Value.Z, posB.Z);
|
||||
|
||||
Assert.AreEqual(posA.Value.Test1, posB.Test1);
|
||||
Assert.AreEqual(posA.Value.Test2, posB.Test2);
|
||||
var tA = posA.Value.Test3;
|
||||
var tB = posB.Test3;
|
||||
Assert.AreEqual(tA.A, tB.A);
|
||||
Assert.AreEqual(tA.B, tB.B);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.TestType, b.Test.Type);
|
||||
if (a.TestType == Any.Monster)
|
||||
{
|
||||
var monster2A = a.Test<Monster>().Value;
|
||||
var monster2B = b.Test.AsMonster();
|
||||
Assert.AreEqual(monster2A.Name, monster2B.Name);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.InventoryLength, b.Inventory.Count);
|
||||
for (var i = 0; i < a.InventoryLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.Inventory(i), b.Inventory[i]);
|
||||
}
|
||||
|
||||
var inventoryArray = a.GetInventoryArray();
|
||||
var inventoryArrayLength = inventoryArray == null ? 0 : inventoryArray.Length;
|
||||
Assert.AreEqual(inventoryArrayLength, b.Inventory.Count);
|
||||
for (var i = 0; i < inventoryArrayLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(inventoryArray[i], b.Inventory[i]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.Test4Length, b.Test4.Count);
|
||||
for (var i = 0; i < a.Test4Length; ++i)
|
||||
{
|
||||
var t4A = a.Test4(i);
|
||||
var t4B = b.Test4[i];
|
||||
Assert.AreEqual(t4A.Value.A, t4B.A);
|
||||
Assert.AreEqual(t4A.Value.B, t4B.B);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.TestarrayofstringLength, b.Testarrayofstring.Count);
|
||||
for (var i = 0; i < a.TestarrayofstringLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.Testarrayofstring(i), b.Testarrayofstring[i]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.Testbool, b.Testbool);
|
||||
|
||||
Assert.AreEqual(a.TestarrayofboolsLength, b.Testarrayofbools.Count);
|
||||
for (var i = 0; i < a.TestarrayofboolsLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.Testarrayofbools(i), b.Testarrayofbools[i]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.VectorOfLongsLength, b.VectorOfLongs.Count);
|
||||
for (var i = 0; i < a.VectorOfLongsLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.VectorOfLongs(i), b.VectorOfLongs[i]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.VectorOfDoublesLength, b.VectorOfDoubles.Count);
|
||||
for (var i = 0; i < a.VectorOfDoublesLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.VectorOfDoubles(i), b.VectorOfDoubles[i]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.VectorOfEnumsLength, b.VectorOfEnums.Count);
|
||||
for (var i = 0; i < a.VectorOfEnumsLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.VectorOfEnums(i), b.VectorOfEnums[i]);
|
||||
}
|
||||
}
|
||||
|
||||
private void AreEqual(Monster a, Monster b)
|
||||
{
|
||||
Assert.AreEqual(a.Hp, b.Hp);
|
||||
Assert.AreEqual(a.Mana, b.Mana);
|
||||
Assert.AreEqual(a.Name, b.Name);
|
||||
|
||||
var posA = a.Pos;
|
||||
var posB = b.Pos;
|
||||
if (posA != null)
|
||||
{
|
||||
Assert.AreEqual(posA.Value.X, posB.Value.X);
|
||||
Assert.AreEqual(posA.Value.Y, posB.Value.Y);
|
||||
Assert.AreEqual(posA.Value.Z, posB.Value.Z);
|
||||
|
||||
Assert.AreEqual(posA.Value.Test1, posB.Value.Test1);
|
||||
Assert.AreEqual(posA.Value.Test2, posB.Value.Test2);
|
||||
var tA = posA.Value.Test3;
|
||||
var tB = posB.Value.Test3;
|
||||
Assert.AreEqual(tA.A, tB.A);
|
||||
Assert.AreEqual(tA.B, tB.B);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.TestType, b.TestType);
|
||||
if (a.TestType == Any.Monster)
|
||||
{
|
||||
var monster2A = a.Test<Monster>().Value;
|
||||
var monster2B = b.Test<Monster>().Value;
|
||||
Assert.AreEqual(monster2A.Name, monster2B.Name);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.InventoryLength, b.InventoryLength);
|
||||
for (var i = 0; i < a.InventoryLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.Inventory(i), b.Inventory(i));
|
||||
}
|
||||
|
||||
var inventoryArrayA = a.GetInventoryArray();
|
||||
var inventoryArrayALength = inventoryArrayA == null ? 0 : inventoryArrayA.Length;
|
||||
var inventoryArrayB = b.GetInventoryArray();
|
||||
var inventoryArrayBLength = inventoryArrayB == null ? 0 : inventoryArrayB.Length;
|
||||
Assert.AreEqual(inventoryArrayALength, inventoryArrayBLength);
|
||||
for (var i = 0; i < inventoryArrayALength; ++i)
|
||||
{
|
||||
Assert.AreEqual(inventoryArrayA[i], inventoryArrayB[i]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.Test4Length, b.Test4Length);
|
||||
for (var i = 0; i < a.Test4Length; ++i)
|
||||
{
|
||||
var t4A = a.Test4(i);
|
||||
var t4B = b.Test4(i);
|
||||
Assert.AreEqual(t4A.Value.A, t4B.Value.A);
|
||||
Assert.AreEqual(t4A.Value.B, t4B.Value.B);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.TestarrayofstringLength, b.TestarrayofstringLength);
|
||||
for (var i = 0; i < a.TestarrayofstringLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.Testarrayofstring(i), b.Testarrayofstring(i));
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.Testbool, b.Testbool);
|
||||
|
||||
Assert.AreEqual(a.TestarrayofboolsLength, b.TestarrayofboolsLength);
|
||||
for (var i = 0; i < a.TestarrayofboolsLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.Testarrayofbools(i), b.Testarrayofbools(i));
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.VectorOfLongsLength, b.VectorOfLongsLength);
|
||||
for (var i = 0; i < a.VectorOfLongsLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.VectorOfLongs(i), b.VectorOfLongs(i));
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.VectorOfDoublesLength, b.VectorOfDoublesLength);
|
||||
for (var i = 0; i < a.VectorOfDoublesLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.VectorOfDoubles(i), b.VectorOfDoubles(i));
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.VectorOfEnumsLength, b.VectorOfEnumsLength);
|
||||
for (var i = 0; i < a.VectorOfEnumsLength; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.VectorOfEnums(i), b.VectorOfEnums(i));
|
||||
}
|
||||
}
|
||||
|
||||
private void TestObjectAPI(Monster a)
|
||||
{
|
||||
var b = a.UnPack();
|
||||
AreEqual(a, b);
|
||||
|
||||
var fbb = new FlatBufferBuilder(1);
|
||||
fbb.Finish(Monster.Pack(fbb, b).Value);
|
||||
var c = Monster.GetRootAsMonster(fbb.DataBuffer);
|
||||
AreEqual(a, c);
|
||||
}
|
||||
|
||||
private void AreEqual(ArrayTable a, ArrayTableT b)
|
||||
{
|
||||
Assert.AreEqual(a.A.Value.A, b.A.A);
|
||||
|
||||
for (int i = 0; i < 15; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.A.Value.B(i), b.A.B[i]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.A.Value.C, b.A.C);
|
||||
|
||||
for (int i = 0; i < 2; ++i)
|
||||
{
|
||||
var ad = a.A.Value.D(i);
|
||||
var bd = b.A.D[i];
|
||||
|
||||
for (int j = 0; j < 2; ++j)
|
||||
{
|
||||
Assert.AreEqual(ad.A(j), bd.A[j]);
|
||||
}
|
||||
|
||||
Assert.AreEqual(ad.B, bd.B);
|
||||
|
||||
for (int j = 0; j < 2; ++j)
|
||||
{
|
||||
Assert.AreEqual(ad.C(j), bd.C[j]);
|
||||
}
|
||||
|
||||
for (int j = 0; j < 2; ++j)
|
||||
{
|
||||
Assert.AreEqual(ad.D(j), bd.D[j]);
|
||||
}
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.A.Value.E, b.A.E);
|
||||
|
||||
for (int i = 0; i < 2; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.A.Value.F(i), b.A.F[i]);
|
||||
}
|
||||
}
|
||||
|
||||
private void AreEqual(ArrayTable a, ArrayTable b)
|
||||
{
|
||||
Assert.AreEqual(a.A.Value.A, b.A.Value.A);
|
||||
|
||||
for (int i = 0; i < 15; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.A.Value.B(i), b.A.Value.B(i));
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.A.Value.C, b.A.Value.C);
|
||||
|
||||
for (int i = 0; i < 2; ++i)
|
||||
{
|
||||
var ad = a.A.Value.D(i);
|
||||
var bd = b.A.Value.D(i);
|
||||
|
||||
for (int j = 0; j < 2; ++j)
|
||||
{
|
||||
Assert.AreEqual(ad.A(j), bd.A(j));
|
||||
}
|
||||
|
||||
Assert.AreEqual(ad.B, bd.B);
|
||||
|
||||
for (int j = 0; j < 2; ++j)
|
||||
{
|
||||
Assert.AreEqual(ad.C(j), bd.C(j));
|
||||
}
|
||||
|
||||
for (int j = 0; j < 2; ++j)
|
||||
{
|
||||
Assert.AreEqual(ad.D(j), bd.D(j));
|
||||
}
|
||||
}
|
||||
|
||||
Assert.AreEqual(a.A.Value.E, b.A.Value.E);
|
||||
|
||||
for (int i = 0; i < 2; ++i)
|
||||
{
|
||||
Assert.AreEqual(a.A.Value.F(i), b.A.Value.F(i));
|
||||
}
|
||||
}
|
||||
|
||||
private void TestObjectAPI(ArrayTable a)
|
||||
{
|
||||
var b = a.UnPack();
|
||||
AreEqual(a, b);
|
||||
|
||||
var fbb = new FlatBufferBuilder(1);
|
||||
fbb.Finish(ArrayTable.Pack(fbb, b).Value);
|
||||
var c = ArrayTable.GetRootAsArrayTable(fbb.DataBuffer);
|
||||
AreEqual(a, c);
|
||||
}
|
||||
|
||||
private void AreEqual(Movie a, MovieT b)
|
||||
{
|
||||
Assert.AreEqual(a.MainCharacterType, b.MainCharacter.Type);
|
||||
Assert.AreEqual(a.MainCharacter<Rapunzel>().Value.HairLength, b.MainCharacter.AsRapunzel().HairLength);
|
||||
|
||||
Assert.AreEqual(a.CharactersLength, b.Characters.Count);
|
||||
Assert.AreEqual(a.CharactersType(0), b.Characters[0].Type);
|
||||
Assert.AreEqual(a.Characters<Attacker>(0).Value.SwordAttackDamage, b.Characters[0].AsMuLan().SwordAttackDamage);
|
||||
Assert.AreEqual(a.CharactersType(1), b.Characters[1].Type);
|
||||
Assert.AreEqual(a.Characters<BookReader>(1).Value.BooksRead, b.Characters[1].AsBelle().BooksRead);
|
||||
Assert.AreEqual(a.CharactersType(2), b.Characters[2].Type);
|
||||
Assert.AreEqual(a.CharactersAsString(2), b.Characters[2].AsOther());
|
||||
}
|
||||
|
||||
private void AreEqual(Movie a, Movie b)
|
||||
{
|
||||
Assert.AreEqual(a.MainCharacterType, b.MainCharacterType);
|
||||
Assert.AreEqual(a.MainCharacter<Rapunzel>().Value.HairLength, b.MainCharacter<Rapunzel>().Value.HairLength);
|
||||
|
||||
Assert.AreEqual(a.CharactersLength, b.CharactersLength);
|
||||
Assert.AreEqual(a.CharactersType(0), b.CharactersType(0));
|
||||
Assert.AreEqual(a.Characters<Attacker>(0).Value.SwordAttackDamage, b.Characters<Attacker>(0).Value.SwordAttackDamage);
|
||||
Assert.AreEqual(a.CharactersType(1), b.CharactersType(1));
|
||||
Assert.AreEqual(a.Characters<BookReader>(1).Value.BooksRead, b.Characters<BookReader>(1).Value.BooksRead);
|
||||
Assert.AreEqual(a.CharactersType(2), b.CharactersType(2));
|
||||
Assert.AreEqual(a.CharactersAsString(2), b.CharactersAsString(2));
|
||||
}
|
||||
|
||||
private void TestObjectAPI(Movie a)
|
||||
{
|
||||
var b = a.UnPack();
|
||||
AreEqual(a, b);
|
||||
|
||||
var fbb = new FlatBufferBuilder(1);
|
||||
fbb.Finish(Movie.Pack(fbb, b).Value);
|
||||
var c = Movie.GetRootAsMovie(fbb.DataBuffer);
|
||||
AreEqual(a, c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
# Testing C# on Linux using Mono.
|
||||
|
||||
mcs -debug -out:./fbnettest.exe \
|
||||
../../net/FlatBuffers/*.cs ../MyGame/Example/*.cs ../MyGame/*.cs ../union_vector/*.cs \
|
||||
../../net/FlatBuffers/*.cs ../MyGame/Example/*.cs ../MyGame/Example2/*.cs ../MyGame/*.cs ../union_vector/*.cs \
|
||||
FlatBuffersTestClassAttribute.cs FlatBuffersTestMethodAttribute.cs Assert.cs FlatBuffersExampleTests.cs Program.cs ByteBufferTests.cs FlatBufferBuilderTests.cs FlatBuffersFuzzTests.cs FuzzTestData.cs Lcg.cs TestTable.cs
|
||||
mono --debug ./fbnettest.exe
|
||||
rm fbnettest.exe
|
||||
@@ -14,7 +14,7 @@ rm Resources/monsterdata_cstest_sp.mon
|
||||
|
||||
mcs -debug -out:./fbnettest.exe \
|
||||
-unsafe -d:UNSAFE_BYTEBUFFER \
|
||||
../../net/FlatBuffers/*.cs ../MyGame/Example/*.cs ../MyGame/*.cs ../union_vector/*.cs\
|
||||
../../net/FlatBuffers/*.cs ../MyGame/Example/*.cs ../MyGame/Example2/*.cs ../MyGame/*.cs ../union_vector/*.cs\
|
||||
FlatBuffersTestClassAttribute.cs FlatBuffersTestMethodAttribute.cs Assert.cs FlatBuffersExampleTests.cs Program.cs ByteBufferTests.cs FlatBufferBuilderTests.cs FlatBuffersFuzzTests.cs FuzzTestData.cs Lcg.cs TestTable.cs
|
||||
mono --debug ./fbnettest.exe
|
||||
rm fbnettest.exe
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Ability : IFlatbufferObject
|
||||
@@ -26,7 +27,34 @@ public struct Ability : IFlatbufferObject
|
||||
builder.PutUint(Id);
|
||||
return new Offset<MyGame.Example.Ability>(builder.Offset);
|
||||
}
|
||||
public AbilityT UnPack() {
|
||||
var _o = new AbilityT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(AbilityT _o) {
|
||||
_o.Id = this.Id;
|
||||
_o.Distance = this.Distance;
|
||||
}
|
||||
public static Offset<MyGame.Example.Ability> Pack(FlatBufferBuilder builder, AbilityT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.Ability>);
|
||||
return CreateAbility(
|
||||
builder,
|
||||
_o.Id,
|
||||
_o.Distance);
|
||||
}
|
||||
};
|
||||
|
||||
public class AbilityT
|
||||
{
|
||||
public uint Id { get; set; }
|
||||
public uint Distance { get; set; }
|
||||
|
||||
public AbilityT() {
|
||||
this.Id = 0;
|
||||
this.Distance = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -13,5 +13,29 @@ public enum Any : byte
|
||||
MyGame_Example2_Monster = 3,
|
||||
};
|
||||
|
||||
public class AnyUnion {
|
||||
public Any Type { get; set; }
|
||||
public object Value { get; set; }
|
||||
|
||||
public AnyUnion() {
|
||||
this.Type = Any.NONE;
|
||||
this.Value = null;
|
||||
}
|
||||
|
||||
public T As<T>() where T : class { return this.Value as T; }
|
||||
public MyGame.Example.MonsterT AsMonster() { return this.As<MyGame.Example.MonsterT>(); }
|
||||
internal MyGame.Example.TestSimpleTableWithEnumT AsTestSimpleTableWithEnum() { return this.As<MyGame.Example.TestSimpleTableWithEnumT>(); }
|
||||
public MyGame.Example2.MonsterT AsMyGame_Example2_Monster() { return this.As<MyGame.Example2.MonsterT>(); }
|
||||
|
||||
public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUnion _o) {
|
||||
switch (_o.Type) {
|
||||
default: return 0;
|
||||
case Any.Monster: return MyGame.Example.Monster.Pack(builder, _o.AsMonster()).Value;
|
||||
case Any.TestSimpleTableWithEnum: return MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTestSimpleTableWithEnum()).Value;
|
||||
case Any.MyGame_Example2_Monster: return MyGame.Example2.Monster.Pack(builder, _o.AsMyGame_Example2_Monster()).Value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -13,5 +13,29 @@ public enum AnyAmbiguousAliases : byte
|
||||
M3 = 3,
|
||||
};
|
||||
|
||||
public class AnyAmbiguousAliasesUnion {
|
||||
public AnyAmbiguousAliases Type { get; set; }
|
||||
public object Value { get; set; }
|
||||
|
||||
public AnyAmbiguousAliasesUnion() {
|
||||
this.Type = AnyAmbiguousAliases.NONE;
|
||||
this.Value = null;
|
||||
}
|
||||
|
||||
public T As<T>() where T : class { return this.Value as T; }
|
||||
public MyGame.Example.MonsterT AsM1() { return this.As<MyGame.Example.MonsterT>(); }
|
||||
public MyGame.Example.MonsterT AsM2() { return this.As<MyGame.Example.MonsterT>(); }
|
||||
public MyGame.Example.MonsterT AsM3() { return this.As<MyGame.Example.MonsterT>(); }
|
||||
|
||||
public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyAmbiguousAliasesUnion _o) {
|
||||
switch (_o.Type) {
|
||||
default: return 0;
|
||||
case AnyAmbiguousAliases.M1: return MyGame.Example.Monster.Pack(builder, _o.AsM1()).Value;
|
||||
case AnyAmbiguousAliases.M2: return MyGame.Example.Monster.Pack(builder, _o.AsM2()).Value;
|
||||
case AnyAmbiguousAliases.M3: return MyGame.Example.Monster.Pack(builder, _o.AsM3()).Value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -13,5 +13,29 @@ public enum AnyUniqueAliases : byte
|
||||
M2 = 3,
|
||||
};
|
||||
|
||||
public class AnyUniqueAliasesUnion {
|
||||
public AnyUniqueAliases Type { get; set; }
|
||||
public object Value { get; set; }
|
||||
|
||||
public AnyUniqueAliasesUnion() {
|
||||
this.Type = AnyUniqueAliases.NONE;
|
||||
this.Value = null;
|
||||
}
|
||||
|
||||
public T As<T>() where T : class { return this.Value as T; }
|
||||
public MyGame.Example.MonsterT AsM() { return this.As<MyGame.Example.MonsterT>(); }
|
||||
internal MyGame.Example.TestSimpleTableWithEnumT AsTS() { return this.As<MyGame.Example.TestSimpleTableWithEnumT>(); }
|
||||
public MyGame.Example2.MonsterT AsM2() { return this.As<MyGame.Example2.MonsterT>(); }
|
||||
|
||||
public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUniqueAliasesUnion _o) {
|
||||
switch (_o.Type) {
|
||||
default: return 0;
|
||||
case AnyUniqueAliases.M: return MyGame.Example.Monster.Pack(builder, _o.AsM()).Value;
|
||||
case AnyUniqueAliases.TS: return MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTS()).Value;
|
||||
case AnyUniqueAliases.M2: return MyGame.Example2.Monster.Pack(builder, _o.AsM2()).Value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct ArrayStruct : IFlatbufferObject
|
||||
@@ -56,7 +57,66 @@ public struct ArrayStruct : IFlatbufferObject
|
||||
builder.PutFloat(A);
|
||||
return new Offset<MyGame.Example.ArrayStruct>(builder.Offset);
|
||||
}
|
||||
public ArrayStructT UnPack() {
|
||||
var _o = new ArrayStructT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(ArrayStructT _o) {
|
||||
_o.A = this.A;
|
||||
_o.B = new int[15];
|
||||
for (var _j = 0; _j < 15; ++_j) { _o.B[_j] = this.B(_j); }
|
||||
_o.C = this.C;
|
||||
_o.D = new MyGame.Example.NestedStructT[2];
|
||||
for (var _j = 0; _j < 2; ++_j) { _o.D[_j] = this.D(_j).UnPack(); }
|
||||
_o.E = this.E;
|
||||
_o.F = new long[2];
|
||||
for (var _j = 0; _j < 2; ++_j) { _o.F[_j] = this.F(_j); }
|
||||
}
|
||||
public static Offset<MyGame.Example.ArrayStruct> Pack(FlatBufferBuilder builder, ArrayStructT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.ArrayStruct>);
|
||||
var _b = _o.B;
|
||||
var _d_a = new int[2,2];
|
||||
for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_a[idx0,idx1] = _o.D[idx0].A[idx1];}}
|
||||
var _d_b = new MyGame.Example.TestEnum[2];
|
||||
for (var idx0 = 0; idx0 < 2; ++idx0) {_d_b[idx0] = _o.D[idx0].B;}
|
||||
var _d_c = new MyGame.Example.TestEnum[2,2];
|
||||
for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_c[idx0,idx1] = _o.D[idx0].C[idx1];}}
|
||||
var _d_d = new long[2,2];
|
||||
for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_d[idx0,idx1] = _o.D[idx0].D[idx1];}}
|
||||
var _f = _o.F;
|
||||
return CreateArrayStruct(
|
||||
builder,
|
||||
_o.A,
|
||||
_b,
|
||||
_o.C,
|
||||
_d_a,
|
||||
_d_b,
|
||||
_d_c,
|
||||
_d_d,
|
||||
_o.E,
|
||||
_f);
|
||||
}
|
||||
};
|
||||
|
||||
public class ArrayStructT
|
||||
{
|
||||
public float A { get; set; }
|
||||
public int[] B { get; set; }
|
||||
public sbyte C { get; set; }
|
||||
public MyGame.Example.NestedStructT[] D { get; set; }
|
||||
public int E { get; set; }
|
||||
public long[] F { get; set; }
|
||||
|
||||
public ArrayStructT() {
|
||||
this.A = 0.0f;
|
||||
this.B = new int[15];
|
||||
this.C = 0;
|
||||
this.D = new MyGame.Example.NestedStructT[2];
|
||||
this.E = 0;
|
||||
this.F = new long[2];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct ArrayTable : IFlatbufferObject
|
||||
@@ -29,7 +30,30 @@ public struct ArrayTable : IFlatbufferObject
|
||||
}
|
||||
public static void FinishArrayTableBuffer(FlatBufferBuilder builder, Offset<MyGame.Example.ArrayTable> offset) { builder.Finish(offset.Value, "ARRT"); }
|
||||
public static void FinishSizePrefixedArrayTableBuffer(FlatBufferBuilder builder, Offset<MyGame.Example.ArrayTable> offset) { builder.FinishSizePrefixed(offset.Value, "ARRT"); }
|
||||
public ArrayTableT UnPack() {
|
||||
var _o = new ArrayTableT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(ArrayTableT _o) {
|
||||
_o.A = this.A.HasValue ? this.A.Value.UnPack() : null;
|
||||
}
|
||||
public static Offset<MyGame.Example.ArrayTable> Pack(FlatBufferBuilder builder, ArrayTableT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.ArrayTable>);
|
||||
StartArrayTable(builder);
|
||||
AddA(builder, MyGame.Example.ArrayStruct.Pack(builder, _o.A));
|
||||
return EndArrayTable(builder);
|
||||
}
|
||||
};
|
||||
|
||||
public class ArrayTableT
|
||||
{
|
||||
public MyGame.Example.ArrayStructT A { get; set; }
|
||||
|
||||
public ArrayTableT() {
|
||||
this.A = new MyGame.Example.ArrayStructT();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
/// an example documentation comment: monster object
|
||||
@@ -318,7 +319,374 @@ public struct Monster : IFlatbufferObject
|
||||
}
|
||||
return null;
|
||||
}
|
||||
public MonsterT UnPack() {
|
||||
var _o = new MonsterT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(MonsterT _o) {
|
||||
_o.Pos = this.Pos.HasValue ? this.Pos.Value.UnPack() : null;
|
||||
_o.Mana = this.Mana;
|
||||
_o.Hp = this.Hp;
|
||||
_o.Name = this.Name;
|
||||
_o.Inventory = new List<byte>();
|
||||
for (var _j = 0; _j < this.InventoryLength; ++_j) {_o.Inventory.Add(this.Inventory(_j));}
|
||||
_o.Color = this.Color;
|
||||
_o.Test = new MyGame.Example.AnyUnion();
|
||||
_o.Test.Type = this.TestType;
|
||||
switch (this.TestType) {
|
||||
default: break;
|
||||
case MyGame.Example.Any.Monster:
|
||||
_o.Test.Value = this.Test<MyGame.Example.Monster>().HasValue ? this.Test<MyGame.Example.Monster>().Value.UnPack() : null;
|
||||
break;
|
||||
case MyGame.Example.Any.TestSimpleTableWithEnum:
|
||||
_o.Test.Value = this.Test<MyGame.Example.TestSimpleTableWithEnum>().HasValue ? this.Test<MyGame.Example.TestSimpleTableWithEnum>().Value.UnPack() : null;
|
||||
break;
|
||||
case MyGame.Example.Any.MyGame_Example2_Monster:
|
||||
_o.Test.Value = this.Test<MyGame.Example2.Monster>().HasValue ? this.Test<MyGame.Example2.Monster>().Value.UnPack() : null;
|
||||
break;
|
||||
}
|
||||
_o.Test4 = new List<MyGame.Example.TestT>();
|
||||
for (var _j = 0; _j < this.Test4Length; ++_j) {_o.Test4.Add(this.Test4(_j).HasValue ? this.Test4(_j).Value.UnPack() : null);}
|
||||
_o.Testarrayofstring = new List<string>();
|
||||
for (var _j = 0; _j < this.TestarrayofstringLength; ++_j) {_o.Testarrayofstring.Add(this.Testarrayofstring(_j));}
|
||||
_o.Testarrayoftables = new List<MyGame.Example.MonsterT>();
|
||||
for (var _j = 0; _j < this.TestarrayoftablesLength; ++_j) {_o.Testarrayoftables.Add(this.Testarrayoftables(_j).HasValue ? this.Testarrayoftables(_j).Value.UnPack() : null);}
|
||||
_o.Enemy = this.Enemy.HasValue ? this.Enemy.Value.UnPack() : null;
|
||||
_o.Testnestedflatbuffer = new List<byte>();
|
||||
for (var _j = 0; _j < this.TestnestedflatbufferLength; ++_j) {_o.Testnestedflatbuffer.Add(this.Testnestedflatbuffer(_j));}
|
||||
_o.Testempty = this.Testempty.HasValue ? this.Testempty.Value.UnPack() : null;
|
||||
_o.Testbool = this.Testbool;
|
||||
_o.Testhashs32Fnv1 = this.Testhashs32Fnv1;
|
||||
_o.Testhashu32Fnv1 = this.Testhashu32Fnv1;
|
||||
_o.Testhashs64Fnv1 = this.Testhashs64Fnv1;
|
||||
_o.Testhashu64Fnv1 = this.Testhashu64Fnv1;
|
||||
_o.Testhashs32Fnv1a = this.Testhashs32Fnv1a;
|
||||
_o.Testhashu32Fnv1a = this.Testhashu32Fnv1a;
|
||||
_o.Testhashs64Fnv1a = this.Testhashs64Fnv1a;
|
||||
_o.Testhashu64Fnv1a = this.Testhashu64Fnv1a;
|
||||
_o.Testarrayofbools = new List<bool>();
|
||||
for (var _j = 0; _j < this.TestarrayofboolsLength; ++_j) {_o.Testarrayofbools.Add(this.Testarrayofbools(_j));}
|
||||
_o.Testf = this.Testf;
|
||||
_o.Testf2 = this.Testf2;
|
||||
_o.Testf3 = this.Testf3;
|
||||
_o.Testarrayofstring2 = new List<string>();
|
||||
for (var _j = 0; _j < this.Testarrayofstring2Length; ++_j) {_o.Testarrayofstring2.Add(this.Testarrayofstring2(_j));}
|
||||
_o.Testarrayofsortedstruct = new List<MyGame.Example.AbilityT>();
|
||||
for (var _j = 0; _j < this.TestarrayofsortedstructLength; ++_j) {_o.Testarrayofsortedstruct.Add(this.Testarrayofsortedstruct(_j).HasValue ? this.Testarrayofsortedstruct(_j).Value.UnPack() : null);}
|
||||
_o.Flex = new List<byte>();
|
||||
for (var _j = 0; _j < this.FlexLength; ++_j) {_o.Flex.Add(this.Flex(_j));}
|
||||
_o.Test5 = new List<MyGame.Example.TestT>();
|
||||
for (var _j = 0; _j < this.Test5Length; ++_j) {_o.Test5.Add(this.Test5(_j).HasValue ? this.Test5(_j).Value.UnPack() : null);}
|
||||
_o.VectorOfLongs = new List<long>();
|
||||
for (var _j = 0; _j < this.VectorOfLongsLength; ++_j) {_o.VectorOfLongs.Add(this.VectorOfLongs(_j));}
|
||||
_o.VectorOfDoubles = new List<double>();
|
||||
for (var _j = 0; _j < this.VectorOfDoublesLength; ++_j) {_o.VectorOfDoubles.Add(this.VectorOfDoubles(_j));}
|
||||
_o.ParentNamespaceTest = this.ParentNamespaceTest.HasValue ? this.ParentNamespaceTest.Value.UnPack() : null;
|
||||
_o.VectorOfReferrables = new List<MyGame.Example.ReferrableT>();
|
||||
for (var _j = 0; _j < this.VectorOfReferrablesLength; ++_j) {_o.VectorOfReferrables.Add(this.VectorOfReferrables(_j).HasValue ? this.VectorOfReferrables(_j).Value.UnPack() : null);}
|
||||
_o.SingleWeakReference = this.SingleWeakReference;
|
||||
_o.VectorOfWeakReferences = new List<ulong>();
|
||||
for (var _j = 0; _j < this.VectorOfWeakReferencesLength; ++_j) {_o.VectorOfWeakReferences.Add(this.VectorOfWeakReferences(_j));}
|
||||
_o.VectorOfStrongReferrables = new List<MyGame.Example.ReferrableT>();
|
||||
for (var _j = 0; _j < this.VectorOfStrongReferrablesLength; ++_j) {_o.VectorOfStrongReferrables.Add(this.VectorOfStrongReferrables(_j).HasValue ? this.VectorOfStrongReferrables(_j).Value.UnPack() : null);}
|
||||
_o.CoOwningReference = this.CoOwningReference;
|
||||
_o.VectorOfCoOwningReferences = new List<ulong>();
|
||||
for (var _j = 0; _j < this.VectorOfCoOwningReferencesLength; ++_j) {_o.VectorOfCoOwningReferences.Add(this.VectorOfCoOwningReferences(_j));}
|
||||
_o.NonOwningReference = this.NonOwningReference;
|
||||
_o.VectorOfNonOwningReferences = new List<ulong>();
|
||||
for (var _j = 0; _j < this.VectorOfNonOwningReferencesLength; ++_j) {_o.VectorOfNonOwningReferences.Add(this.VectorOfNonOwningReferences(_j));}
|
||||
_o.AnyUnique = new MyGame.Example.AnyUniqueAliasesUnion();
|
||||
_o.AnyUnique.Type = this.AnyUniqueType;
|
||||
switch (this.AnyUniqueType) {
|
||||
default: break;
|
||||
case MyGame.Example.AnyUniqueAliases.M:
|
||||
_o.AnyUnique.Value = this.AnyUnique<MyGame.Example.Monster>().HasValue ? this.AnyUnique<MyGame.Example.Monster>().Value.UnPack() : null;
|
||||
break;
|
||||
case MyGame.Example.AnyUniqueAliases.TS:
|
||||
_o.AnyUnique.Value = this.AnyUnique<MyGame.Example.TestSimpleTableWithEnum>().HasValue ? this.AnyUnique<MyGame.Example.TestSimpleTableWithEnum>().Value.UnPack() : null;
|
||||
break;
|
||||
case MyGame.Example.AnyUniqueAliases.M2:
|
||||
_o.AnyUnique.Value = this.AnyUnique<MyGame.Example2.Monster>().HasValue ? this.AnyUnique<MyGame.Example2.Monster>().Value.UnPack() : null;
|
||||
break;
|
||||
}
|
||||
_o.AnyAmbiguous = new MyGame.Example.AnyAmbiguousAliasesUnion();
|
||||
_o.AnyAmbiguous.Type = this.AnyAmbiguousType;
|
||||
switch (this.AnyAmbiguousType) {
|
||||
default: break;
|
||||
case MyGame.Example.AnyAmbiguousAliases.M1:
|
||||
_o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
|
||||
break;
|
||||
case MyGame.Example.AnyAmbiguousAliases.M2:
|
||||
_o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
|
||||
break;
|
||||
case MyGame.Example.AnyAmbiguousAliases.M3:
|
||||
_o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
|
||||
break;
|
||||
}
|
||||
_o.VectorOfEnums = new List<MyGame.Example.Color>();
|
||||
for (var _j = 0; _j < this.VectorOfEnumsLength; ++_j) {_o.VectorOfEnums.Add(this.VectorOfEnums(_j));}
|
||||
_o.SignedEnum = this.SignedEnum;
|
||||
}
|
||||
public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.Monster>);
|
||||
var _name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
|
||||
var _inventory = default(VectorOffset);
|
||||
if (_o.Inventory != null) {
|
||||
var __inventory = _o.Inventory.ToArray();
|
||||
_inventory = CreateInventoryVector(builder, __inventory);
|
||||
}
|
||||
var _test_type = _o.Test == null ? MyGame.Example.Any.NONE : _o.Test.Type;
|
||||
var _test = _o.Test == null ? 0 : MyGame.Example.AnyUnion.Pack(builder, _o.Test);
|
||||
var _test4 = default(VectorOffset);
|
||||
if (_o.Test4 != null) {
|
||||
StartTest4Vector(builder, _o.Test4.Count);
|
||||
for (var _j = _o.Test4.Count - 1; _j >= 0; --_j) { MyGame.Example.Test.Pack(builder, _o.Test4[_j]); }
|
||||
_test4 = builder.EndVector();
|
||||
}
|
||||
var _testarrayofstring = default(VectorOffset);
|
||||
if (_o.Testarrayofstring != null) {
|
||||
var __testarrayofstring = new StringOffset[_o.Testarrayofstring.Count];
|
||||
for (var _j = 0; _j < __testarrayofstring.Length; ++_j) { __testarrayofstring[_j] = builder.CreateString(_o.Testarrayofstring[_j]); }
|
||||
_testarrayofstring = CreateTestarrayofstringVector(builder, __testarrayofstring);
|
||||
}
|
||||
var _testarrayoftables = default(VectorOffset);
|
||||
if (_o.Testarrayoftables != null) {
|
||||
var __testarrayoftables = new Offset<MyGame.Example.Monster>[_o.Testarrayoftables.Count];
|
||||
for (var _j = 0; _j < __testarrayoftables.Length; ++_j) { __testarrayoftables[_j] = MyGame.Example.Monster.Pack(builder, _o.Testarrayoftables[_j]); }
|
||||
_testarrayoftables = CreateTestarrayoftablesVector(builder, __testarrayoftables);
|
||||
}
|
||||
var _enemy = _o.Enemy == null ? default(Offset<MyGame.Example.Monster>) : MyGame.Example.Monster.Pack(builder, _o.Enemy);
|
||||
var _testnestedflatbuffer = default(VectorOffset);
|
||||
if (_o.Testnestedflatbuffer != null) {
|
||||
var __testnestedflatbuffer = _o.Testnestedflatbuffer.ToArray();
|
||||
_testnestedflatbuffer = CreateTestnestedflatbufferVector(builder, __testnestedflatbuffer);
|
||||
}
|
||||
var _testempty = _o.Testempty == null ? default(Offset<MyGame.Example.Stat>) : MyGame.Example.Stat.Pack(builder, _o.Testempty);
|
||||
var _testarrayofbools = default(VectorOffset);
|
||||
if (_o.Testarrayofbools != null) {
|
||||
var __testarrayofbools = _o.Testarrayofbools.ToArray();
|
||||
_testarrayofbools = CreateTestarrayofboolsVector(builder, __testarrayofbools);
|
||||
}
|
||||
var _testarrayofstring2 = default(VectorOffset);
|
||||
if (_o.Testarrayofstring2 != null) {
|
||||
var __testarrayofstring2 = new StringOffset[_o.Testarrayofstring2.Count];
|
||||
for (var _j = 0; _j < __testarrayofstring2.Length; ++_j) { __testarrayofstring2[_j] = builder.CreateString(_o.Testarrayofstring2[_j]); }
|
||||
_testarrayofstring2 = CreateTestarrayofstring2Vector(builder, __testarrayofstring2);
|
||||
}
|
||||
var _testarrayofsortedstruct = default(VectorOffset);
|
||||
if (_o.Testarrayofsortedstruct != null) {
|
||||
StartTestarrayofsortedstructVector(builder, _o.Testarrayofsortedstruct.Count);
|
||||
for (var _j = _o.Testarrayofsortedstruct.Count - 1; _j >= 0; --_j) { MyGame.Example.Ability.Pack(builder, _o.Testarrayofsortedstruct[_j]); }
|
||||
_testarrayofsortedstruct = builder.EndVector();
|
||||
}
|
||||
var _flex = default(VectorOffset);
|
||||
if (_o.Flex != null) {
|
||||
var __flex = _o.Flex.ToArray();
|
||||
_flex = CreateFlexVector(builder, __flex);
|
||||
}
|
||||
var _test5 = default(VectorOffset);
|
||||
if (_o.Test5 != null) {
|
||||
StartTest5Vector(builder, _o.Test5.Count);
|
||||
for (var _j = _o.Test5.Count - 1; _j >= 0; --_j) { MyGame.Example.Test.Pack(builder, _o.Test5[_j]); }
|
||||
_test5 = builder.EndVector();
|
||||
}
|
||||
var _vector_of_longs = default(VectorOffset);
|
||||
if (_o.VectorOfLongs != null) {
|
||||
var __vector_of_longs = _o.VectorOfLongs.ToArray();
|
||||
_vector_of_longs = CreateVectorOfLongsVector(builder, __vector_of_longs);
|
||||
}
|
||||
var _vector_of_doubles = default(VectorOffset);
|
||||
if (_o.VectorOfDoubles != null) {
|
||||
var __vector_of_doubles = _o.VectorOfDoubles.ToArray();
|
||||
_vector_of_doubles = CreateVectorOfDoublesVector(builder, __vector_of_doubles);
|
||||
}
|
||||
var _parent_namespace_test = _o.ParentNamespaceTest == null ? default(Offset<MyGame.InParentNamespace>) : MyGame.InParentNamespace.Pack(builder, _o.ParentNamespaceTest);
|
||||
var _vector_of_referrables = default(VectorOffset);
|
||||
if (_o.VectorOfReferrables != null) {
|
||||
var __vector_of_referrables = new Offset<MyGame.Example.Referrable>[_o.VectorOfReferrables.Count];
|
||||
for (var _j = 0; _j < __vector_of_referrables.Length; ++_j) { __vector_of_referrables[_j] = MyGame.Example.Referrable.Pack(builder, _o.VectorOfReferrables[_j]); }
|
||||
_vector_of_referrables = CreateVectorOfReferrablesVector(builder, __vector_of_referrables);
|
||||
}
|
||||
var _vector_of_weak_references = default(VectorOffset);
|
||||
if (_o.VectorOfWeakReferences != null) {
|
||||
var __vector_of_weak_references = _o.VectorOfWeakReferences.ToArray();
|
||||
_vector_of_weak_references = CreateVectorOfWeakReferencesVector(builder, __vector_of_weak_references);
|
||||
}
|
||||
var _vector_of_strong_referrables = default(VectorOffset);
|
||||
if (_o.VectorOfStrongReferrables != null) {
|
||||
var __vector_of_strong_referrables = new Offset<MyGame.Example.Referrable>[_o.VectorOfStrongReferrables.Count];
|
||||
for (var _j = 0; _j < __vector_of_strong_referrables.Length; ++_j) { __vector_of_strong_referrables[_j] = MyGame.Example.Referrable.Pack(builder, _o.VectorOfStrongReferrables[_j]); }
|
||||
_vector_of_strong_referrables = CreateVectorOfStrongReferrablesVector(builder, __vector_of_strong_referrables);
|
||||
}
|
||||
var _vector_of_co_owning_references = default(VectorOffset);
|
||||
if (_o.VectorOfCoOwningReferences != null) {
|
||||
var __vector_of_co_owning_references = _o.VectorOfCoOwningReferences.ToArray();
|
||||
_vector_of_co_owning_references = CreateVectorOfCoOwningReferencesVector(builder, __vector_of_co_owning_references);
|
||||
}
|
||||
var _vector_of_non_owning_references = default(VectorOffset);
|
||||
if (_o.VectorOfNonOwningReferences != null) {
|
||||
var __vector_of_non_owning_references = _o.VectorOfNonOwningReferences.ToArray();
|
||||
_vector_of_non_owning_references = CreateVectorOfNonOwningReferencesVector(builder, __vector_of_non_owning_references);
|
||||
}
|
||||
var _any_unique_type = _o.AnyUnique == null ? MyGame.Example.AnyUniqueAliases.NONE : _o.AnyUnique.Type;
|
||||
var _any_unique = _o.AnyUnique == null ? 0 : MyGame.Example.AnyUniqueAliasesUnion.Pack(builder, _o.AnyUnique);
|
||||
var _any_ambiguous_type = _o.AnyAmbiguous == null ? MyGame.Example.AnyAmbiguousAliases.NONE : _o.AnyAmbiguous.Type;
|
||||
var _any_ambiguous = _o.AnyAmbiguous == null ? 0 : MyGame.Example.AnyAmbiguousAliasesUnion.Pack(builder, _o.AnyAmbiguous);
|
||||
var _vector_of_enums = default(VectorOffset);
|
||||
if (_o.VectorOfEnums != null) {
|
||||
var __vector_of_enums = _o.VectorOfEnums.ToArray();
|
||||
_vector_of_enums = CreateVectorOfEnumsVector(builder, __vector_of_enums);
|
||||
}
|
||||
StartMonster(builder);
|
||||
AddPos(builder, MyGame.Example.Vec3.Pack(builder, _o.Pos));
|
||||
AddMana(builder, _o.Mana);
|
||||
AddHp(builder, _o.Hp);
|
||||
AddName(builder, _name);
|
||||
AddInventory(builder, _inventory);
|
||||
AddColor(builder, _o.Color);
|
||||
AddTestType(builder, _test_type);
|
||||
AddTest(builder, _test);
|
||||
AddTest4(builder, _test4);
|
||||
AddTestarrayofstring(builder, _testarrayofstring);
|
||||
AddTestarrayoftables(builder, _testarrayoftables);
|
||||
AddEnemy(builder, _enemy);
|
||||
AddTestnestedflatbuffer(builder, _testnestedflatbuffer);
|
||||
AddTestempty(builder, _testempty);
|
||||
AddTestbool(builder, _o.Testbool);
|
||||
AddTesthashs32Fnv1(builder, _o.Testhashs32Fnv1);
|
||||
AddTesthashu32Fnv1(builder, _o.Testhashu32Fnv1);
|
||||
AddTesthashs64Fnv1(builder, _o.Testhashs64Fnv1);
|
||||
AddTesthashu64Fnv1(builder, _o.Testhashu64Fnv1);
|
||||
AddTesthashs32Fnv1a(builder, _o.Testhashs32Fnv1a);
|
||||
AddTesthashu32Fnv1a(builder, _o.Testhashu32Fnv1a);
|
||||
AddTesthashs64Fnv1a(builder, _o.Testhashs64Fnv1a);
|
||||
AddTesthashu64Fnv1a(builder, _o.Testhashu64Fnv1a);
|
||||
AddTestarrayofbools(builder, _testarrayofbools);
|
||||
AddTestf(builder, _o.Testf);
|
||||
AddTestf2(builder, _o.Testf2);
|
||||
AddTestf3(builder, _o.Testf3);
|
||||
AddTestarrayofstring2(builder, _testarrayofstring2);
|
||||
AddTestarrayofsortedstruct(builder, _testarrayofsortedstruct);
|
||||
AddFlex(builder, _flex);
|
||||
AddTest5(builder, _test5);
|
||||
AddVectorOfLongs(builder, _vector_of_longs);
|
||||
AddVectorOfDoubles(builder, _vector_of_doubles);
|
||||
AddParentNamespaceTest(builder, _parent_namespace_test);
|
||||
AddVectorOfReferrables(builder, _vector_of_referrables);
|
||||
AddSingleWeakReference(builder, _o.SingleWeakReference);
|
||||
AddVectorOfWeakReferences(builder, _vector_of_weak_references);
|
||||
AddVectorOfStrongReferrables(builder, _vector_of_strong_referrables);
|
||||
AddCoOwningReference(builder, _o.CoOwningReference);
|
||||
AddVectorOfCoOwningReferences(builder, _vector_of_co_owning_references);
|
||||
AddNonOwningReference(builder, _o.NonOwningReference);
|
||||
AddVectorOfNonOwningReferences(builder, _vector_of_non_owning_references);
|
||||
AddAnyUniqueType(builder, _any_unique_type);
|
||||
AddAnyUnique(builder, _any_unique);
|
||||
AddAnyAmbiguousType(builder, _any_ambiguous_type);
|
||||
AddAnyAmbiguous(builder, _any_ambiguous);
|
||||
AddVectorOfEnums(builder, _vector_of_enums);
|
||||
AddSignedEnum(builder, _o.SignedEnum);
|
||||
return EndMonster(builder);
|
||||
}
|
||||
};
|
||||
|
||||
public class MonsterT
|
||||
{
|
||||
public MyGame.Example.Vec3T Pos { get; set; }
|
||||
public short Mana { get; set; }
|
||||
public short Hp { get; set; }
|
||||
public string Name { get; set; }
|
||||
public List<byte> Inventory { get; set; }
|
||||
public MyGame.Example.Color Color { get; set; }
|
||||
public MyGame.Example.AnyUnion Test { get; set; }
|
||||
public List<MyGame.Example.TestT> Test4 { get; set; }
|
||||
public List<string> Testarrayofstring { get; set; }
|
||||
public List<MyGame.Example.MonsterT> Testarrayoftables { get; set; }
|
||||
public MyGame.Example.MonsterT Enemy { get; set; }
|
||||
public List<byte> Testnestedflatbuffer { get; set; }
|
||||
public MyGame.Example.StatT Testempty { get; set; }
|
||||
public bool Testbool { get; set; }
|
||||
public int Testhashs32Fnv1 { get; set; }
|
||||
public uint Testhashu32Fnv1 { get; set; }
|
||||
public long Testhashs64Fnv1 { get; set; }
|
||||
public ulong Testhashu64Fnv1 { get; set; }
|
||||
public int Testhashs32Fnv1a { get; set; }
|
||||
public uint Testhashu32Fnv1a { get; set; }
|
||||
public long Testhashs64Fnv1a { get; set; }
|
||||
public ulong Testhashu64Fnv1a { get; set; }
|
||||
public List<bool> Testarrayofbools { get; set; }
|
||||
public float Testf { get; set; }
|
||||
public float Testf2 { get; set; }
|
||||
public float Testf3 { get; set; }
|
||||
public List<string> Testarrayofstring2 { get; set; }
|
||||
public List<MyGame.Example.AbilityT> Testarrayofsortedstruct { get; set; }
|
||||
public List<byte> Flex { get; set; }
|
||||
public List<MyGame.Example.TestT> Test5 { get; set; }
|
||||
public List<long> VectorOfLongs { get; set; }
|
||||
public List<double> VectorOfDoubles { get; set; }
|
||||
public MyGame.InParentNamespaceT ParentNamespaceTest { get; set; }
|
||||
public List<MyGame.Example.ReferrableT> VectorOfReferrables { get; set; }
|
||||
public ulong SingleWeakReference { get; set; }
|
||||
public List<ulong> VectorOfWeakReferences { get; set; }
|
||||
public List<MyGame.Example.ReferrableT> VectorOfStrongReferrables { get; set; }
|
||||
public ulong CoOwningReference { get; set; }
|
||||
public List<ulong> VectorOfCoOwningReferences { get; set; }
|
||||
public ulong NonOwningReference { get; set; }
|
||||
public List<ulong> VectorOfNonOwningReferences { get; set; }
|
||||
public MyGame.Example.AnyUniqueAliasesUnion AnyUnique { get; set; }
|
||||
public MyGame.Example.AnyAmbiguousAliasesUnion AnyAmbiguous { get; set; }
|
||||
public List<MyGame.Example.Color> VectorOfEnums { get; set; }
|
||||
public MyGame.Example.Race SignedEnum { get; set; }
|
||||
|
||||
public MonsterT() {
|
||||
this.Pos = new MyGame.Example.Vec3T();
|
||||
this.Mana = 150;
|
||||
this.Hp = 100;
|
||||
this.Name = null;
|
||||
this.Inventory = null;
|
||||
this.Color = MyGame.Example.Color.Blue;
|
||||
this.Test = null;
|
||||
this.Test4 = null;
|
||||
this.Testarrayofstring = null;
|
||||
this.Testarrayoftables = null;
|
||||
this.Enemy = null;
|
||||
this.Testnestedflatbuffer = null;
|
||||
this.Testempty = null;
|
||||
this.Testbool = false;
|
||||
this.Testhashs32Fnv1 = 0;
|
||||
this.Testhashu32Fnv1 = 0;
|
||||
this.Testhashs64Fnv1 = 0;
|
||||
this.Testhashu64Fnv1 = 0;
|
||||
this.Testhashs32Fnv1a = 0;
|
||||
this.Testhashu32Fnv1a = 0;
|
||||
this.Testhashs64Fnv1a = 0;
|
||||
this.Testhashu64Fnv1a = 0;
|
||||
this.Testarrayofbools = null;
|
||||
this.Testf = 3.14159f;
|
||||
this.Testf2 = 3.0f;
|
||||
this.Testf3 = 0.0f;
|
||||
this.Testarrayofstring2 = null;
|
||||
this.Testarrayofsortedstruct = null;
|
||||
this.Flex = null;
|
||||
this.Test5 = null;
|
||||
this.VectorOfLongs = null;
|
||||
this.VectorOfDoubles = null;
|
||||
this.ParentNamespaceTest = null;
|
||||
this.VectorOfReferrables = null;
|
||||
this.SingleWeakReference = 0;
|
||||
this.VectorOfWeakReferences = null;
|
||||
this.VectorOfStrongReferrables = null;
|
||||
this.CoOwningReference = 0;
|
||||
this.VectorOfCoOwningReferences = null;
|
||||
this.NonOwningReference = 0;
|
||||
this.VectorOfNonOwningReferences = null;
|
||||
this.AnyUnique = null;
|
||||
this.AnyAmbiguous = null;
|
||||
this.VectorOfEnums = null;
|
||||
this.SignedEnum = MyGame.Example.Race.None;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct NestedStruct : IFlatbufferObject
|
||||
@@ -39,7 +40,48 @@ public struct NestedStruct : IFlatbufferObject
|
||||
}
|
||||
return new Offset<MyGame.Example.NestedStruct>(builder.Offset);
|
||||
}
|
||||
public NestedStructT UnPack() {
|
||||
var _o = new NestedStructT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(NestedStructT _o) {
|
||||
_o.A = new int[2];
|
||||
for (var _j = 0; _j < 2; ++_j) { _o.A[_j] = this.A(_j); }
|
||||
_o.B = this.B;
|
||||
_o.C = new MyGame.Example.TestEnum[2];
|
||||
for (var _j = 0; _j < 2; ++_j) { _o.C[_j] = this.C(_j); }
|
||||
_o.D = new long[2];
|
||||
for (var _j = 0; _j < 2; ++_j) { _o.D[_j] = this.D(_j); }
|
||||
}
|
||||
public static Offset<MyGame.Example.NestedStruct> Pack(FlatBufferBuilder builder, NestedStructT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.NestedStruct>);
|
||||
var _a = _o.A;
|
||||
var _c = _o.C;
|
||||
var _d = _o.D;
|
||||
return CreateNestedStruct(
|
||||
builder,
|
||||
_a,
|
||||
_o.B,
|
||||
_c,
|
||||
_d);
|
||||
}
|
||||
};
|
||||
|
||||
public class NestedStructT
|
||||
{
|
||||
public int[] A { get; set; }
|
||||
public MyGame.Example.TestEnum B { get; set; }
|
||||
public MyGame.Example.TestEnum[] C { get; set; }
|
||||
public long[] D { get; set; }
|
||||
|
||||
public NestedStructT() {
|
||||
this.A = new int[2];
|
||||
this.B = MyGame.Example.TestEnum.A;
|
||||
this.C = new MyGame.Example.TestEnum[2];
|
||||
this.D = new long[2];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Referrable : IFlatbufferObject
|
||||
@@ -59,7 +60,30 @@ public struct Referrable : IFlatbufferObject
|
||||
}
|
||||
return null;
|
||||
}
|
||||
public ReferrableT UnPack() {
|
||||
var _o = new ReferrableT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(ReferrableT _o) {
|
||||
_o.Id = this.Id;
|
||||
}
|
||||
public static Offset<MyGame.Example.Referrable> Pack(FlatBufferBuilder builder, ReferrableT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.Referrable>);
|
||||
return CreateReferrable(
|
||||
builder,
|
||||
_o.Id);
|
||||
}
|
||||
};
|
||||
|
||||
public class ReferrableT
|
||||
{
|
||||
public ulong Id { get; set; }
|
||||
|
||||
public ReferrableT() {
|
||||
this.Id = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Stat : IFlatbufferObject
|
||||
@@ -49,7 +50,39 @@ public struct Stat : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<MyGame.Example.Stat>(o);
|
||||
}
|
||||
public StatT UnPack() {
|
||||
var _o = new StatT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(StatT _o) {
|
||||
_o.Id = this.Id;
|
||||
_o.Val = this.Val;
|
||||
_o.Count = this.Count;
|
||||
}
|
||||
public static Offset<MyGame.Example.Stat> Pack(FlatBufferBuilder builder, StatT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.Stat>);
|
||||
var _id = _o.Id == null ? default(StringOffset) : builder.CreateString(_o.Id);
|
||||
return CreateStat(
|
||||
builder,
|
||||
_id,
|
||||
_o.Val,
|
||||
_o.Count);
|
||||
}
|
||||
};
|
||||
|
||||
public class StatT
|
||||
{
|
||||
public string Id { get; set; }
|
||||
public long Val { get; set; }
|
||||
public ushort Count { get; set; }
|
||||
|
||||
public StatT() {
|
||||
this.Id = null;
|
||||
this.Val = 0;
|
||||
this.Count = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Test : IFlatbufferObject
|
||||
@@ -27,7 +28,34 @@ public struct Test : IFlatbufferObject
|
||||
builder.PutShort(A);
|
||||
return new Offset<MyGame.Example.Test>(builder.Offset);
|
||||
}
|
||||
public TestT UnPack() {
|
||||
var _o = new TestT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(TestT _o) {
|
||||
_o.A = this.A;
|
||||
_o.B = this.B;
|
||||
}
|
||||
public static Offset<MyGame.Example.Test> Pack(FlatBufferBuilder builder, TestT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.Test>);
|
||||
return CreateTest(
|
||||
builder,
|
||||
_o.A,
|
||||
_o.B);
|
||||
}
|
||||
};
|
||||
|
||||
public class TestT
|
||||
{
|
||||
public short A { get; set; }
|
||||
public sbyte B { get; set; }
|
||||
|
||||
public TestT() {
|
||||
this.A = 0;
|
||||
this.B = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
internal partial struct TestSimpleTableWithEnum : IFlatbufferObject
|
||||
@@ -34,7 +35,30 @@ internal partial struct TestSimpleTableWithEnum : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<MyGame.Example.TestSimpleTableWithEnum>(o);
|
||||
}
|
||||
public TestSimpleTableWithEnumT UnPack() {
|
||||
var _o = new TestSimpleTableWithEnumT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(TestSimpleTableWithEnumT _o) {
|
||||
_o.Color = this.Color;
|
||||
}
|
||||
public static Offset<MyGame.Example.TestSimpleTableWithEnum> Pack(FlatBufferBuilder builder, TestSimpleTableWithEnumT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.TestSimpleTableWithEnum>);
|
||||
return CreateTestSimpleTableWithEnum(
|
||||
builder,
|
||||
_o.Color);
|
||||
}
|
||||
};
|
||||
|
||||
internal partial class TestSimpleTableWithEnumT
|
||||
{
|
||||
public MyGame.Example.Color Color { get; set; }
|
||||
|
||||
public TestSimpleTableWithEnumT() {
|
||||
this.Color = MyGame.Example.Color.Green;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct TypeAliases : IFlatbufferObject
|
||||
@@ -109,7 +110,86 @@ public struct TypeAliases : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<MyGame.Example.TypeAliases>(o);
|
||||
}
|
||||
public TypeAliasesT UnPack() {
|
||||
var _o = new TypeAliasesT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(TypeAliasesT _o) {
|
||||
_o.I8 = this.I8;
|
||||
_o.U8 = this.U8;
|
||||
_o.I16 = this.I16;
|
||||
_o.U16 = this.U16;
|
||||
_o.I32 = this.I32;
|
||||
_o.U32 = this.U32;
|
||||
_o.I64 = this.I64;
|
||||
_o.U64 = this.U64;
|
||||
_o.F32 = this.F32;
|
||||
_o.F64 = this.F64;
|
||||
_o.V8 = new List<sbyte>();
|
||||
for (var _j = 0; _j < this.V8Length; ++_j) {_o.V8.Add(this.V8(_j));}
|
||||
_o.Vf64 = new List<double>();
|
||||
for (var _j = 0; _j < this.Vf64Length; ++_j) {_o.Vf64.Add(this.Vf64(_j));}
|
||||
}
|
||||
public static Offset<MyGame.Example.TypeAliases> Pack(FlatBufferBuilder builder, TypeAliasesT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.TypeAliases>);
|
||||
var _v8 = default(VectorOffset);
|
||||
if (_o.V8 != null) {
|
||||
var __v8 = _o.V8.ToArray();
|
||||
_v8 = CreateV8Vector(builder, __v8);
|
||||
}
|
||||
var _vf64 = default(VectorOffset);
|
||||
if (_o.Vf64 != null) {
|
||||
var __vf64 = _o.Vf64.ToArray();
|
||||
_vf64 = CreateVf64Vector(builder, __vf64);
|
||||
}
|
||||
return CreateTypeAliases(
|
||||
builder,
|
||||
_o.I8,
|
||||
_o.U8,
|
||||
_o.I16,
|
||||
_o.U16,
|
||||
_o.I32,
|
||||
_o.U32,
|
||||
_o.I64,
|
||||
_o.U64,
|
||||
_o.F32,
|
||||
_o.F64,
|
||||
_v8,
|
||||
_vf64);
|
||||
}
|
||||
};
|
||||
|
||||
public class TypeAliasesT
|
||||
{
|
||||
public sbyte I8 { get; set; }
|
||||
public byte U8 { get; set; }
|
||||
public short I16 { get; set; }
|
||||
public ushort U16 { get; set; }
|
||||
public int I32 { get; set; }
|
||||
public uint U32 { get; set; }
|
||||
public long I64 { get; set; }
|
||||
public ulong U64 { get; set; }
|
||||
public float F32 { get; set; }
|
||||
public double F64 { get; set; }
|
||||
public List<sbyte> V8 { get; set; }
|
||||
public List<double> Vf64 { get; set; }
|
||||
|
||||
public TypeAliasesT() {
|
||||
this.I8 = 0;
|
||||
this.U8 = 0;
|
||||
this.I16 = 0;
|
||||
this.U16 = 0;
|
||||
this.I32 = 0;
|
||||
this.U32 = 0;
|
||||
this.I64 = 0;
|
||||
this.U64 = 0;
|
||||
this.F32 = 0.0f;
|
||||
this.F64 = 0.0;
|
||||
this.V8 = null;
|
||||
this.Vf64 = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Vec3 : IFlatbufferObject
|
||||
@@ -43,7 +44,51 @@ public struct Vec3 : IFlatbufferObject
|
||||
builder.PutFloat(X);
|
||||
return new Offset<MyGame.Example.Vec3>(builder.Offset);
|
||||
}
|
||||
public Vec3T UnPack() {
|
||||
var _o = new Vec3T();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(Vec3T _o) {
|
||||
_o.X = this.X;
|
||||
_o.Y = this.Y;
|
||||
_o.Z = this.Z;
|
||||
_o.Test1 = this.Test1;
|
||||
_o.Test2 = this.Test2;
|
||||
_o.Test3 = this.Test3.UnPack();
|
||||
}
|
||||
public static Offset<MyGame.Example.Vec3> Pack(FlatBufferBuilder builder, Vec3T _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.Vec3>);
|
||||
return CreateVec3(
|
||||
builder,
|
||||
_o.X,
|
||||
_o.Y,
|
||||
_o.Z,
|
||||
_o.Test1,
|
||||
_o.Test2,
|
||||
_o.Test3.A,
|
||||
_o.Test3.B);
|
||||
}
|
||||
};
|
||||
|
||||
public class Vec3T
|
||||
{
|
||||
public float X { get; set; }
|
||||
public float Y { get; set; }
|
||||
public float Z { get; set; }
|
||||
public double Test1 { get; set; }
|
||||
public MyGame.Example.Color Test2 { get; set; }
|
||||
public MyGame.Example.TestT Test3 { get; set; }
|
||||
|
||||
public Vec3T() {
|
||||
this.X = 0.0f;
|
||||
this.Y = 0.0f;
|
||||
this.Z = 0.0f;
|
||||
this.Test1 = 0.0;
|
||||
this.Test2 = 0;
|
||||
this.Test3 = new MyGame.Example.TestT();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame.Example2
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Monster : IFlatbufferObject
|
||||
@@ -24,7 +25,26 @@ public struct Monster : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<MyGame.Example2.Monster>(o);
|
||||
}
|
||||
public MonsterT UnPack() {
|
||||
var _o = new MonsterT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(MonsterT _o) {
|
||||
}
|
||||
public static Offset<MyGame.Example2.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example2.Monster>);
|
||||
StartMonster(builder);
|
||||
return EndMonster(builder);
|
||||
}
|
||||
};
|
||||
|
||||
public class MonsterT
|
||||
{
|
||||
|
||||
public MonsterT() {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct InParentNamespace : IFlatbufferObject
|
||||
@@ -24,7 +25,26 @@ public struct InParentNamespace : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<MyGame.InParentNamespace>(o);
|
||||
}
|
||||
public InParentNamespaceT UnPack() {
|
||||
var _o = new InParentNamespaceT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(InParentNamespaceT _o) {
|
||||
}
|
||||
public static Offset<MyGame.InParentNamespace> Pack(FlatBufferBuilder builder, InParentNamespaceT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.InParentNamespace>);
|
||||
StartInParentNamespace(builder);
|
||||
return EndInParentNamespace(builder);
|
||||
}
|
||||
};
|
||||
|
||||
public class InParentNamespaceT
|
||||
{
|
||||
|
||||
public InParentNamespaceT() {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace MyGame
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct MonsterExtra : IFlatbufferObject
|
||||
@@ -102,7 +103,78 @@ public struct MonsterExtra : IFlatbufferObject
|
||||
}
|
||||
public static void FinishMonsterExtraBuffer(FlatBufferBuilder builder, Offset<MyGame.MonsterExtra> offset) { builder.Finish(offset.Value, "MONE"); }
|
||||
public static void FinishSizePrefixedMonsterExtraBuffer(FlatBufferBuilder builder, Offset<MyGame.MonsterExtra> offset) { builder.FinishSizePrefixed(offset.Value, "MONE"); }
|
||||
public MonsterExtraT UnPack() {
|
||||
var _o = new MonsterExtraT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(MonsterExtraT _o) {
|
||||
_o.D0 = this.D0;
|
||||
_o.D1 = this.D1;
|
||||
_o.D2 = this.D2;
|
||||
_o.D3 = this.D3;
|
||||
_o.F0 = this.F0;
|
||||
_o.F1 = this.F1;
|
||||
_o.F2 = this.F2;
|
||||
_o.F3 = this.F3;
|
||||
_o.Dvec = new List<double>();
|
||||
for (var _j = 0; _j < this.DvecLength; ++_j) {_o.Dvec.Add(this.Dvec(_j));}
|
||||
_o.Fvec = new List<float>();
|
||||
for (var _j = 0; _j < this.FvecLength; ++_j) {_o.Fvec.Add(this.Fvec(_j));}
|
||||
}
|
||||
public static Offset<MyGame.MonsterExtra> Pack(FlatBufferBuilder builder, MonsterExtraT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.MonsterExtra>);
|
||||
var _dvec = default(VectorOffset);
|
||||
if (_o.Dvec != null) {
|
||||
var __dvec = _o.Dvec.ToArray();
|
||||
_dvec = CreateDvecVector(builder, __dvec);
|
||||
}
|
||||
var _fvec = default(VectorOffset);
|
||||
if (_o.Fvec != null) {
|
||||
var __fvec = _o.Fvec.ToArray();
|
||||
_fvec = CreateFvecVector(builder, __fvec);
|
||||
}
|
||||
return CreateMonsterExtra(
|
||||
builder,
|
||||
_o.D0,
|
||||
_o.D1,
|
||||
_o.D2,
|
||||
_o.D3,
|
||||
_o.F0,
|
||||
_o.F1,
|
||||
_o.F2,
|
||||
_o.F3,
|
||||
_dvec,
|
||||
_fvec);
|
||||
}
|
||||
};
|
||||
|
||||
public class MonsterExtraT
|
||||
{
|
||||
public double D0 { get; set; }
|
||||
public double D1 { get; set; }
|
||||
public double D2 { get; set; }
|
||||
public double D3 { get; set; }
|
||||
public float F0 { get; set; }
|
||||
public float F1 { get; set; }
|
||||
public float F2 { get; set; }
|
||||
public float F3 { get; set; }
|
||||
public List<double> Dvec { get; set; }
|
||||
public List<float> Fvec { get; set; }
|
||||
|
||||
public MonsterExtraT() {
|
||||
this.D0 = Double.NaN;
|
||||
this.D1 = Double.NaN;
|
||||
this.D2 = Double.PositiveInfinity;
|
||||
this.D3 = Double.NegativeInfinity;
|
||||
this.F0 = Single.NaN;
|
||||
this.F1 = Single.NaN;
|
||||
this.F2 = Single.PositiveInfinity;
|
||||
this.F3 = Single.NegativeInfinity;
|
||||
this.Dvec = null;
|
||||
this.Fvec = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace NamespaceA.NamespaceB
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct StructInNestedNS : IFlatbufferObject
|
||||
@@ -26,7 +27,34 @@ public struct StructInNestedNS : IFlatbufferObject
|
||||
builder.PutInt(A);
|
||||
return new Offset<NamespaceA.NamespaceB.StructInNestedNS>(builder.Offset);
|
||||
}
|
||||
public StructInNestedNST UnPack() {
|
||||
var _o = new StructInNestedNST();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(StructInNestedNST _o) {
|
||||
_o.A = this.A;
|
||||
_o.B = this.B;
|
||||
}
|
||||
public static Offset<NamespaceA.NamespaceB.StructInNestedNS> Pack(FlatBufferBuilder builder, StructInNestedNST _o) {
|
||||
if (_o == null) return default(Offset<NamespaceA.NamespaceB.StructInNestedNS>);
|
||||
return CreateStructInNestedNS(
|
||||
builder,
|
||||
_o.A,
|
||||
_o.B);
|
||||
}
|
||||
};
|
||||
|
||||
public class StructInNestedNST
|
||||
{
|
||||
public int A { get; set; }
|
||||
public int B { get; set; }
|
||||
|
||||
public StructInNestedNST() {
|
||||
this.A = 0;
|
||||
this.B = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace NamespaceA.NamespaceB
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct TableInNestedNS : IFlatbufferObject
|
||||
@@ -34,7 +35,30 @@ public struct TableInNestedNS : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<NamespaceA.NamespaceB.TableInNestedNS>(o);
|
||||
}
|
||||
public TableInNestedNST UnPack() {
|
||||
var _o = new TableInNestedNST();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(TableInNestedNST _o) {
|
||||
_o.Foo = this.Foo;
|
||||
}
|
||||
public static Offset<NamespaceA.NamespaceB.TableInNestedNS> Pack(FlatBufferBuilder builder, TableInNestedNST _o) {
|
||||
if (_o == null) return default(Offset<NamespaceA.NamespaceB.TableInNestedNS>);
|
||||
return CreateTableInNestedNS(
|
||||
builder,
|
||||
_o.Foo);
|
||||
}
|
||||
};
|
||||
|
||||
public class TableInNestedNST
|
||||
{
|
||||
public int Foo { get; set; }
|
||||
|
||||
public TableInNestedNST() {
|
||||
this.Foo = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace NamespaceA
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct SecondTableInA : IFlatbufferObject
|
||||
@@ -33,7 +34,31 @@ public struct SecondTableInA : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<NamespaceA.SecondTableInA>(o);
|
||||
}
|
||||
public SecondTableInAT UnPack() {
|
||||
var _o = new SecondTableInAT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(SecondTableInAT _o) {
|
||||
_o.ReferToC = this.ReferToC.HasValue ? this.ReferToC.Value.UnPack() : null;
|
||||
}
|
||||
public static Offset<NamespaceA.SecondTableInA> Pack(FlatBufferBuilder builder, SecondTableInAT _o) {
|
||||
if (_o == null) return default(Offset<NamespaceA.SecondTableInA>);
|
||||
var _refer_to_c = _o.ReferToC == null ? default(Offset<NamespaceC.TableInC>) : NamespaceC.TableInC.Pack(builder, _o.ReferToC);
|
||||
return CreateSecondTableInA(
|
||||
builder,
|
||||
_refer_to_c);
|
||||
}
|
||||
};
|
||||
|
||||
public class SecondTableInAT
|
||||
{
|
||||
public NamespaceC.TableInCT ReferToC { get; set; }
|
||||
|
||||
public SecondTableInAT() {
|
||||
this.ReferToC = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace NamespaceA
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct TableInFirstNS : IFlatbufferObject
|
||||
@@ -31,7 +32,39 @@ public struct TableInFirstNS : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<NamespaceA.TableInFirstNS>(o);
|
||||
}
|
||||
public TableInFirstNST UnPack() {
|
||||
var _o = new TableInFirstNST();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(TableInFirstNST _o) {
|
||||
_o.FooTable = this.FooTable.HasValue ? this.FooTable.Value.UnPack() : null;
|
||||
_o.FooEnum = this.FooEnum;
|
||||
_o.FooStruct = this.FooStruct.HasValue ? this.FooStruct.Value.UnPack() : null;
|
||||
}
|
||||
public static Offset<NamespaceA.TableInFirstNS> Pack(FlatBufferBuilder builder, TableInFirstNST _o) {
|
||||
if (_o == null) return default(Offset<NamespaceA.TableInFirstNS>);
|
||||
var _foo_table = _o.FooTable == null ? default(Offset<NamespaceA.NamespaceB.TableInNestedNS>) : NamespaceA.NamespaceB.TableInNestedNS.Pack(builder, _o.FooTable);
|
||||
StartTableInFirstNS(builder);
|
||||
AddFooTable(builder, _foo_table);
|
||||
AddFooEnum(builder, _o.FooEnum);
|
||||
AddFooStruct(builder, NamespaceA.NamespaceB.StructInNestedNS.Pack(builder, _o.FooStruct));
|
||||
return EndTableInFirstNS(builder);
|
||||
}
|
||||
};
|
||||
|
||||
public class TableInFirstNST
|
||||
{
|
||||
public NamespaceA.NamespaceB.TableInNestedNST FooTable { get; set; }
|
||||
public NamespaceA.NamespaceB.EnumInNestedNS FooEnum { get; set; }
|
||||
public NamespaceA.NamespaceB.StructInNestedNST FooStruct { get; set; }
|
||||
|
||||
public TableInFirstNST() {
|
||||
this.FooTable = null;
|
||||
this.FooEnum = NamespaceA.NamespaceB.EnumInNestedNS.A;
|
||||
this.FooStruct = new NamespaceA.NamespaceB.StructInNestedNST();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace NamespaceC
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct TableInC : IFlatbufferObject
|
||||
@@ -37,7 +38,36 @@ public struct TableInC : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<NamespaceC.TableInC>(o);
|
||||
}
|
||||
public TableInCT UnPack() {
|
||||
var _o = new TableInCT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(TableInCT _o) {
|
||||
_o.ReferToA1 = this.ReferToA1.HasValue ? this.ReferToA1.Value.UnPack() : null;
|
||||
_o.ReferToA2 = this.ReferToA2.HasValue ? this.ReferToA2.Value.UnPack() : null;
|
||||
}
|
||||
public static Offset<NamespaceC.TableInC> Pack(FlatBufferBuilder builder, TableInCT _o) {
|
||||
if (_o == null) return default(Offset<NamespaceC.TableInC>);
|
||||
var _refer_to_a1 = _o.ReferToA1 == null ? default(Offset<NamespaceA.TableInFirstNS>) : NamespaceA.TableInFirstNS.Pack(builder, _o.ReferToA1);
|
||||
var _refer_to_a2 = _o.ReferToA2 == null ? default(Offset<NamespaceA.SecondTableInA>) : NamespaceA.SecondTableInA.Pack(builder, _o.ReferToA2);
|
||||
return CreateTableInC(
|
||||
builder,
|
||||
_refer_to_a1,
|
||||
_refer_to_a2);
|
||||
}
|
||||
};
|
||||
|
||||
public class TableInCT
|
||||
{
|
||||
public NamespaceA.TableInFirstNST ReferToA1 { get; set; }
|
||||
public NamespaceA.SecondTableInAT ReferToA2 { get; set; }
|
||||
|
||||
public TableInCT() {
|
||||
this.ReferToA1 = null;
|
||||
this.ReferToA2 = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
// </auto-generated>
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Attacker : IFlatbufferObject
|
||||
@@ -31,5 +32,28 @@ public struct Attacker : IFlatbufferObject
|
||||
int o = builder.EndTable();
|
||||
return new Offset<Attacker>(o);
|
||||
}
|
||||
public AttackerT UnPack() {
|
||||
var _o = new AttackerT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(AttackerT _o) {
|
||||
_o.SwordAttackDamage = this.SwordAttackDamage;
|
||||
}
|
||||
public static Offset<Attacker> Pack(FlatBufferBuilder builder, AttackerT _o) {
|
||||
if (_o == null) return default(Offset<Attacker>);
|
||||
return CreateAttacker(
|
||||
builder,
|
||||
_o.SwordAttackDamage);
|
||||
}
|
||||
};
|
||||
|
||||
public class AttackerT
|
||||
{
|
||||
public int SwordAttackDamage { get; set; }
|
||||
|
||||
public AttackerT() {
|
||||
this.SwordAttackDamage = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
// </auto-generated>
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct BookReader : IFlatbufferObject
|
||||
@@ -20,5 +21,28 @@ public struct BookReader : IFlatbufferObject
|
||||
builder.PutInt(BooksRead);
|
||||
return new Offset<BookReader>(builder.Offset);
|
||||
}
|
||||
public BookReaderT UnPack() {
|
||||
var _o = new BookReaderT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(BookReaderT _o) {
|
||||
_o.BooksRead = this.BooksRead;
|
||||
}
|
||||
public static Offset<BookReader> Pack(FlatBufferBuilder builder, BookReaderT _o) {
|
||||
if (_o == null) return default(Offset<BookReader>);
|
||||
return CreateBookReader(
|
||||
builder,
|
||||
_o.BooksRead);
|
||||
}
|
||||
};
|
||||
|
||||
public class BookReaderT
|
||||
{
|
||||
public int BooksRead { get; set; }
|
||||
|
||||
public BookReaderT() {
|
||||
this.BooksRead = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -13,3 +13,33 @@ public enum Character : byte
|
||||
Unused = 6,
|
||||
};
|
||||
|
||||
public class CharacterUnion {
|
||||
public Character Type { get; set; }
|
||||
public object Value { get; set; }
|
||||
|
||||
public CharacterUnion() {
|
||||
this.Type = Character.NONE;
|
||||
this.Value = null;
|
||||
}
|
||||
|
||||
public T As<T>() where T : class { return this.Value as T; }
|
||||
public AttackerT AsMuLan() { return this.As<AttackerT>(); }
|
||||
public RapunzelT AsRapunzel() { return this.As<RapunzelT>(); }
|
||||
public BookReaderT AsBelle() { return this.As<BookReaderT>(); }
|
||||
public BookReaderT AsBookFan() { return this.As<BookReaderT>(); }
|
||||
public string AsOther() { return this.As<string>(); }
|
||||
public string AsUnused() { return this.As<string>(); }
|
||||
|
||||
public static int Pack(FlatBuffers.FlatBufferBuilder builder, CharacterUnion _o) {
|
||||
switch (_o.Type) {
|
||||
default: return 0;
|
||||
case Character.MuLan: return Attacker.Pack(builder, _o.AsMuLan()).Value;
|
||||
case Character.Rapunzel: return Rapunzel.Pack(builder, _o.AsRapunzel()).Value;
|
||||
case Character.Belle: return BookReader.Pack(builder, _o.AsBelle()).Value;
|
||||
case Character.BookFan: return BookReader.Pack(builder, _o.AsBookFan()).Value;
|
||||
case Character.Other: return builder.CreateString(_o.AsOther()).Value;
|
||||
case Character.Unused: return builder.CreateString(_o.AsUnused()).Value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
// </auto-generated>
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Movie : IFlatbufferObject
|
||||
@@ -18,6 +19,7 @@ public struct Movie : IFlatbufferObject
|
||||
|
||||
public Character MainCharacterType { get { int o = __p.__offset(4); return o != 0 ? (Character)__p.bb.Get(o + __p.bb_pos) : Character.NONE; } }
|
||||
public TTable? MainCharacter<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(6); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
|
||||
public string MainCharacterAsString() { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; }
|
||||
public Character CharactersType(int j) { int o = __p.__offset(8); return o != 0 ? (Character)__p.bb.Get(__p.__vector(o) + j * 1) : (Character)0; }
|
||||
public int CharactersTypeLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
|
||||
#if ENABLE_SPAN_T
|
||||
@@ -27,6 +29,7 @@ public struct Movie : IFlatbufferObject
|
||||
#endif
|
||||
public Character[] GetCharactersTypeArray() { int o = __p.__offset(8); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); Character[] a = new Character[l]; for (int i = 0; i < l; i++) { a[i] = (Character)__p.bb.Get(p + i * 1); } return a; }
|
||||
public TTable? Characters<TTable>(int j) where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(__p.__vector(o) + j * 4) : null; }
|
||||
public string CharactersAsString(int j) { int o = __p.__offset(10); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
|
||||
public int CharactersLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
|
||||
|
||||
public static Offset<Movie> CreateMovie(FlatBufferBuilder builder,
|
||||
@@ -59,5 +62,96 @@ public struct Movie : IFlatbufferObject
|
||||
}
|
||||
public static void FinishMovieBuffer(FlatBufferBuilder builder, Offset<Movie> offset) { builder.Finish(offset.Value, "MOVI"); }
|
||||
public static void FinishSizePrefixedMovieBuffer(FlatBufferBuilder builder, Offset<Movie> offset) { builder.FinishSizePrefixed(offset.Value, "MOVI"); }
|
||||
public MovieT UnPack() {
|
||||
var _o = new MovieT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(MovieT _o) {
|
||||
_o.MainCharacter = new CharacterUnion();
|
||||
_o.MainCharacter.Type = this.MainCharacterType;
|
||||
switch (this.MainCharacterType) {
|
||||
default: break;
|
||||
case Character.MuLan:
|
||||
_o.MainCharacter.Value = this.MainCharacter<Attacker>().HasValue ? this.MainCharacter<Attacker>().Value.UnPack() : null;
|
||||
break;
|
||||
case Character.Rapunzel:
|
||||
_o.MainCharacter.Value = this.MainCharacter<Rapunzel>().HasValue ? this.MainCharacter<Rapunzel>().Value.UnPack() : null;
|
||||
break;
|
||||
case Character.Belle:
|
||||
_o.MainCharacter.Value = this.MainCharacter<BookReader>().HasValue ? this.MainCharacter<BookReader>().Value.UnPack() : null;
|
||||
break;
|
||||
case Character.BookFan:
|
||||
_o.MainCharacter.Value = this.MainCharacter<BookReader>().HasValue ? this.MainCharacter<BookReader>().Value.UnPack() : null;
|
||||
break;
|
||||
case Character.Other:
|
||||
_o.MainCharacter.Value = this.MainCharacterAsString();
|
||||
break;
|
||||
case Character.Unused:
|
||||
_o.MainCharacter.Value = this.MainCharacterAsString();
|
||||
break;
|
||||
}
|
||||
_o.Characters = new List<CharacterUnion>();
|
||||
for (var _j = 0; _j < this.CharactersLength; ++_j) {
|
||||
var _o_Characters = new CharacterUnion();
|
||||
_o_Characters.Type = this.CharactersType(_j);
|
||||
switch (this.CharactersType(_j)) {
|
||||
default: break;
|
||||
case Character.MuLan:
|
||||
_o_Characters.Value = this.Characters<Attacker>(_j).HasValue ? this.Characters<Attacker>(_j).Value.UnPack() : null;
|
||||
break;
|
||||
case Character.Rapunzel:
|
||||
_o_Characters.Value = this.Characters<Rapunzel>(_j).HasValue ? this.Characters<Rapunzel>(_j).Value.UnPack() : null;
|
||||
break;
|
||||
case Character.Belle:
|
||||
_o_Characters.Value = this.Characters<BookReader>(_j).HasValue ? this.Characters<BookReader>(_j).Value.UnPack() : null;
|
||||
break;
|
||||
case Character.BookFan:
|
||||
_o_Characters.Value = this.Characters<BookReader>(_j).HasValue ? this.Characters<BookReader>(_j).Value.UnPack() : null;
|
||||
break;
|
||||
case Character.Other:
|
||||
_o_Characters.Value = this.CharactersAsString(_j);
|
||||
break;
|
||||
case Character.Unused:
|
||||
_o_Characters.Value = this.CharactersAsString(_j);
|
||||
break;
|
||||
}
|
||||
_o.Characters.Add(_o_Characters);
|
||||
}
|
||||
}
|
||||
public static Offset<Movie> Pack(FlatBufferBuilder builder, MovieT _o) {
|
||||
if (_o == null) return default(Offset<Movie>);
|
||||
var _main_character_type = _o.MainCharacter == null ? Character.NONE : _o.MainCharacter.Type;
|
||||
var _main_character = _o.MainCharacter == null ? 0 : CharacterUnion.Pack(builder, _o.MainCharacter);
|
||||
var _characters_type = default(VectorOffset);
|
||||
if (_o.Characters != null) {
|
||||
var __characters_type = new Character[_o.Characters.Count];
|
||||
for (var _j = 0; _j < __characters_type.Length; ++_j) { __characters_type[_j] = _o.Characters[_j].Type; }
|
||||
_characters_type = CreateCharactersTypeVector(builder, __characters_type);
|
||||
}
|
||||
var _characters = default(VectorOffset);
|
||||
if (_o.Characters != null) {
|
||||
var __characters = new int[_o.Characters.Count];
|
||||
for (var _j = 0; _j < __characters.Length; ++_j) { __characters[_j] = CharacterUnion.Pack(builder, _o.Characters[_j]); }
|
||||
_characters = CreateCharactersVector(builder, __characters);
|
||||
}
|
||||
return CreateMovie(
|
||||
builder,
|
||||
_main_character_type,
|
||||
_main_character,
|
||||
_characters_type,
|
||||
_characters);
|
||||
}
|
||||
};
|
||||
|
||||
public class MovieT
|
||||
{
|
||||
public CharacterUnion MainCharacter { get; set; }
|
||||
public List<CharacterUnion> Characters { get; set; }
|
||||
|
||||
public MovieT() {
|
||||
this.MainCharacter = null;
|
||||
this.Characters = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
// </auto-generated>
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::FlatBuffers;
|
||||
|
||||
public struct Rapunzel : IFlatbufferObject
|
||||
@@ -20,5 +21,28 @@ public struct Rapunzel : IFlatbufferObject
|
||||
builder.PutInt(HairLength);
|
||||
return new Offset<Rapunzel>(builder.Offset);
|
||||
}
|
||||
public RapunzelT UnPack() {
|
||||
var _o = new RapunzelT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(RapunzelT _o) {
|
||||
_o.HairLength = this.HairLength;
|
||||
}
|
||||
public static Offset<Rapunzel> Pack(FlatBufferBuilder builder, RapunzelT _o) {
|
||||
if (_o == null) return default(Offset<Rapunzel>);
|
||||
return CreateRapunzel(
|
||||
builder,
|
||||
_o.HairLength);
|
||||
}
|
||||
};
|
||||
|
||||
public class RapunzelT
|
||||
{
|
||||
public int HairLength { get; set; }
|
||||
|
||||
public RapunzelT() {
|
||||
this.HairLength = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user