BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-07-04 19:31:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

[csharp] flatc should generate a 'Create…' method for tables with struct field… (#5818)

Browse Source 
* flatc should generate a 'Create…' method for tables with struct fields when also generating the object based api (C#)
https://stackoverflow.com/questions/60724317/flatc-should-generate-a-create-method-for-tables-with-struct-fields-when-al

* missing namespace fixed: C:\projects\flatbuffers\tests\namespace_test\NamespaceA\TableInFirstNS.cs(30,7): error CS0246: The type or namespace name 'StructInNestedNST' could not be found (are you missing a using directive or an assembly reference?) [C:\projects\flatbuffers\tests\FlatBuffers.Test\FlatBuffers.Test.csproj]

Co-authored-by: stefan301 <Stefan.Felkel@de.Zuken.com>
This commit is contained in:
stefan301
2020-03-23 17:39:26 +01:00
committed by GitHub
parent c4231c3cb9
commit 3af7359345
3 changed files with 199 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/idl_gen_csharp.cpp
View File

@@ -947,7 +947,8 @@ class CSharpGenerator : public BaseGenerator {
} }
// JVM specifications restrict default constructor params to be < 255. // JVM specifications restrict default constructor params to be < 255.
// Longs and doubles take up 2 units, so we set the limit to be < 127. // Longs and doubles take up 2 units, so we set the limit to be < 127.
if (has_no_struct_fields && num_fields && num_fields < 127) { if ((has_no_struct_fields || opts.generate_object_based_api) &&
num_fields && num_fields < 127) {
struct_has_create = true; struct_has_create = true;
// Generate a table constructor of the form: // Generate a table constructor of the form:
// public static int createName(FlatBufferBuilder builder, args...) // public static int createName(FlatBufferBuilder builder, args...)
@@ -959,13 +960,22 @@ class CSharpGenerator : public BaseGenerator {
auto &field = **it; auto &field = **it;
if (field.deprecated) continue; if (field.deprecated) continue;
code += ",\n "; code += ",\n ";
code += GenTypeBasic(field.value.type); if (IsStruct(field.value.type) && opts.generate_object_based_api) {
code += " "; code += WrapInNameSpace(
code += field.name; field.value.type.struct_def->defined_namespace,
if (!IsScalar(field.value.type.base_type)) code += "Offset"; GenTypeName_ObjectAPI(field.value.type.struct_def->name, opts));
code += " ";
code += field.name;
code += " = null";
} else {
code += GenTypeBasic(field.value.type);
code += " ";
code += field.name;
if (!IsScalar(field.value.type.base_type)) code += "Offset";
code += " = "; code += " = ";
code += GenDefaultValueBasic(field); code += GenDefaultValueBasic(field);
}
} }
code += ") {\n builder."; code += ") {\n builder.";
code += "StartTable("; code += "StartTable(";
@@ -980,8 +990,16 @@ class CSharpGenerator : public BaseGenerator {
size == SizeOf(field.value.type.base_type))) { size == SizeOf(field.value.type.base_type))) {
code += " " + struct_def.name + "."; code += " " + struct_def.name + ".";
code += "Add"; code += "Add";
code += MakeCamel(field.name) + "(builder, " + field.name; code += MakeCamel(field.name) + "(builder, ";
if (!IsScalar(field.value.type.base_type)) code += "Offset"; if (IsStruct(field.value.type) &&
opts.generate_object_based_api) {
code += GenTypePointer(field.value.type) + ".Pack(builder, " +
field.name + ")";
} else {
code += field.name;
if (!IsScalar(field.value.type.base_type)) code += "Offset";
}
code += ");\n"; code += ");\n";
} }
} }
@@ -1643,8 +1661,11 @@ class CSharpGenerator : public BaseGenerator {
} else { } else {
code += ",\n"; code += ",\n";
if (field.value.type.struct_def->fixed) { if (field.value.type.struct_def->fixed) {
code += " " + GenTypeGet(field.value.type) + if (opts.generate_object_based_api)
".Pack(builder, _o." + camel_name + ")"; code += " _o." + camel_name;
else
code += " " + GenTypeGet(field.value.type) +
".Pack(builder, _o." + camel_name + ")";
} else { } else {
code += " _" + field.name; code += " _" + field.name;
} }

201
tests/MyGame/Example/Monster.cs
View File

@@ -189,6 +189,107 @@ public struct Monster : IFlatbufferObject
public MyGame.Example.Race SignedEnum { get { int o = __p.__offset(100); return o != 0 ? (MyGame.Example.Race)__p.bb.GetSbyte(o + __p.bb_pos) : MyGame.Example.Race.None; } } public MyGame.Example.Race SignedEnum { get { int o = __p.__offset(100); return o != 0 ? (MyGame.Example.Race)__p.bb.GetSbyte(o + __p.bb_pos) : MyGame.Example.Race.None; } }
public bool MutateSignedEnum(MyGame.Example.Race signed_enum) { int o = __p.__offset(100); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)signed_enum); return true; } else { return false; } } public bool MutateSignedEnum(MyGame.Example.Race signed_enum) { int o = __p.__offset(100); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)signed_enum); return true; } else { return false; } }
public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
MyGame.Example.Vec3T pos = null,
short mana = 150,
short hp = 100,
StringOffset nameOffset = default(StringOffset),
VectorOffset inventoryOffset = default(VectorOffset),
MyGame.Example.Color color = MyGame.Example.Color.Blue,
MyGame.Example.Any test_type = MyGame.Example.Any.NONE,
int testOffset = 0,
VectorOffset test4Offset = default(VectorOffset),
VectorOffset testarrayofstringOffset = default(VectorOffset),
VectorOffset testarrayoftablesOffset = default(VectorOffset),
Offset<MyGame.Example.Monster> enemyOffset = default(Offset<MyGame.Example.Monster>),
VectorOffset testnestedflatbufferOffset = default(VectorOffset),
Offset<MyGame.Example.Stat> testemptyOffset = default(Offset<MyGame.Example.Stat>),
bool testbool = false,
int testhashs32_fnv1 = 0,
uint testhashu32_fnv1 = 0,
long testhashs64_fnv1 = 0,
ulong testhashu64_fnv1 = 0,
int testhashs32_fnv1a = 0,
uint testhashu32_fnv1a = 0,
long testhashs64_fnv1a = 0,
ulong testhashu64_fnv1a = 0,
VectorOffset testarrayofboolsOffset = default(VectorOffset),
float testf = 3.14159f,
float testf2 = 3.0f,
float testf3 = 0.0f,
VectorOffset testarrayofstring2Offset = default(VectorOffset),
VectorOffset testarrayofsortedstructOffset = default(VectorOffset),
VectorOffset flexOffset = default(VectorOffset),
VectorOffset test5Offset = default(VectorOffset),
VectorOffset vector_of_longsOffset = default(VectorOffset),
VectorOffset vector_of_doublesOffset = default(VectorOffset),
Offset<MyGame.InParentNamespace> parent_namespace_testOffset = default(Offset<MyGame.InParentNamespace>),
VectorOffset vector_of_referrablesOffset = default(VectorOffset),
ulong single_weak_reference = 0,
VectorOffset vector_of_weak_referencesOffset = default(VectorOffset),
VectorOffset vector_of_strong_referrablesOffset = default(VectorOffset),
ulong co_owning_reference = 0,
VectorOffset vector_of_co_owning_referencesOffset = default(VectorOffset),
ulong non_owning_reference = 0,
VectorOffset vector_of_non_owning_referencesOffset = default(VectorOffset),
MyGame.Example.AnyUniqueAliases any_unique_type = MyGame.Example.AnyUniqueAliases.NONE,
int any_uniqueOffset = 0,
MyGame.Example.AnyAmbiguousAliases any_ambiguous_type = MyGame.Example.AnyAmbiguousAliases.NONE,
int any_ambiguousOffset = 0,
VectorOffset vector_of_enumsOffset = default(VectorOffset),
MyGame.Example.Race signed_enum = MyGame.Example.Race.None) {
builder.StartTable(49);
Monster.AddNonOwningReference(builder, non_owning_reference);
Monster.AddCoOwningReference(builder, co_owning_reference);
Monster.AddSingleWeakReference(builder, single_weak_reference);
Monster.AddTesthashu64Fnv1a(builder, testhashu64_fnv1a);
Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
Monster.AddVectorOfEnums(builder, vector_of_enumsOffset);
Monster.AddAnyAmbiguous(builder, any_ambiguousOffset);
Monster.AddAnyUnique(builder, any_uniqueOffset);
Monster.AddVectorOfNonOwningReferences(builder, vector_of_non_owning_referencesOffset);
Monster.AddVectorOfCoOwningReferences(builder, vector_of_co_owning_referencesOffset);
Monster.AddVectorOfStrongReferrables(builder, vector_of_strong_referrablesOffset);
Monster.AddVectorOfWeakReferences(builder, vector_of_weak_referencesOffset);
Monster.AddVectorOfReferrables(builder, vector_of_referrablesOffset);
Monster.AddParentNamespaceTest(builder, parent_namespace_testOffset);
Monster.AddVectorOfDoubles(builder, vector_of_doublesOffset);
Monster.AddVectorOfLongs(builder, vector_of_longsOffset);
Monster.AddTest5(builder, test5Offset);
Monster.AddFlex(builder, flexOffset);
Monster.AddTestarrayofsortedstruct(builder, testarrayofsortedstructOffset);
Monster.AddTestarrayofstring2(builder, testarrayofstring2Offset);
Monster.AddTestf3(builder, testf3);
Monster.AddTestf2(builder, testf2);
Monster.AddTestf(builder, testf);
Monster.AddTestarrayofbools(builder, testarrayofboolsOffset);
Monster.AddTesthashu32Fnv1a(builder, testhashu32_fnv1a);
Monster.AddTesthashs32Fnv1a(builder, testhashs32_fnv1a);
Monster.AddTesthashu32Fnv1(builder, testhashu32_fnv1);
Monster.AddTesthashs32Fnv1(builder, testhashs32_fnv1);
Monster.AddTestempty(builder, testemptyOffset);
Monster.AddTestnestedflatbuffer(builder, testnestedflatbufferOffset);
Monster.AddEnemy(builder, enemyOffset);
Monster.AddTestarrayoftables(builder, testarrayoftablesOffset);
Monster.AddTestarrayofstring(builder, testarrayofstringOffset);
Monster.AddTest4(builder, test4Offset);
Monster.AddTest(builder, testOffset);
Monster.AddInventory(builder, inventoryOffset);
Monster.AddName(builder, nameOffset);
Monster.AddPos(builder, MyGame.Example.Vec3.Pack(builder, pos));
Monster.AddHp(builder, hp);
Monster.AddMana(builder, mana);
Monster.AddSignedEnum(builder, signed_enum);
Monster.AddAnyAmbiguousType(builder, any_ambiguous_type);
Monster.AddAnyUniqueType(builder, any_unique_type);
Monster.AddTestbool(builder, testbool);
Monster.AddTestType(builder, test_type);
Monster.AddColor(builder, color);
return Monster.EndMonster(builder);
}
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(49); } public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(49); }
public static void AddPos(FlatBufferBuilder builder, Offset<MyGame.Example.Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); } public static void AddPos(FlatBufferBuilder builder, Offset<MyGame.Example.Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); }
public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); } public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
@@ -538,56 +639,56 @@ public struct Monster : IFlatbufferObject
var __vector_of_enums = _o.VectorOfEnums.ToArray(); var __vector_of_enums = _o.VectorOfEnums.ToArray();
_vector_of_enums = CreateVectorOfEnumsVector(builder, __vector_of_enums); _vector_of_enums = CreateVectorOfEnumsVector(builder, __vector_of_enums);
} }
StartMonster(builder); return CreateMonster(
AddPos(builder, MyGame.Example.Vec3.Pack(builder, _o.Pos)); builder,
AddMana(builder, _o.Mana); _o.Pos,
AddHp(builder, _o.Hp); _o.Mana,
AddName(builder, _name); _o.Hp,
AddInventory(builder, _inventory); _name,
AddColor(builder, _o.Color); _inventory,
AddTestType(builder, _test_type); _o.Color,
AddTest(builder, _test); _test_type,
AddTest4(builder, _test4); _test,
AddTestarrayofstring(builder, _testarrayofstring); _test4,
AddTestarrayoftables(builder, _testarrayoftables); _testarrayofstring,
AddEnemy(builder, _enemy); _testarrayoftables,
AddTestnestedflatbuffer(builder, _testnestedflatbuffer); _enemy,
AddTestempty(builder, _testempty); _testnestedflatbuffer,
AddTestbool(builder, _o.Testbool); _testempty,
AddTesthashs32Fnv1(builder, _o.Testhashs32Fnv1); _o.Testbool,
AddTesthashu32Fnv1(builder, _o.Testhashu32Fnv1); _o.Testhashs32Fnv1,
AddTesthashs64Fnv1(builder, _o.Testhashs64Fnv1); _o.Testhashu32Fnv1,
AddTesthashu64Fnv1(builder, _o.Testhashu64Fnv1); _o.Testhashs64Fnv1,
AddTesthashs32Fnv1a(builder, _o.Testhashs32Fnv1a); _o.Testhashu64Fnv1,
AddTesthashu32Fnv1a(builder, _o.Testhashu32Fnv1a); _o.Testhashs32Fnv1a,
AddTesthashs64Fnv1a(builder, _o.Testhashs64Fnv1a); _o.Testhashu32Fnv1a,
AddTesthashu64Fnv1a(builder, _o.Testhashu64Fnv1a); _o.Testhashs64Fnv1a,
AddTestarrayofbools(builder, _testarrayofbools); _o.Testhashu64Fnv1a,
AddTestf(builder, _o.Testf); _testarrayofbools,
AddTestf2(builder, _o.Testf2); _o.Testf,
AddTestf3(builder, _o.Testf3); _o.Testf2,
AddTestarrayofstring2(builder, _testarrayofstring2); _o.Testf3,
AddTestarrayofsortedstruct(builder, _testarrayofsortedstruct); _testarrayofstring2,
AddFlex(builder, _flex); _testarrayofsortedstruct,
AddTest5(builder, _test5); _flex,
AddVectorOfLongs(builder, _vector_of_longs); _test5,
AddVectorOfDoubles(builder, _vector_of_doubles); _vector_of_longs,
AddParentNamespaceTest(builder, _parent_namespace_test); _vector_of_doubles,
AddVectorOfReferrables(builder, _vector_of_referrables); _parent_namespace_test,
AddSingleWeakReference(builder, _o.SingleWeakReference); _vector_of_referrables,
AddVectorOfWeakReferences(builder, _vector_of_weak_references); _o.SingleWeakReference,
AddVectorOfStrongReferrables(builder, _vector_of_strong_referrables); _vector_of_weak_references,
AddCoOwningReference(builder, _o.CoOwningReference); _vector_of_strong_referrables,
AddVectorOfCoOwningReferences(builder, _vector_of_co_owning_references); _o.CoOwningReference,
AddNonOwningReference(builder, _o.NonOwningReference); _vector_of_co_owning_references,
AddVectorOfNonOwningReferences(builder, _vector_of_non_owning_references); _o.NonOwningReference,
AddAnyUniqueType(builder, _any_unique_type); _vector_of_non_owning_references,
AddAnyUnique(builder, _any_unique); _any_unique_type,
AddAnyAmbiguousType(builder, _any_ambiguous_type); _any_unique,
AddAnyAmbiguous(builder, _any_ambiguous); _any_ambiguous_type,
AddVectorOfEnums(builder, _vector_of_enums); _any_ambiguous,
AddSignedEnum(builder, _o.SignedEnum); _vector_of_enums,
return EndMonster(builder); _o.SignedEnum);
} }
}; };

