From ab6af18d9feeee3e7b01cd6ee62c5bf190982cfc Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Thu, 2 Jul 2020 21:18:21 +0200 Subject: [PATCH] Not using non-existent create method for obj api (#6015) Co-authored-by: Kamil Rojewski --- src/idl_gen_js_ts.cpp | 32 +++++- tests/monster_test_generated.ts | 101 +++++++++--------- .../namespace_test2_generated.ts | 20 ++-- 3 files changed, 89 insertions(+), 64 deletions(-) diff --git a/src/idl_gen_js_ts.cpp b/src/idl_gen_js_ts.cpp index 101fa29bc..6c6d619a9 100644 --- a/src/idl_gen_js_ts.cpp +++ b/src/idl_gen_js_ts.cpp @@ -969,17 +969,30 @@ class JsTsGenerator : public BaseGenerator { std::string constructor_func = "constructor("; constructor_func += (struct_def.fields.vec.empty() ? "" : "\n"); + + const auto has_create = struct_def.fixed || CanCreateFactoryMethod(struct_def); + std::string pack_func_prototype = "/**\n * " + GenTypeAnnotation(kParam, "flatbuffers.Builder", "builder") + " * " + GenTypeAnnotation(kReturns, "flatbuffers.Offset", "") + " */\npack(builder:flatbuffers.Builder): flatbuffers.Offset {\n"; + std::string pack_func_offset_decl; - std::string pack_func_create_call = + std::string pack_func_create_call; + + const auto struct_name = GenPrefixedTypeName(WrapInNameSpace(struct_def), struct_def.file); + + if (has_create) { + pack_func_create_call = " return " + - GenPrefixedTypeName(WrapInNameSpace(struct_def), struct_def.file) + + struct_name + ".create" + Verbose(struct_def) + "(builder" + (struct_def.fields.vec.empty() ? "" : ",\n "); + } else { + pack_func_create_call = " " + struct_name + ".start(builder);\n"; + } + if (struct_def.fixed) { // when packing struct, nested struct's members instead of the struct's // offset are used @@ -1179,14 +1192,19 @@ class JsTsGenerator : public BaseGenerator { if (!field_offset_decl.empty()) { pack_func_offset_decl += field_offset_decl + "\n"; } - pack_func_create_call += field_offset_val; + + if (has_create) { + pack_func_create_call += field_offset_val; + } else { + pack_func_create_call += " " + struct_name + ".add" + MakeCamel(field.name) + "(builder, " + field_offset_val + ");\n"; + } } if (std::next(it) != struct_def.fields.vec.end()) { constructor_annotation += "\n"; constructor_func += ",\n"; - if (!struct_def.fixed) { pack_func_create_call += ",\n "; } + if (!struct_def.fixed && has_create) { pack_func_create_call += ",\n "; } unpack_func += ",\n"; unpack_to_func += "\n"; @@ -1205,7 +1223,11 @@ class JsTsGenerator : public BaseGenerator { constructor_annotation += "\n */\n"; constructor_func += "){};\n\n"; - pack_func_create_call += ");"; + if (has_create) { + pack_func_create_call += ");"; + } else { + pack_func_create_call += "return " + struct_name + ".end(builder);"; + } obj_api_class = "\nexport class " + GetObjApiClassName(struct_def, parser.opts) + " {\n"; diff --git a/tests/monster_test_generated.ts b/tests/monster_test_generated.ts index 1130761d2..afdaeabdb 100644 --- a/tests/monster_test_generated.ts +++ b/tests/monster_test_generated.ts @@ -3167,56 +3167,57 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { const anyAmbiguous = builder.createObjectOffset(this.anyAmbiguous); const vectorOfEnums = MyGame.Example.Monster.createVectorOfEnumsVector(builder, this.vectorOfEnums); - return MyGame.Example.Monster.createMonster(builder, - (this.pos !== null ? this.pos!.pack(builder) : 0), - this.mana, - this.hp, - name, - inventory, - this.color, - this.testType, - test, - test4, - testarrayofstring, - testarrayoftables, - (this.enemy !== null ? this.enemy!.pack(builder) : 0), - testnestedflatbuffer, - (this.testempty !== null ? this.testempty!.pack(builder) : 0), - this.testbool, - this.testhashs32Fnv1, - this.testhashu32Fnv1, - this.testhashs64Fnv1, - this.testhashu64Fnv1, - this.testhashs32Fnv1a, - this.testhashu32Fnv1a, - this.testhashs64Fnv1a, - this.testhashu64Fnv1a, - testarrayofbools, - this.testf, - this.testf2, - this.testf3, - testarrayofstring2, - testarrayofsortedstruct, - flex, - test5, - vectorOfLongs, - vectorOfDoubles, - (this.parentNamespaceTest !== null ? this.parentNamespaceTest!.pack(builder) : 0), - vectorOfReferrables, - this.singleWeakReference, - vectorOfWeakReferences, - vectorOfStrongReferrables, - this.coOwningReference, - vectorOfCoOwningReferences, - this.nonOwningReference, - vectorOfNonOwningReferences, - this.anyUniqueType, - anyUnique, - this.anyAmbiguousType, - anyAmbiguous, - vectorOfEnums, - this.signedEnum - ); + MyGame.Example.Monster.start(builder); + MyGame.Example.Monster.addPos(builder, (this.pos !== null ? this.pos!.pack(builder) : 0)); + MyGame.Example.Monster.addMana(builder, this.mana); + MyGame.Example.Monster.addHp(builder, this.hp); + MyGame.Example.Monster.addName(builder, name); + MyGame.Example.Monster.addInventory(builder, inventory); + MyGame.Example.Monster.addColor(builder, this.color); + MyGame.Example.Monster.addTestType(builder, this.testType); + MyGame.Example.Monster.addTest(builder, test); + MyGame.Example.Monster.addTest4(builder, test4); + MyGame.Example.Monster.addTestarrayofstring(builder, testarrayofstring); + MyGame.Example.Monster.addTestarrayoftables(builder, testarrayoftables); + MyGame.Example.Monster.addEnemy(builder, (this.enemy !== null ? this.enemy!.pack(builder) : 0)); + MyGame.Example.Monster.addTestnestedflatbuffer(builder, testnestedflatbuffer); + MyGame.Example.Monster.addTestempty(builder, (this.testempty !== null ? this.testempty!.pack(builder) : 0)); + MyGame.Example.Monster.addTestbool(builder, this.testbool); + MyGame.Example.Monster.addTesthashs32Fnv1(builder, this.testhashs32Fnv1); + MyGame.Example.Monster.addTesthashu32Fnv1(builder, this.testhashu32Fnv1); + MyGame.Example.Monster.addTesthashs64Fnv1(builder, this.testhashs64Fnv1); + MyGame.Example.Monster.addTesthashu64Fnv1(builder, this.testhashu64Fnv1); + MyGame.Example.Monster.addTesthashs32Fnv1a(builder, this.testhashs32Fnv1a); + MyGame.Example.Monster.addTesthashu32Fnv1a(builder, this.testhashu32Fnv1a); + MyGame.Example.Monster.addTesthashs64Fnv1a(builder, this.testhashs64Fnv1a); + MyGame.Example.Monster.addTesthashu64Fnv1a(builder, this.testhashu64Fnv1a); + MyGame.Example.Monster.addTestarrayofbools(builder, testarrayofbools); + MyGame.Example.Monster.addTestf(builder, this.testf); + MyGame.Example.Monster.addTestf2(builder, this.testf2); + MyGame.Example.Monster.addTestf3(builder, this.testf3); + MyGame.Example.Monster.addTestarrayofstring2(builder, testarrayofstring2); + MyGame.Example.Monster.addTestarrayofsortedstruct(builder, testarrayofsortedstruct); + MyGame.Example.Monster.addFlex(builder, flex); + MyGame.Example.Monster.addTest5(builder, test5); + MyGame.Example.Monster.addVectorOfLongs(builder, vectorOfLongs); + MyGame.Example.Monster.addVectorOfDoubles(builder, vectorOfDoubles); + MyGame.Example.Monster.addParentNamespaceTest(builder, (this.parentNamespaceTest !== null ? this.parentNamespaceTest!.pack(builder) : 0)); + MyGame.Example.Monster.addVectorOfReferrables(builder, vectorOfReferrables); + MyGame.Example.Monster.addSingleWeakReference(builder, this.singleWeakReference); + MyGame.Example.Monster.addVectorOfWeakReferences(builder, vectorOfWeakReferences); + MyGame.Example.Monster.addVectorOfStrongReferrables(builder, vectorOfStrongReferrables); + MyGame.Example.Monster.addCoOwningReference(builder, this.coOwningReference); + MyGame.Example.Monster.addVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences); + MyGame.Example.Monster.addNonOwningReference(builder, this.nonOwningReference); + MyGame.Example.Monster.addVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences); + MyGame.Example.Monster.addAnyUniqueType(builder, this.anyUniqueType); + MyGame.Example.Monster.addAnyUnique(builder, anyUnique); + MyGame.Example.Monster.addAnyAmbiguousType(builder, this.anyAmbiguousType); + MyGame.Example.Monster.addAnyAmbiguous(builder, anyAmbiguous); + MyGame.Example.Monster.addVectorOfEnums(builder, vectorOfEnums); + MyGame.Example.Monster.addSignedEnum(builder, this.signedEnum); + + return MyGame.Example.Monster.end(builder); }; } } diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index d5a1cf0c2..495681bc4 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -160,11 +160,12 @@ constructor( * @returns flatbuffers.Offset */ pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return NamespaceA.TableInFirstNS.createTableInFirstNS(builder, - (this.fooTable !== null ? this.fooTable!.pack(builder) : 0), - this.fooEnum, - (this.fooStruct !== null ? this.fooStruct!.pack(builder) : 0) - ); + NamespaceA.TableInFirstNS.start(builder); + NamespaceA.TableInFirstNS.addFooTable(builder, (this.fooTable !== null ? this.fooTable!.pack(builder) : 0)); + NamespaceA.TableInFirstNS.addFooEnum(builder, this.fooEnum); + NamespaceA.TableInFirstNS.addFooStruct(builder, (this.fooStruct !== null ? this.fooStruct!.pack(builder) : 0)); + + return NamespaceA.TableInFirstNS.end(builder); }; } } @@ -292,10 +293,11 @@ constructor( * @returns flatbuffers.Offset */ pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return NamespaceC.TableInC.createTableInC(builder, - (this.referToA1 !== null ? this.referToA1!.pack(builder) : 0), - (this.referToA2 !== null ? this.referToA2!.pack(builder) : 0) - ); + NamespaceC.TableInC.start(builder); + NamespaceC.TableInC.addReferToA1(builder, (this.referToA1 !== null ? this.referToA1!.pack(builder) : 0)); + NamespaceC.TableInC.addReferToA2(builder, (this.referToA2 !== null ? this.referToA2!.pack(builder) : 0)); + + return NamespaceC.TableInC.end(builder); }; } }