From 48cf09ec32f5f650f8ed8a4e2c6d2c0be03882eb Mon Sep 17 00:00:00 2001 From: Didier Villevalois Date: Sat, 6 Feb 2021 13:53:26 +0100 Subject: [PATCH 1/3] [TS/JS] Fix TS code gen after #6420 --- src/idl_gen_ts.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp index 915b05e41fd..f8829e48c2c 100644 --- a/src/idl_gen_ts.cpp +++ b/src/idl_gen_ts.cpp @@ -1489,7 +1489,7 @@ class TsGenerator : public BaseGenerator { it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated && field.IsRequired()) { - code += " builder.IsRequired()Field(offset, "; + code += " builder.requiredField(offset, "; code += NumToString(field.value.offset); code += ") // " + field.name + "\n"; } From cf782edfa0f7a4b95b28d86570509da660b3909e Mon Sep 17 00:00:00 2001 From: Didier Villevalois Date: Sat, 6 Feb 2021 14:04:07 +0100 Subject: [PATCH 2/3] Outdated generated file by make --- .../namespace_test/namespace_test1_generated.h | 9 --------- .../namespace_test/namespace_test2_generated.h | 18 ------------------ tests/union_vector/union_vector_generated.h | 18 ------------------ 3 files changed, 45 deletions(-) diff --git a/tests/namespace_test/namespace_test1_generated.h b/tests/namespace_test/namespace_test1_generated.h index 540fa251746..05186fe6bf3 100644 --- a/tests/namespace_test/namespace_test1_generated.h +++ b/tests/namespace_test/namespace_test1_generated.h @@ -170,9 +170,6 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS static const flatbuffers::TypeTable *MiniReflectTypeTable() { return StructInNestedNSTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceA.NamespaceB.StructInNestedNS"; - } StructInNestedNS() : a_(0), b_(0) { @@ -209,9 +206,6 @@ inline bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs) struct TableInNestedNST : public flatbuffers::NativeTable { typedef TableInNestedNS TableType; - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceA.NamespaceB.TableInNestedNST"; - } int32_t foo = 0; }; @@ -231,9 +225,6 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return TableInNestedNSTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceA.NamespaceB.TableInNestedNS"; - } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FOO = 4 }; diff --git a/tests/namespace_test/namespace_test2_generated.h b/tests/namespace_test/namespace_test2_generated.h index 968e240ccb1..b7fc67209f2 100644 --- a/tests/namespace_test/namespace_test2_generated.h +++ b/tests/namespace_test/namespace_test2_generated.h @@ -59,9 +59,6 @@ inline const flatbuffers::TypeTable *SecondTableInATypeTable(); struct TableInFirstNST : public flatbuffers::NativeTable { typedef TableInFirstNS TableType; - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceA.TableInFirstNST"; - } flatbuffers::unique_ptr foo_table{}; NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A; NamespaceA::NamespaceB::UnionInNestedNSUnion foo_union{}; @@ -87,9 +84,6 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return TableInFirstNSTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceA.TableInFirstNS"; - } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FOO_TABLE = 4, VT_FOO_ENUM = 6, @@ -202,9 +196,6 @@ namespace NamespaceC { struct TableInCT : public flatbuffers::NativeTable { typedef TableInC TableType; - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceC.TableInCT"; - } flatbuffers::unique_ptr refer_to_a1{}; flatbuffers::unique_ptr refer_to_a2{}; }; @@ -226,9 +217,6 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return TableInCTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceC.TableInC"; - } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_REFER_TO_A1 = 4, VT_REFER_TO_A2 = 6 @@ -297,9 +285,6 @@ namespace NamespaceA { struct SecondTableInAT : public flatbuffers::NativeTable { typedef SecondTableInA TableType; - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceA.SecondTableInAT"; - } flatbuffers::unique_ptr refer_to_c{}; }; @@ -319,9 +304,6 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return SecondTableInATypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "NamespaceA.SecondTableInA"; - } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_REFER_TO_C = 4 }; diff --git a/tests/union_vector/union_vector_generated.h b/tests/union_vector/union_vector_generated.h index c819c98ad52..eba87a80195 100644 --- a/tests/union_vector/union_vector_generated.h +++ b/tests/union_vector/union_vector_generated.h @@ -202,9 +202,6 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return RapunzelTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "Rapunzel"; - } Rapunzel() : hair_length_(0) { } @@ -238,9 +235,6 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return BookReaderTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "BookReader"; - } BookReader() : books_read_(0) { } @@ -268,9 +262,6 @@ inline bool operator!=(const BookReader &lhs, const BookReader &rhs) { struct AttackerT : public flatbuffers::NativeTable { typedef Attacker TableType; - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "AttackerT"; - } int32_t sword_attack_damage = 0; }; @@ -290,9 +281,6 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return AttackerTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "Attacker"; - } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_SWORD_ATTACK_DAMAGE = 4 }; @@ -342,9 +330,6 @@ flatbuffers::Offset CreateAttacker(flatbuffers::FlatBufferBuilder &_fb struct MovieT : public flatbuffers::NativeTable { typedef Movie TableType; - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "MovieT"; - } CharacterUnion main_character{}; std::vector characters{}; }; @@ -366,9 +351,6 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { static const flatbuffers::TypeTable *MiniReflectTypeTable() { return MovieTypeTable(); } - static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() { - return "Movie"; - } enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_MAIN_CHARACTER_TYPE = 4, VT_MAIN_CHARACTER = 6, From 2e30e10a8dd387afcbcbba8cc3977ab199f8831b Mon Sep 17 00:00:00 2001 From: Didier Villevalois Date: Sat, 6 Feb 2021 15:13:58 +0100 Subject: [PATCH 3/3] [TS/JS] Add support for creating vectors from typed arrays This commit add support for creating vectors directly from in-memory JavaScript typed arrays (Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array and Float64Array). There was already support for reading directly to typed arrays. This brings the counterpart for writing. This commit also removes the invalid Uint8Array overloads. These overloads were invalid as they enabled a TypeScript user to pass a Uint8Array to the generated methods which were in turn iterating on the array content as if they were normal numbers. Summary of changes: * add support for typed array factory methods in builder.ts * add corresponding support in idl_gen_ts.cpp * remove invalid Uint8Array overloads in idl_gen_ts.cpp --- src/idl_gen_ts.cpp | 50 ++--- tests/ts/movie.ts | 4 +- tests/ts/my-game/example/monster.ts | 65 ++----- tests/ts/my-game/example/type-aliases.ts | 26 +-- ts/builder.ts | 237 ++++++++++++++++++++++- ts/byte-buffer.ts | 8 +- 6 files changed, 293 insertions(+), 97 deletions(-) diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp index f8829e48c2c..818bbfa83e0 100644 --- a/src/idl_gen_ts.cpp +++ b/src/idl_gen_ts.cpp @@ -189,6 +189,20 @@ class TsGenerator : public BaseGenerator { } } + static bool HasTypedCreateVector(const Type &type) { + switch (type.base_type) { + case BASE_TYPE_CHAR: + case BASE_TYPE_UCHAR: + case BASE_TYPE_SHORT: + case BASE_TYPE_USHORT: + case BASE_TYPE_INT: + case BASE_TYPE_UINT: + case BASE_TYPE_FLOAT: + case BASE_TYPE_DOUBLE: return true; + default: return false; + } + } + std::string GenGetter(const Type &type, const std::string &arguments) { switch (type.base_type) { case BASE_TYPE_STRING: return GenBBAccess() + ".__string" + arguments; @@ -1439,30 +1453,22 @@ class TsGenerator : public BaseGenerator { GenTypeName(imports, struct_def, vector_type, true) + "[]"; if (type == "number[]") { const auto &array_type = GenType(vector_type); - // the old type should be deprecated in the future - std::string type_old = "number[]|Uint8Array"; - std::string type_new = "number[]|" + array_type + "Array"; - if (type_old == type_new) { - type = type_new; - } else { - // add function overloads - code += sig_begin + type_new + sig_end + ";\n"; - code += - "/**\n * @deprecated This Uint8Array overload will " - "be removed in the future.\n */\n"; - code += sig_begin + type_old + sig_end + ";\n"; - type = type_new + "|Uint8Array"; - } + type = "number[]|" + array_type + "Array"; } code += sig_begin + type + sig_end + " {\n"; - code += " builder.startVector(" + NumToString(elem_size); - code += ", data.length, " + NumToString(alignment) + ");\n"; - code += " for (let i = data.length - 1; i >= 0; i--) {\n"; - code += " builder.add" + GenWriteMethod(vector_type) + "("; - if (vector_type.base_type == BASE_TYPE_BOOL) { code += "+"; } - code += "data[i]);\n"; - code += " }\n"; - code += " return builder.endVector();\n"; + if (HasTypedCreateVector(vector_type)) { + const auto &array_type = GenType(vector_type); + code += " return builder.create" + array_type + "Vector(data);\n"; + } else { + code += " builder.startVector(" + NumToString(elem_size); + code += ", data.length, " + NumToString(alignment) + ");\n"; + code += " for (var i = data.length - 1; i >= 0; i--) {\n"; + code += " builder.add" + GenWriteMethod(vector_type) + "("; + if (vector_type.base_type == BASE_TYPE_BOOL) { code += "+"; } + code += "data[i]);\n"; + code += " }\n"; + code += " return builder.endVector();\n"; + } code += "}\n\n"; } diff --git a/tests/ts/movie.ts b/tests/ts/movie.ts index a07b6eaa0f2..535b1d2bcda 100644 --- a/tests/ts/movie.ts +++ b/tests/ts/movie.ts @@ -87,7 +87,7 @@ static addCharactersType(builder:flatbuffers.Builder, charactersTypeOffset:flatb static createCharactersTypeVector(builder:flatbuffers.Builder, data:Character[]):flatbuffers.Offset { builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addInt8(data[i]); } return builder.endVector(); @@ -103,7 +103,7 @@ static addCharacters(builder:flatbuffers.Builder, charactersOffset:flatbuffers.O static createCharactersVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addOffset(data[i]); } return builder.endVector(); diff --git a/tests/ts/my-game/example/monster.ts b/tests/ts/my-game/example/monster.ts index b334782e2fd..d34a1a2fb48 100644 --- a/tests/ts/my-game/example/monster.ts +++ b/tests/ts/my-game/example/monster.ts @@ -675,11 +675,7 @@ static addInventory(builder:flatbuffers.Builder, inventoryOffset:flatbuffers.Off } static createInventoryVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { - builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); + return builder.createUint8Vector(data); } static startInventoryVector(builder:flatbuffers.Builder, numElems:number) { @@ -712,7 +708,7 @@ static addTestarrayofstring(builder:flatbuffers.Builder, testarrayofstringOffset static createTestarrayofstringVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addOffset(data[i]); } return builder.endVector(); @@ -728,7 +724,7 @@ static addTestarrayoftables(builder:flatbuffers.Builder, testarrayoftablesOffset static createTestarrayoftablesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addOffset(data[i]); } return builder.endVector(); @@ -747,11 +743,7 @@ static addTestnestedflatbuffer(builder:flatbuffers.Builder, testnestedflatbuffer } static createTestnestedflatbufferVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { - builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); + return builder.createUint8Vector(data); } static startTestnestedflatbufferVector(builder:flatbuffers.Builder, numElems:number) { @@ -804,7 +796,7 @@ static addTestarrayofbools(builder:flatbuffers.Builder, testarrayofboolsOffset:f static createTestarrayofboolsVector(builder:flatbuffers.Builder, data:boolean[]):flatbuffers.Offset { builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addInt8(+data[i]); } return builder.endVector(); @@ -832,7 +824,7 @@ static addTestarrayofstring2(builder:flatbuffers.Builder, testarrayofstring2Offs static createTestarrayofstring2Vector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addOffset(data[i]); } return builder.endVector(); @@ -855,11 +847,7 @@ static addFlex(builder:flatbuffers.Builder, flexOffset:flatbuffers.Offset) { } static createFlexVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { - builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); + return builder.createUint8Vector(data); } static startFlexVector(builder:flatbuffers.Builder, numElems:number) { @@ -880,7 +868,7 @@ static addVectorOfLongs(builder:flatbuffers.Builder, vectorOfLongsOffset:flatbuf static createVectorOfLongsVector(builder:flatbuffers.Builder, data:flatbuffers.Long[]):flatbuffers.Offset { builder.startVector(8, data.length, 8); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addInt64(data[i]); } return builder.endVector(); @@ -894,17 +882,8 @@ static addVectorOfDoubles(builder:flatbuffers.Builder, vectorOfDoublesOffset:fla builder.addFieldOffset(33, vectorOfDoublesOffset, 0); } -static createVectorOfDoublesVector(builder:flatbuffers.Builder, data:number[]|Float64Array):flatbuffers.Offset; -/** - * @deprecated This Uint8Array overload will be removed in the future. - */ -static createVectorOfDoublesVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset; -static createVectorOfDoublesVector(builder:flatbuffers.Builder, data:number[]|Float64Array|Uint8Array):flatbuffers.Offset { - builder.startVector(8, data.length, 8); - for (let i = data.length - 1; i >= 0; i--) { - builder.addFloat64(data[i]); - } - return builder.endVector(); +static createVectorOfDoublesVector(builder:flatbuffers.Builder, data:number[]|Float64Array):flatbuffers.Offset { + return builder.createFloat64Vector(data); } static startVectorOfDoublesVector(builder:flatbuffers.Builder, numElems:number) { @@ -921,7 +900,7 @@ static addVectorOfReferrables(builder:flatbuffers.Builder, vectorOfReferrablesOf static createVectorOfReferrablesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addOffset(data[i]); } return builder.endVector(); @@ -941,7 +920,7 @@ static addVectorOfWeakReferences(builder:flatbuffers.Builder, vectorOfWeakRefere static createVectorOfWeakReferencesVector(builder:flatbuffers.Builder, data:flatbuffers.Long[]):flatbuffers.Offset { builder.startVector(8, data.length, 8); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addInt64(data[i]); } return builder.endVector(); @@ -957,7 +936,7 @@ static addVectorOfStrongReferrables(builder:flatbuffers.Builder, vectorOfStrongR static createVectorOfStrongReferrablesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addOffset(data[i]); } return builder.endVector(); @@ -977,7 +956,7 @@ static addVectorOfCoOwningReferences(builder:flatbuffers.Builder, vectorOfCoOwni static createVectorOfCoOwningReferencesVector(builder:flatbuffers.Builder, data:flatbuffers.Long[]):flatbuffers.Offset { builder.startVector(8, data.length, 8); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addInt64(data[i]); } return builder.endVector(); @@ -997,7 +976,7 @@ static addVectorOfNonOwningReferences(builder:flatbuffers.Builder, vectorOfNonOw static createVectorOfNonOwningReferencesVector(builder:flatbuffers.Builder, data:flatbuffers.Long[]):flatbuffers.Offset { builder.startVector(8, data.length, 8); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addInt64(data[i]); } return builder.endVector(); @@ -1028,11 +1007,7 @@ static addVectorOfEnums(builder:flatbuffers.Builder, vectorOfEnumsOffset:flatbuf } static createVectorOfEnumsVector(builder:flatbuffers.Builder, data:Color[]):flatbuffers.Offset { - builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); + return builder.createUint8Vector(data); } static startVectorOfEnumsVector(builder:flatbuffers.Builder, numElems:number) { @@ -1048,11 +1023,7 @@ static addTestrequirednestedflatbuffer(builder:flatbuffers.Builder, testrequired } static createTestrequirednestedflatbufferVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { - builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); + return builder.createUint8Vector(data); } static startTestrequirednestedflatbufferVector(builder:flatbuffers.Builder, numElems:number) { @@ -1065,7 +1036,7 @@ static addScalarKeySortedTables(builder:flatbuffers.Builder, scalarKeySortedTabl static createScalarKeySortedTablesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { + for (var i = data.length - 1; i >= 0; i--) { builder.addOffset(data[i]); } return builder.endVector(); diff --git a/tests/ts/my-game/example/type-aliases.ts b/tests/ts/my-game/example/type-aliases.ts index 9409eafc977..771c67579be 100644 --- a/tests/ts/my-game/example/type-aliases.ts +++ b/tests/ts/my-game/example/type-aliases.ts @@ -264,17 +264,8 @@ static addV8(builder:flatbuffers.Builder, v8Offset:flatbuffers.Offset) { builder.addFieldOffset(10, v8Offset, 0); } -static createV8Vector(builder:flatbuffers.Builder, data:number[]|Int8Array):flatbuffers.Offset; -/** - * @deprecated This Uint8Array overload will be removed in the future. - */ -static createV8Vector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset; -static createV8Vector(builder:flatbuffers.Builder, data:number[]|Int8Array|Uint8Array):flatbuffers.Offset { - builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); +static createV8Vector(builder:flatbuffers.Builder, data:number[]|Int8Array):flatbuffers.Offset { + return builder.createInt8Vector(data); } static startV8Vector(builder:flatbuffers.Builder, numElems:number) { @@ -285,17 +276,8 @@ static addVf64(builder:flatbuffers.Builder, vf64Offset:flatbuffers.Offset) { builder.addFieldOffset(11, vf64Offset, 0); } -static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Float64Array):flatbuffers.Offset; -/** - * @deprecated This Uint8Array overload will be removed in the future. - */ -static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset; -static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Float64Array|Uint8Array):flatbuffers.Offset { - builder.startVector(8, data.length, 8); - for (let i = data.length - 1; i >= 0; i--) { - builder.addFloat64(data[i]); - } - return builder.endVector(); +static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Float64Array):flatbuffers.Offset { + return builder.createFloat64Vector(data); } static startVf64Vector(builder:flatbuffers.Builder, numElems:number) { diff --git a/ts/builder.ts b/ts/builder.ts index 7aad15e235d..49e1e3c0c92 100644 --- a/ts/builder.ts +++ b/ts/builder.ts @@ -1,6 +1,7 @@ import { ByteBuffer } from "./byte-buffer" import { SIZEOF_SHORT, SIZE_PREFIX_LENGTH, SIZEOF_INT, FILE_IDENTIFIER_LENGTH } from "./constants" import { Offset, IGeneratedObject } from "./types" +import { isLittleEndian } from './utils'; import { Long } from "./long" export class Builder { @@ -127,14 +128,26 @@ export class Builder { writeInt8(value: number): void { this.bb.writeInt8(this.space -= 1, value); } + + writeUint8(value: number): void { + this.bb.writeUint8(this.space -= 1, value); + } writeInt16(value: number): void { this.bb.writeInt16(this.space -= 2, value); } + + writeUint16(value: number): void { + this.bb.writeUint16(this.space -= 2, value); + } writeInt32(value: number): void { this.bb.writeInt32(this.space -= 4, value); } + + writeUint32(value: number): void { + this.bb.writeUint32(this.space -= 4, value); + } writeInt64(value: Long): void { this.bb.writeInt64(this.space -= 8, value); @@ -156,7 +169,16 @@ export class Builder { this.prep(1, 0); this.writeInt8(value); } - + + /** + * Add an `uint8` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param value The `uint8` to add the the buffer. + */ + addUint8(value: number): void { + this.prep(1, 0); + this.writeUint8(value); + } + /** * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary). * @param value The `int16` to add the the buffer. @@ -165,6 +187,15 @@ export class Builder { this.prep(2, 0); this.writeInt16(value); } + + /** + * Add an `uint16` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param value The `uint16` to add the the buffer. + */ + addUint16(value: number): void { + this.prep(2, 0); + this.writeUint16(value); + } /** * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary). @@ -174,6 +205,15 @@ export class Builder { this.prep(4, 0); this.writeInt32(value); } + + /** + * Add an `uint32` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param value The `uint32` to add the the buffer. + */ + addUint32(value: number): void { + this.prep(4, 0); + this.writeUint32(value); + } /** * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary). @@ -493,7 +533,200 @@ export class Builder { this.writeInt32(this.vector_num_elems); return this.offset(); } - + + /** + * Creates a new array/vector of `int8`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createInt8Vector(elements: number[] | Int8Array): Offset { + this.startVector(1, elements.length, 1); + + if (elements instanceof Int8Array) { + const byteLength = elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + this.addInt8(elements[i]); + } + } + + return this.endVector(); + } + + /** + * Creates a new array/vector of `uint8`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createUint8Vector(elements: number[] | Uint8Array): Offset { + this.startVector(1, elements.length, 1); + + if (elements instanceof Uint8Array) { + const byteLength = elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + this.addUint8(elements[i]); + } + } + + return this.endVector(); + } + + /** + * Creates a new array/vector of `int16`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createInt16Vector(elements: number[] | Int16Array): Offset { + this.startVector(2, elements.length, 4); + + if (elements instanceof Int16Array && isLittleEndian) { + const byteLength = 2 * elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + this.addInt16(elements[i]); + } + } + + return this.endVector(); + } + + /** + * Creates a new array/vector of `uint16`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createUint16Vector(elements: number[] | Uint16Array): Offset { + this.startVector(2, elements.length, 4); + + if (elements instanceof Uint16Array && isLittleEndian) { + const byteLength = 2 * elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + this.addUint16(elements[i]); + } + } + + return this.endVector(); + } + + /** + * Creates a new array/vector of `int32`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createInt32Vector(elements: number[] | Int32Array): Offset { + this.startVector(4, elements.length, 4); + + if (elements instanceof Int32Array && isLittleEndian) { + const byteLength = 4 * elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + this.addInt32(elements[i]); + } + } + + return this.endVector(); + } + + /** + * Creates a new array/vector of `uint32`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createUint32Vector(elements: number[] | Uint32Array): Offset { + this.startVector(4, elements.length, 4); + + if (elements instanceof Uint32Array && isLittleEndian) { + const byteLength = 4 * elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + this.addUint32(elements[i]); + } + } + + return this.endVector(); + } + + /** + * Creates a new array/vector of `float32`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createFloat32Vector(elements: number[] | Float32Array): Offset { + this.startVector(4, elements.length, 4); + + if (elements instanceof Float32Array && isLittleEndian) { + const byteLength = 4 * elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + console.log(elements[i]); + this.addFloat32(elements[i]); + } + } + + return this.endVector(); + } + + /** + * Creates a new array/vector of `float64`. Users usually will not call + * this directly. The FlatBuffers compiler will create a create + * method for vector types in generated code. + * + * @param elements The array of elements + * @returns The offset at which the newly created array starts. + */ + createFloat64Vector(elements: number[] | Float64Array): Offset { + this.startVector(8, elements.length, 8); + + if (elements instanceof Float64Array && isLittleEndian) { + const byteLength = 8 * elements.length; + this.bb.setPosition(this.space -= byteLength); + this.bb.writeBytes(this.space, elements.buffer, byteLength); + } else { + for (let i = elements.length - 1; i >= 0; i--) { + this.addFloat64(elements[i]); + } + } + + return this.endVector(); + } + /** * Encode the string `s` in the buffer using UTF-8. If the string passed has * already been seen, we return the offset of the already written string diff --git a/ts/byte-buffer.ts b/ts/byte-buffer.ts index f802548a9f3..b4cfa6358f9 100644 --- a/ts/byte-buffer.ts +++ b/ts/byte-buffer.ts @@ -146,7 +146,11 @@ export class ByteBuffer { this.writeInt32(offset, int32[isLittleEndian ? 0 : 1]); this.writeInt32(offset + 4, int32[isLittleEndian ? 1 : 0]); } - + + writeBytes(offset: number, bytes: ArrayBuffer, length: number) { + this.bytes_.set(new Uint8Array(bytes, 0, length), offset) + } + /** * Return the file identifier. Behavior is undefined for FlatBuffers whose * schema does not include a file_identifier (likely points at padding or the @@ -341,4 +345,4 @@ export class ByteBuffer { return ret; } - } \ No newline at end of file + }