21
tests/namespace_test/NamespaceA/TableInFirstNS.cs
View File

@@ -24,6 +24,17 @@ public struct TableInFirstNS : IFlatbufferObject
public bool MutateFooEnum(NamespaceA.NamespaceB.EnumInNestedNS foo_enum) { int o = __p.__offset(6); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)foo_enum); return true; } else { return false; } } public bool MutateFooEnum(NamespaceA.NamespaceB.EnumInNestedNS foo_enum) { int o = __p.__offset(6); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)foo_enum); return true; } else { return false; } }
public NamespaceA.NamespaceB.StructInNestedNS? FooStruct { get { int o = __p.__offset(8); return o != 0 ? (NamespaceA.NamespaceB.StructInNestedNS?)(new NamespaceA.NamespaceB.StructInNestedNS()).__assign(o + __p.bb_pos, __p.bb) : null; } } public NamespaceA.NamespaceB.StructInNestedNS? FooStruct { get { int o = __p.__offset(8); return o != 0 ? (NamespaceA.NamespaceB.StructInNestedNS?)(new NamespaceA.NamespaceB.StructInNestedNS()).__assign(o + __p.bb_pos, __p.bb) : null; } }
public static Offset<NamespaceA.TableInFirstNS> CreateTableInFirstNS(FlatBufferBuilder builder,
Offset<NamespaceA.NamespaceB.TableInNestedNS> foo_tableOffset = default(Offset<NamespaceA.NamespaceB.TableInNestedNS>),
NamespaceA.NamespaceB.EnumInNestedNS foo_enum = NamespaceA.NamespaceB.EnumInNestedNS.A,
NamespaceA.NamespaceB.StructInNestedNST foo_struct = null) {
builder.StartTable(3);
TableInFirstNS.AddFooStruct(builder, NamespaceA.NamespaceB.StructInNestedNS.Pack(builder, foo_struct));
TableInFirstNS.AddFooTable(builder, foo_tableOffset);
TableInFirstNS.AddFooEnum(builder, foo_enum);
return TableInFirstNS.EndTableInFirstNS(builder);
}
public static void StartTableInFirstNS(FlatBufferBuilder builder) { builder.StartTable(3); } public static void StartTableInFirstNS(FlatBufferBuilder builder) { builder.StartTable(3); }
public static void AddFooTable(FlatBufferBuilder builder, Offset<NamespaceA.NamespaceB.TableInNestedNS> fooTableOffset) { builder.AddOffset(0, fooTableOffset.Value, 0); } public static void AddFooTable(FlatBufferBuilder builder, Offset<NamespaceA.NamespaceB.TableInNestedNS> fooTableOffset) { builder.AddOffset(0, fooTableOffset.Value, 0); }
public static void AddFooEnum(FlatBufferBuilder builder, NamespaceA.NamespaceB.EnumInNestedNS fooEnum) { builder.AddSbyte(1, (sbyte)fooEnum, 0); } public static void AddFooEnum(FlatBufferBuilder builder, NamespaceA.NamespaceB.EnumInNestedNS fooEnum) { builder.AddSbyte(1, (sbyte)fooEnum, 0); }
@@ -45,11 +56,11 @@ public struct TableInFirstNS : IFlatbufferObject
public static Offset<NamespaceA.TableInFirstNS> Pack(FlatBufferBuilder builder, TableInFirstNST _o) { public static Offset<NamespaceA.TableInFirstNS> Pack(FlatBufferBuilder builder, TableInFirstNST _o) {
if (_o == null) return default(Offset<NamespaceA.TableInFirstNS>); 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); var _foo_table = _o.FooTable == null ? default(Offset<NamespaceA.NamespaceB.TableInNestedNS>) : NamespaceA.NamespaceB.TableInNestedNS.Pack(builder, _o.FooTable);
StartTableInFirstNS(builder); return CreateTableInFirstNS(
AddFooTable(builder, _foo_table); builder,
AddFooEnum(builder, _o.FooEnum); _foo_table,
AddFooStruct(builder, NamespaceA.NamespaceB.StructInNestedNS.Pack(builder, _o.FooStruct)); _o.FooEnum,
return EndTableInFirstNS(builder); _o.FooStruct);
} }
}; };