diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp index 915b05e41fd..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"; } @@ -1489,7 +1495,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"; } 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/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/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, 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 + }