diff --git a/.gitignore b/.gitignore index e02f85499..d50343708 100644 --- a/.gitignore +++ b/.gitignore @@ -136,4 +136,5 @@ mjs/**/*.js mjs/**/*.d.ts yarn-error.log .cache/ -.cmake/ \ No newline at end of file +/flatbuffers.lib +.cmake/ diff --git a/src/idl_gen_js_ts.cpp b/src/idl_gen_js_ts.cpp index cd3b92218..0240f5130 100644 --- a/src/idl_gen_js_ts.cpp +++ b/src/idl_gen_js_ts.cpp @@ -442,11 +442,16 @@ class JsTsGenerator : public BaseGenerator { } } - std::string GenBBAccess() { + std::string GenBBAccess() const { return lang_.language == IDLOptions::kTs ? "this.bb!" : "this.bb"; } - std::string GenDefaultValue(const Value &value, const std::string &context) { + std::string GenDefaultValue(const FieldDef &field, const std::string &context) { + if (field.IsScalarOptional()) { + return "null"; + } + + const auto &value = field.value; if (value.type.enum_def && value.type.base_type != BASE_TYPE_UNION && value.type.base_type != BASE_TYPE_VECTOR) { if (auto val = value.type.enum_def->FindByValue(value.constant)) { @@ -503,13 +508,17 @@ class JsTsGenerator : public BaseGenerator { } switch (type.base_type) { - case BASE_TYPE_BOOL: return "boolean"; + case BASE_TYPE_BOOL: return (allowNull) ? ("boolean|null") : ("boolean"); case BASE_TYPE_LONG: - case BASE_TYPE_ULONG: return "flatbuffers.Long"; + case BASE_TYPE_ULONG: return (allowNull) ? ("flatbuffers.Long|null") : ("flatbuffers.Long"); default: if (IsScalar(type.base_type)) { - if (type.enum_def) { return WrapInNameSpace(*type.enum_def); } - return "number"; + if (type.enum_def) { + const auto enum_name = WrapInNameSpace(*type.enum_def); + return (allowNull) ? (enum_name + "|null") : (enum_name); + } + + return (allowNull) ? ("number|null") : ("number"); } return "flatbuffers.Offset"; } @@ -576,10 +585,6 @@ class JsTsGenerator : public BaseGenerator { return GenFileNamespacePrefix(file) + "." + typeName; } - std::string GenFullNameSpace(const Definition &def, const std::string &file) { - return GenPrefixedTypeName(GetNameSpace(def), file); - } - void GenStructArgs(const StructDef &struct_def, std::string *annotations, std::string *arguments, const std::string &nameprefix) { for (auto it = struct_def.fields.vec.begin(); @@ -593,11 +598,11 @@ class JsTsGenerator : public BaseGenerator { nameprefix + field.name + "_"); } else { *annotations += - GenTypeAnnotation(kParam, GenTypeName(field.value.type, true), + GenTypeAnnotation(kParam, GenTypeName(field.value.type, true, field.optional), nameprefix + field.name); if (lang_.language == IDLOptions::kTs) { *arguments += ", " + nameprefix + field.name + ": " + - GenTypeName(field.value.type, true); + GenTypeName(field.value.type, true, field.optional); } else { *arguments += ", " + nameprefix + field.name; } @@ -879,7 +884,7 @@ class JsTsGenerator : public BaseGenerator { const auto union_has_string = UnionHasStringType(enum_def); const auto field_binded_method = "this." + field_name + ".bind(this)"; - std::string ret = ""; + std::string ret; if (!is_array) { const auto conversion_function = @@ -935,7 +940,7 @@ class JsTsGenerator : public BaseGenerator { return ""; } - std::string GenNullCheckConditional(const std::string &nullCheckVar, + static std::string GenNullCheckConditional(const std::string &nullCheckVar, const std::string &trueVal, const std::string &falseVal = "null") { return "(" + nullCheckVar + " !== null ? " + trueVal + " : " + falseVal + @@ -1039,21 +1044,23 @@ class JsTsGenerator : public BaseGenerator { // the variable name from field_offset_decl std::string field_offset_val; const auto field_default_val = - GenDefaultValue(field.value, "flatbuffers"); + GenDefaultValue(field, "flatbuffers"); // Emit a scalar field - if (IsScalar(field.value.type.base_type) || - IsString(field.value.type)) { + const auto is_string = IsString(field.value.type); + if (IsScalar(field.value.type.base_type) || is_string) { + const auto has_null_default = is_string || HasNullDefault(field); + if (field.value.type.enum_def) { if (!parser_.opts.generate_all) { imported_files.insert(field.value.type.enum_def->file); } field_type += - GenPrefixedTypeName(GenTypeName(field.value.type, false, true), + GenPrefixedTypeName(GenTypeName(field.value.type, false, has_null_default), field.value.type.enum_def->file); } else { - field_type += GenTypeName(field.value.type, false, true); + field_type += GenTypeName(field.value.type, false, has_null_default); } field_val = "this." + field_name + "()"; @@ -1162,7 +1169,7 @@ class JsTsGenerator : public BaseGenerator { } field_type += - GenPrefixedTypeName(GenTypeName(vectortype, false, true), + GenPrefixedTypeName(GenTypeName(vectortype, false, HasNullDefault(field)), vectortype.enum_def->file); } else { field_type += vectortypename; @@ -1281,7 +1288,7 @@ class JsTsGenerator : public BaseGenerator { obj_api_unpack_func = unpack_func + "\n\n" + unpack_to_func; } - bool CanCreateFactoryMethod(const StructDef &struct_def) { + static bool CanCreateFactoryMethod(const StructDef &struct_def) { // to preserve backwards compatibility, we allow the first field to be a // struct return struct_def.fields.vec.size() < 2 || @@ -1411,20 +1418,22 @@ class JsTsGenerator : public BaseGenerator { NumToString(field.value.offset) + ");\n return offset ? "; // Emit a scalar field - if (IsScalar(field.value.type.base_type) || - IsString(field.value.type)) { + const auto is_string = IsString(field.value.type); + if (IsScalar(field.value.type.base_type) || is_string) { + const auto has_null_default = is_string || HasNullDefault(field); + GenDocComment( field.doc_comment, code_ptr, - std::string(IsString(field.value.type) + std::string(is_string ? GenTypeAnnotation(kParam, "flatbuffers.Encoding=", "optionalEncoding") : "") + GenTypeAnnotation(kReturns, - GenTypeName(field.value.type, false, true), + GenTypeName(field.value.type, false, has_null_default), "", false)); if (lang_.language == IDLOptions::kTs) { std::string prefix = MakeCamel(field.name, false) + "("; - if (IsString(field.value.type)) { + if (is_string) { code += prefix + "):string|null\n"; code += prefix + "optionalEncoding:flatbuffers.Encoding" + "):" + GenTypeName(field.value.type, false, true) + "\n"; @@ -1435,7 +1444,7 @@ class JsTsGenerator : public BaseGenerator { if (field.value.type.enum_def) { code += "):" + - GenPrefixedTypeName(GenTypeName(field.value.type, false, true), + GenPrefixedTypeName(GenTypeName(field.value.type, false, field.optional), field.value.type.enum_def->file) + " {\n"; @@ -1443,12 +1452,12 @@ class JsTsGenerator : public BaseGenerator { imported_files.insert(field.value.type.enum_def->file); } } else { - code += "):" + GenTypeName(field.value.type, false, true) + " {\n"; + code += "):" + GenTypeName(field.value.type, false, has_null_default) + " {\n"; } } else { code += object_name + ".prototype." + MakeCamel(field.name, false); code += " = function("; - if (IsString(field.value.type)) { + if (is_string) { code += "optionalEncoding"; } code += ") {\n"; @@ -1462,12 +1471,12 @@ class JsTsGenerator : public BaseGenerator { ";\n"; } else { std::string index = "this.bb_pos + offset"; - if (IsString(field.value.type)) { + if (is_string) { index += ", optionalEncoding"; } code += offset_prefix + GenGetter(field.value.type, "(" + index + ")") + " : " + - GenDefaultValue(field.value, GenBBAccess()); + GenDefaultValue(field, GenBBAccess()); code += ";\n"; } } @@ -1865,7 +1874,7 @@ class JsTsGenerator : public BaseGenerator { if (lang_.language == IDLOptions::kTs) { code += "static add" + MakeCamel(field.name); code += "(builder:flatbuffers.Builder, " + argname + ":" + - GetArgType(field) + ") {\n"; + GetArgType(field, false) + ") {\n"; } else { code += object_name + ".add" + MakeCamel(field.name); code += " = function(builder, " + argname + ") {\n"; @@ -1877,9 +1886,15 @@ class JsTsGenerator : public BaseGenerator { code += argname + ", "; if (!IsScalar(field.value.type.base_type)) { code += "0"; + } else if (HasNullDefault(field)) { + if (IsLong(field.value.type.base_type)) { + code += "builder.createLong(0, 0)"; + } else { + code += "0"; + } } else { if (field.value.type.base_type == BASE_TYPE_BOOL) { code += "+"; } - code += GenDefaultValue(field.value, "builder"); + code += GenDefaultValue(field, "builder"); } code += ");\n};\n\n"; @@ -2010,7 +2025,7 @@ class JsTsGenerator : public BaseGenerator { const auto &field = **it; if (field.deprecated) continue; paramDoc += - GenTypeAnnotation(kParam, GetArgType(field), GetArgName(field)); + GenTypeAnnotation(kParam, GetArgType(field, true), GetArgName(field)); } paramDoc += GenTypeAnnotation(kReturns, "flatbuffers.Offset", "", false); @@ -2031,7 +2046,7 @@ class JsTsGenerator : public BaseGenerator { if (field.deprecated) continue; if (lang_.language == IDLOptions::kTs) { - code += ", " + GetArgName(field) + ":" + GetArgType(field); + code += ", " + GetArgName(field) + ":" + GetArgType(field, true); } else { code += ", " + GetArgName(field); } @@ -2054,8 +2069,14 @@ class JsTsGenerator : public BaseGenerator { const auto &field = **it; if (field.deprecated) continue; + const auto arg_name = GetArgName(field); + + if (field.IsScalarOptional()) { + code += " if (" + arg_name + " !== null)\n "; + } + code += " " + methodPrefix + ".add" + MakeCamel(field.name) + "("; - code += "builder, " + GetArgName(field) + ");\n"; + code += "builder, " + arg_name + ");\n"; } code += " return " + methodPrefix + ".end" + Verbose(struct_def) + @@ -2094,9 +2115,13 @@ class JsTsGenerator : public BaseGenerator { if (!object_namespace.empty()) { code += "}\n"; } } } + + static bool HasNullDefault(const FieldDef &field) { + return field.optional && field.value.constant == "null"; + } - std::string GetArgType(const FieldDef &field) { - auto type_name = GenTypeName(field.value.type, true); + std::string GetArgType(const FieldDef &field, bool allowNull) { + auto type_name = GenTypeName(field.value.type, true, allowNull && field.optional); if (field.value.type.enum_def) { if (IsScalar(field.value.type.base_type)) { diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index 37d61a78a..9eebac9d6 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -2282,7 +2282,8 @@ CheckedError Parser::CheckClash(std::vector &fields, bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions &opts) { static FLATBUFFERS_CONSTEXPR unsigned long supported_langs = IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster | - IDLOptions::kKotlin | IDLOptions::kCpp | IDLOptions::kJava; + IDLOptions::kKotlin | IDLOptions::kCpp | IDLOptions::kJava | + IDLOptions::kTs | IDLOptions::kJs; unsigned long langs = opts.lang_to_generate; return (langs > 0 && langs < IDLOptions::kMAX) && !(langs & ~supported_langs); } diff --git a/tests/generate_code.bat b/tests/generate_code.bat index 926961b5f..025f8b041 100644 --- a/tests/generate_code.bat +++ b/tests/generate_code.bat @@ -55,7 +55,7 @@ set TEST_NOINCL_FLAGS=%TEST_BASE_FLAGS% --no-includes --no-fb-import ..\%buildtype%\flatc.exe --cpp %TEST_BASE_FLAGS% --cpp-ptr-type flatbuffers::unique_ptr native_type_test.fbs || goto FAIL @rem Generate the optional scalar code for tests. -..\%buildtype%\flatc.exe --kotlin --rust --lobster optional_scalars.fbs || goto FAIL +..\%buildtype%\flatc.exe --kotlin --rust --lobster --ts --js optional_scalars.fbs || goto FAIL ..\%buildtype%\flatc.exe %TEST_NOINCL_FLAGS% %TEST_CPP_FLAGS% --cpp optional_scalars.fbs || goto FAIL @rem Generate the schema evolution tests diff --git a/tests/generate_code.sh b/tests/generate_code.sh index f9e06ec56..d52d78ce4 100755 --- a/tests/generate_code.sh +++ b/tests/generate_code.sh @@ -53,7 +53,7 @@ $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o namespace ../flatc --dart monster_extra.fbs # Generate optional scalar code for tests. -../flatc --java --kotlin --rust --lobster optional_scalars.fbs +../flatc --java --kotlin --rust --lobster --ts --js optional_scalars.fbs ../flatc $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS --cpp optional_scalars.fbs # Generate the schema evolution tests diff --git a/tests/optional_scalars_generated.js b/tests/optional_scalars_generated.js new file mode 100644 index 000000000..60a25a09a --- /dev/null +++ b/tests/optional_scalars_generated.js @@ -0,0 +1,782 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var optional_scalars = optional_scalars || {}; + +/** + * @enum {number} + */ +optional_scalars.OptionalByte = { + None: 0, + One: 1, + Two: 2 +}; + +/** + * @enum {string} + */ +optional_scalars.OptionalByteName = { + '0': 'None', + '1': 'One', + '2': 'Two' +}; + +/** + * @constructor + */ +optional_scalars.ScalarStuff = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {optional_scalars.ScalarStuff} + */ +optional_scalars.ScalarStuff.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {optional_scalars.ScalarStuff=} obj + * @returns {optional_scalars.ScalarStuff} + */ +optional_scalars.ScalarStuff.getRootAsScalarStuff = function(bb, obj) { + return (obj || new optional_scalars.ScalarStuff).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {optional_scalars.ScalarStuff=} obj + * @returns {optional_scalars.ScalarStuff} + */ +optional_scalars.ScalarStuff.getSizePrefixedRootAsScalarStuff = function(bb, obj) { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new optional_scalars.ScalarStuff).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @returns {boolean} + */ +optional_scalars.ScalarStuff.bufferHasIdentifier = function(bb) { + return bb.__has_identifier('NULL'); +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justI8 = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeI8 = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt8(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultI8 = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt8(this.bb_pos + offset) : 42; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justU8 = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeU8 = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint8(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultU8 = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 42; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justI16 = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeI16 = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readInt16(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultI16 = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 42; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justU16 = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeU16 = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint16(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultU16 = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 42; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justI32 = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeI32 = function() { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readInt32(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultI32 = function() { + var offset = this.bb.__offset(this.bb_pos, 32); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 42; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justU32 = function() { + var offset = this.bb.__offset(this.bb_pos, 34); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeU32 = function() { + var offset = this.bb.__offset(this.bb_pos, 36); + return offset ? this.bb.readUint32(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultU32 = function() { + var offset = this.bb.__offset(this.bb_pos, 38); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 42; +}; + +/** + * @returns {flatbuffers.Long} + */ +optional_scalars.ScalarStuff.prototype.justI64 = function() { + var offset = this.bb.__offset(this.bb_pos, 40); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @returns {flatbuffers.Long|null} + */ +optional_scalars.ScalarStuff.prototype.maybeI64 = function() { + var offset = this.bb.__offset(this.bb_pos, 42); + return offset ? this.bb.readInt64(this.bb_pos + offset) : null; +}; + +/** + * @returns {flatbuffers.Long} + */ +optional_scalars.ScalarStuff.prototype.defaultI64 = function() { + var offset = this.bb.__offset(this.bb_pos, 44); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(42, 0); +}; + +/** + * @returns {flatbuffers.Long} + */ +optional_scalars.ScalarStuff.prototype.justU64 = function() { + var offset = this.bb.__offset(this.bb_pos, 46); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @returns {flatbuffers.Long|null} + */ +optional_scalars.ScalarStuff.prototype.maybeU64 = function() { + var offset = this.bb.__offset(this.bb_pos, 48); + return offset ? this.bb.readUint64(this.bb_pos + offset) : null; +}; + +/** + * @returns {flatbuffers.Long} + */ +optional_scalars.ScalarStuff.prototype.defaultU64 = function() { + var offset = this.bb.__offset(this.bb_pos, 50); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(42, 0); +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justF32 = function() { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeF32 = function() { + var offset = this.bb.__offset(this.bb_pos, 54); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultF32 = function() { + var offset = this.bb.__offset(this.bb_pos, 56); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 42.0; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.justF64 = function() { + var offset = this.bb.__offset(this.bb_pos, 58); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns {number|null} + */ +optional_scalars.ScalarStuff.prototype.maybeF64 = function() { + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : null; +}; + +/** + * @returns {number} + */ +optional_scalars.ScalarStuff.prototype.defaultF64 = function() { + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 42.0; +}; + +/** + * @returns {boolean} + */ +optional_scalars.ScalarStuff.prototype.justBool = function() { + var offset = this.bb.__offset(this.bb_pos, 64); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; +}; + +/** + * @returns {boolean|null} + */ +optional_scalars.ScalarStuff.prototype.maybeBool = function() { + var offset = this.bb.__offset(this.bb_pos, 66); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : null; +}; + +/** + * @returns {boolean} + */ +optional_scalars.ScalarStuff.prototype.defaultBool = function() { + var offset = this.bb.__offset(this.bb_pos, 68); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : true; +}; + +/** + * @returns {optional_scalars.OptionalByte} + */ +optional_scalars.ScalarStuff.prototype.justEnum = function() { + var offset = this.bb.__offset(this.bb_pos, 70); + return offset ? /** @type {optional_scalars.OptionalByte} */ (this.bb.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.None; +}; + +/** + * @returns {optional_scalars.OptionalByte|null} + */ +optional_scalars.ScalarStuff.prototype.maybeEnum = function() { + var offset = this.bb.__offset(this.bb_pos, 72); + return offset ? /** @type {optional_scalars.OptionalByte} */ (this.bb.readInt8(this.bb_pos + offset)) : null; +}; + +/** + * @returns {optional_scalars.OptionalByte} + */ +optional_scalars.ScalarStuff.prototype.defaultEnum = function() { + var offset = this.bb.__offset(this.bb_pos, 74); + return offset ? /** @type {optional_scalars.OptionalByte} */ (this.bb.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.One; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +optional_scalars.ScalarStuff.startScalarStuff = function(builder) { + builder.startObject(36); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justI8 + */ +optional_scalars.ScalarStuff.addJustI8 = function(builder, justI8) { + builder.addFieldInt8(0, justI8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeI8 + */ +optional_scalars.ScalarStuff.addMaybeI8 = function(builder, maybeI8) { + builder.addFieldInt8(1, maybeI8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultI8 + */ +optional_scalars.ScalarStuff.addDefaultI8 = function(builder, defaultI8) { + builder.addFieldInt8(2, defaultI8, 42); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justU8 + */ +optional_scalars.ScalarStuff.addJustU8 = function(builder, justU8) { + builder.addFieldInt8(3, justU8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeU8 + */ +optional_scalars.ScalarStuff.addMaybeU8 = function(builder, maybeU8) { + builder.addFieldInt8(4, maybeU8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultU8 + */ +optional_scalars.ScalarStuff.addDefaultU8 = function(builder, defaultU8) { + builder.addFieldInt8(5, defaultU8, 42); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justI16 + */ +optional_scalars.ScalarStuff.addJustI16 = function(builder, justI16) { + builder.addFieldInt16(6, justI16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeI16 + */ +optional_scalars.ScalarStuff.addMaybeI16 = function(builder, maybeI16) { + builder.addFieldInt16(7, maybeI16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultI16 + */ +optional_scalars.ScalarStuff.addDefaultI16 = function(builder, defaultI16) { + builder.addFieldInt16(8, defaultI16, 42); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justU16 + */ +optional_scalars.ScalarStuff.addJustU16 = function(builder, justU16) { + builder.addFieldInt16(9, justU16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeU16 + */ +optional_scalars.ScalarStuff.addMaybeU16 = function(builder, maybeU16) { + builder.addFieldInt16(10, maybeU16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultU16 + */ +optional_scalars.ScalarStuff.addDefaultU16 = function(builder, defaultU16) { + builder.addFieldInt16(11, defaultU16, 42); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justI32 + */ +optional_scalars.ScalarStuff.addJustI32 = function(builder, justI32) { + builder.addFieldInt32(12, justI32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeI32 + */ +optional_scalars.ScalarStuff.addMaybeI32 = function(builder, maybeI32) { + builder.addFieldInt32(13, maybeI32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultI32 + */ +optional_scalars.ScalarStuff.addDefaultI32 = function(builder, defaultI32) { + builder.addFieldInt32(14, defaultI32, 42); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justU32 + */ +optional_scalars.ScalarStuff.addJustU32 = function(builder, justU32) { + builder.addFieldInt32(15, justU32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeU32 + */ +optional_scalars.ScalarStuff.addMaybeU32 = function(builder, maybeU32) { + builder.addFieldInt32(16, maybeU32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultU32 + */ +optional_scalars.ScalarStuff.addDefaultU32 = function(builder, defaultU32) { + builder.addFieldInt32(17, defaultU32, 42); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} justI64 + */ +optional_scalars.ScalarStuff.addJustI64 = function(builder, justI64) { + builder.addFieldInt64(18, justI64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} maybeI64 + */ +optional_scalars.ScalarStuff.addMaybeI64 = function(builder, maybeI64) { + builder.addFieldInt64(19, maybeI64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} defaultI64 + */ +optional_scalars.ScalarStuff.addDefaultI64 = function(builder, defaultI64) { + builder.addFieldInt64(20, defaultI64, builder.createLong(42, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} justU64 + */ +optional_scalars.ScalarStuff.addJustU64 = function(builder, justU64) { + builder.addFieldInt64(21, justU64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} maybeU64 + */ +optional_scalars.ScalarStuff.addMaybeU64 = function(builder, maybeU64) { + builder.addFieldInt64(22, maybeU64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} defaultU64 + */ +optional_scalars.ScalarStuff.addDefaultU64 = function(builder, defaultU64) { + builder.addFieldInt64(23, defaultU64, builder.createLong(42, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justF32 + */ +optional_scalars.ScalarStuff.addJustF32 = function(builder, justF32) { + builder.addFieldFloat32(24, justF32, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeF32 + */ +optional_scalars.ScalarStuff.addMaybeF32 = function(builder, maybeF32) { + builder.addFieldFloat32(25, maybeF32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultF32 + */ +optional_scalars.ScalarStuff.addDefaultF32 = function(builder, defaultF32) { + builder.addFieldFloat32(26, defaultF32, 42.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justF64 + */ +optional_scalars.ScalarStuff.addJustF64 = function(builder, justF64) { + builder.addFieldFloat64(27, justF64, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} maybeF64 + */ +optional_scalars.ScalarStuff.addMaybeF64 = function(builder, maybeF64) { + builder.addFieldFloat64(28, maybeF64, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} defaultF64 + */ +optional_scalars.ScalarStuff.addDefaultF64 = function(builder, defaultF64) { + builder.addFieldFloat64(29, defaultF64, 42.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} justBool + */ +optional_scalars.ScalarStuff.addJustBool = function(builder, justBool) { + builder.addFieldInt8(30, +justBool, +false); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} maybeBool + */ +optional_scalars.ScalarStuff.addMaybeBool = function(builder, maybeBool) { + builder.addFieldInt8(31, +maybeBool, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} defaultBool + */ +optional_scalars.ScalarStuff.addDefaultBool = function(builder, defaultBool) { + builder.addFieldInt8(32, +defaultBool, +true); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {optional_scalars.OptionalByte} justEnum + */ +optional_scalars.ScalarStuff.addJustEnum = function(builder, justEnum) { + builder.addFieldInt8(33, justEnum, optional_scalars.OptionalByte.None); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {optional_scalars.OptionalByte} maybeEnum + */ +optional_scalars.ScalarStuff.addMaybeEnum = function(builder, maybeEnum) { + builder.addFieldInt8(34, maybeEnum, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {optional_scalars.OptionalByte} defaultEnum + */ +optional_scalars.ScalarStuff.addDefaultEnum = function(builder, defaultEnum) { + builder.addFieldInt8(35, defaultEnum, optional_scalars.OptionalByte.One); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +optional_scalars.ScalarStuff.endScalarStuff = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +optional_scalars.ScalarStuff.finishScalarStuffBuffer = function(builder, offset) { + builder.finish(offset, 'NULL'); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +optional_scalars.ScalarStuff.finishSizePrefixedScalarStuffBuffer = function(builder, offset) { + builder.finish(offset, 'NULL', true); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} justI8 + * @param {number|null} maybeI8 + * @param {number} defaultI8 + * @param {number} justU8 + * @param {number|null} maybeU8 + * @param {number} defaultU8 + * @param {number} justI16 + * @param {number|null} maybeI16 + * @param {number} defaultI16 + * @param {number} justU16 + * @param {number|null} maybeU16 + * @param {number} defaultU16 + * @param {number} justI32 + * @param {number|null} maybeI32 + * @param {number} defaultI32 + * @param {number} justU32 + * @param {number|null} maybeU32 + * @param {number} defaultU32 + * @param {flatbuffers.Long} justI64 + * @param {flatbuffers.Long|null} maybeI64 + * @param {flatbuffers.Long} defaultI64 + * @param {flatbuffers.Long} justU64 + * @param {flatbuffers.Long|null} maybeU64 + * @param {flatbuffers.Long} defaultU64 + * @param {number} justF32 + * @param {number|null} maybeF32 + * @param {number} defaultF32 + * @param {number} justF64 + * @param {number|null} maybeF64 + * @param {number} defaultF64 + * @param {boolean} justBool + * @param {boolean|null} maybeBool + * @param {boolean} defaultBool + * @param {optional_scalars.OptionalByte} justEnum + * @param {optional_scalars.OptionalByte|null} maybeEnum + * @param {optional_scalars.OptionalByte} defaultEnum + * @returns {flatbuffers.Offset} + */ +optional_scalars.ScalarStuff.createScalarStuff = function(builder, justI8, maybeI8, defaultI8, justU8, maybeU8, defaultU8, justI16, maybeI16, defaultI16, justU16, maybeU16, defaultU16, justI32, maybeI32, defaultI32, justU32, maybeU32, defaultU32, justI64, maybeI64, defaultI64, justU64, maybeU64, defaultU64, justF32, maybeF32, defaultF32, justF64, maybeF64, defaultF64, justBool, maybeBool, defaultBool, justEnum, maybeEnum, defaultEnum) { + optional_scalars.ScalarStuff.startScalarStuff(builder); + optional_scalars.ScalarStuff.addJustI8(builder, justI8); + if (maybeI8 !== null) + optional_scalars.ScalarStuff.addMaybeI8(builder, maybeI8); + optional_scalars.ScalarStuff.addDefaultI8(builder, defaultI8); + optional_scalars.ScalarStuff.addJustU8(builder, justU8); + if (maybeU8 !== null) + optional_scalars.ScalarStuff.addMaybeU8(builder, maybeU8); + optional_scalars.ScalarStuff.addDefaultU8(builder, defaultU8); + optional_scalars.ScalarStuff.addJustI16(builder, justI16); + if (maybeI16 !== null) + optional_scalars.ScalarStuff.addMaybeI16(builder, maybeI16); + optional_scalars.ScalarStuff.addDefaultI16(builder, defaultI16); + optional_scalars.ScalarStuff.addJustU16(builder, justU16); + if (maybeU16 !== null) + optional_scalars.ScalarStuff.addMaybeU16(builder, maybeU16); + optional_scalars.ScalarStuff.addDefaultU16(builder, defaultU16); + optional_scalars.ScalarStuff.addJustI32(builder, justI32); + if (maybeI32 !== null) + optional_scalars.ScalarStuff.addMaybeI32(builder, maybeI32); + optional_scalars.ScalarStuff.addDefaultI32(builder, defaultI32); + optional_scalars.ScalarStuff.addJustU32(builder, justU32); + if (maybeU32 !== null) + optional_scalars.ScalarStuff.addMaybeU32(builder, maybeU32); + optional_scalars.ScalarStuff.addDefaultU32(builder, defaultU32); + optional_scalars.ScalarStuff.addJustI64(builder, justI64); + if (maybeI64 !== null) + optional_scalars.ScalarStuff.addMaybeI64(builder, maybeI64); + optional_scalars.ScalarStuff.addDefaultI64(builder, defaultI64); + optional_scalars.ScalarStuff.addJustU64(builder, justU64); + if (maybeU64 !== null) + optional_scalars.ScalarStuff.addMaybeU64(builder, maybeU64); + optional_scalars.ScalarStuff.addDefaultU64(builder, defaultU64); + optional_scalars.ScalarStuff.addJustF32(builder, justF32); + if (maybeF32 !== null) + optional_scalars.ScalarStuff.addMaybeF32(builder, maybeF32); + optional_scalars.ScalarStuff.addDefaultF32(builder, defaultF32); + optional_scalars.ScalarStuff.addJustF64(builder, justF64); + if (maybeF64 !== null) + optional_scalars.ScalarStuff.addMaybeF64(builder, maybeF64); + optional_scalars.ScalarStuff.addDefaultF64(builder, defaultF64); + optional_scalars.ScalarStuff.addJustBool(builder, justBool); + if (maybeBool !== null) + optional_scalars.ScalarStuff.addMaybeBool(builder, maybeBool); + optional_scalars.ScalarStuff.addDefaultBool(builder, defaultBool); + optional_scalars.ScalarStuff.addJustEnum(builder, justEnum); + if (maybeEnum !== null) + optional_scalars.ScalarStuff.addMaybeEnum(builder, maybeEnum); + optional_scalars.ScalarStuff.addDefaultEnum(builder, defaultEnum); + return optional_scalars.ScalarStuff.endScalarStuff(builder); +} + +// Exports for Node.js and RequireJS +this.optional_scalars = optional_scalars; diff --git a/tests/optional_scalars_generated.ts b/tests/optional_scalars_generated.ts new file mode 100644 index 000000000..668da8bb0 --- /dev/null +++ b/tests/optional_scalars_generated.ts @@ -0,0 +1,722 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; +/** + * @enum {number} + */ +export namespace optional_scalars{ +export enum OptionalByte{ + None= 0, + One= 1, + Two= 2 +}; +} + +/** + * @constructor + */ +export namespace optional_scalars{ +export class ScalarStuff { + bb: flatbuffers.ByteBuffer|null = null; + + bb_pos:number = 0; +/** + * @param number i + * @param flatbuffers.ByteBuffer bb + * @returns ScalarStuff + */ +__init(i:number, bb:flatbuffers.ByteBuffer):ScalarStuff { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param flatbuffers.ByteBuffer bb + * @param ScalarStuff= obj + * @returns ScalarStuff + */ +static getRootAsScalarStuff(bb:flatbuffers.ByteBuffer, obj?:ScalarStuff):ScalarStuff { + return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param flatbuffers.ByteBuffer bb + * @param ScalarStuff= obj + * @returns ScalarStuff + */ +static getSizePrefixedRootAsScalarStuff(bb:flatbuffers.ByteBuffer, obj?:ScalarStuff):ScalarStuff { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param flatbuffers.ByteBuffer bb + * @returns boolean + */ +static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean { + return bb.__has_identifier('NULL'); +}; + +/** + * @returns number + */ +justI8():number { + var offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : 0; +}; + +/** + * @returns number|null + */ +maybeI8():number|null { + var offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultI8():number { + var offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : 42; +}; + +/** + * @returns number + */ +justU8():number { + var offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns number|null + */ +maybeU8():number|null { + var offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultU8():number { + var offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : 42; +}; + +/** + * @returns number + */ +justI16():number { + var offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0; +}; + +/** + * @returns number|null + */ +maybeI16():number|null { + var offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? this.bb!.readInt16(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultI16():number { + var offset = this.bb!.__offset(this.bb_pos, 20); + return offset ? this.bb!.readInt16(this.bb_pos + offset) : 42; +}; + +/** + * @returns number + */ +justU16():number { + var offset = this.bb!.__offset(this.bb_pos, 22); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns number|null + */ +maybeU16():number|null { + var offset = this.bb!.__offset(this.bb_pos, 24); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultU16():number { + var offset = this.bb!.__offset(this.bb_pos, 26); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 42; +}; + +/** + * @returns number + */ +justI32():number { + var offset = this.bb!.__offset(this.bb_pos, 28); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @returns number|null + */ +maybeI32():number|null { + var offset = this.bb!.__offset(this.bb_pos, 30); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultI32():number { + var offset = this.bb!.__offset(this.bb_pos, 32); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 42; +}; + +/** + * @returns number + */ +justU32():number { + var offset = this.bb!.__offset(this.bb_pos, 34); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @returns number|null + */ +maybeU32():number|null { + var offset = this.bb!.__offset(this.bb_pos, 36); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultU32():number { + var offset = this.bb!.__offset(this.bb_pos, 38); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 42; +}; + +/** + * @returns flatbuffers.Long + */ +justI64():flatbuffers.Long { + var offset = this.bb!.__offset(this.bb_pos, 40); + return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0); +}; + +/** + * @returns flatbuffers.Long|null + */ +maybeI64():flatbuffers.Long|null { + var offset = this.bb!.__offset(this.bb_pos, 42); + return offset ? this.bb!.readInt64(this.bb_pos + offset) : null; +}; + +/** + * @returns flatbuffers.Long + */ +defaultI64():flatbuffers.Long { + var offset = this.bb!.__offset(this.bb_pos, 44); + return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(42, 0); +}; + +/** + * @returns flatbuffers.Long + */ +justU64():flatbuffers.Long { + var offset = this.bb!.__offset(this.bb_pos, 46); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(0, 0); +}; + +/** + * @returns flatbuffers.Long|null + */ +maybeU64():flatbuffers.Long|null { + var offset = this.bb!.__offset(this.bb_pos, 48); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : null; +}; + +/** + * @returns flatbuffers.Long + */ +defaultU64():flatbuffers.Long { + var offset = this.bb!.__offset(this.bb_pos, 50); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(42, 0); +}; + +/** + * @returns number + */ +justF32():number { + var offset = this.bb!.__offset(this.bb_pos, 52); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns number|null + */ +maybeF32():number|null { + var offset = this.bb!.__offset(this.bb_pos, 54); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultF32():number { + var offset = this.bb!.__offset(this.bb_pos, 56); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 42.0; +}; + +/** + * @returns number + */ +justF64():number { + var offset = this.bb!.__offset(this.bb_pos, 58); + return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns number|null + */ +maybeF64():number|null { + var offset = this.bb!.__offset(this.bb_pos, 60); + return offset ? this.bb!.readFloat64(this.bb_pos + offset) : null; +}; + +/** + * @returns number + */ +defaultF64():number { + var offset = this.bb!.__offset(this.bb_pos, 62); + return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 42.0; +}; + +/** + * @returns boolean + */ +justBool():boolean { + var offset = this.bb!.__offset(this.bb_pos, 64); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +}; + +/** + * @returns boolean|null + */ +maybeBool():boolean|null { + var offset = this.bb!.__offset(this.bb_pos, 66); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; +}; + +/** + * @returns boolean + */ +defaultBool():boolean { + var offset = this.bb!.__offset(this.bb_pos, 68); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : true; +}; + +/** + * @returns optional_scalars.OptionalByte + */ +justEnum():optional_scalars.OptionalByte { + var offset = this.bb!.__offset(this.bb_pos, 70); + return offset ? /** */ (this.bb!.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.None; +}; + +/** + * @returns optional_scalars.OptionalByte|null + */ +maybeEnum():optional_scalars.OptionalByte|null { + var offset = this.bb!.__offset(this.bb_pos, 72); + return offset ? /** */ (this.bb!.readInt8(this.bb_pos + offset)) : null; +}; + +/** + * @returns optional_scalars.OptionalByte + */ +defaultEnum():optional_scalars.OptionalByte { + var offset = this.bb!.__offset(this.bb_pos, 74); + return offset ? /** */ (this.bb!.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.One; +}; + +/** + * @param flatbuffers.Builder builder + */ +static startScalarStuff(builder:flatbuffers.Builder) { + builder.startObject(36); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justI8 + */ +static addJustI8(builder:flatbuffers.Builder, justI8:number) { + builder.addFieldInt8(0, justI8, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeI8 + */ +static addMaybeI8(builder:flatbuffers.Builder, maybeI8:number) { + builder.addFieldInt8(1, maybeI8, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultI8 + */ +static addDefaultI8(builder:flatbuffers.Builder, defaultI8:number) { + builder.addFieldInt8(2, defaultI8, 42); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justU8 + */ +static addJustU8(builder:flatbuffers.Builder, justU8:number) { + builder.addFieldInt8(3, justU8, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeU8 + */ +static addMaybeU8(builder:flatbuffers.Builder, maybeU8:number) { + builder.addFieldInt8(4, maybeU8, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultU8 + */ +static addDefaultU8(builder:flatbuffers.Builder, defaultU8:number) { + builder.addFieldInt8(5, defaultU8, 42); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justI16 + */ +static addJustI16(builder:flatbuffers.Builder, justI16:number) { + builder.addFieldInt16(6, justI16, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeI16 + */ +static addMaybeI16(builder:flatbuffers.Builder, maybeI16:number) { + builder.addFieldInt16(7, maybeI16, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultI16 + */ +static addDefaultI16(builder:flatbuffers.Builder, defaultI16:number) { + builder.addFieldInt16(8, defaultI16, 42); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justU16 + */ +static addJustU16(builder:flatbuffers.Builder, justU16:number) { + builder.addFieldInt16(9, justU16, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeU16 + */ +static addMaybeU16(builder:flatbuffers.Builder, maybeU16:number) { + builder.addFieldInt16(10, maybeU16, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultU16 + */ +static addDefaultU16(builder:flatbuffers.Builder, defaultU16:number) { + builder.addFieldInt16(11, defaultU16, 42); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justI32 + */ +static addJustI32(builder:flatbuffers.Builder, justI32:number) { + builder.addFieldInt32(12, justI32, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeI32 + */ +static addMaybeI32(builder:flatbuffers.Builder, maybeI32:number) { + builder.addFieldInt32(13, maybeI32, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultI32 + */ +static addDefaultI32(builder:flatbuffers.Builder, defaultI32:number) { + builder.addFieldInt32(14, defaultI32, 42); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justU32 + */ +static addJustU32(builder:flatbuffers.Builder, justU32:number) { + builder.addFieldInt32(15, justU32, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeU32 + */ +static addMaybeU32(builder:flatbuffers.Builder, maybeU32:number) { + builder.addFieldInt32(16, maybeU32, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultU32 + */ +static addDefaultU32(builder:flatbuffers.Builder, defaultU32:number) { + builder.addFieldInt32(17, defaultU32, 42); +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Long justI64 + */ +static addJustI64(builder:flatbuffers.Builder, justI64:flatbuffers.Long) { + builder.addFieldInt64(18, justI64, builder.createLong(0, 0)); +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Long maybeI64 + */ +static addMaybeI64(builder:flatbuffers.Builder, maybeI64:flatbuffers.Long) { + builder.addFieldInt64(19, maybeI64, builder.createLong(0, 0)); +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Long defaultI64 + */ +static addDefaultI64(builder:flatbuffers.Builder, defaultI64:flatbuffers.Long) { + builder.addFieldInt64(20, defaultI64, builder.createLong(42, 0)); +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Long justU64 + */ +static addJustU64(builder:flatbuffers.Builder, justU64:flatbuffers.Long) { + builder.addFieldInt64(21, justU64, builder.createLong(0, 0)); +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Long maybeU64 + */ +static addMaybeU64(builder:flatbuffers.Builder, maybeU64:flatbuffers.Long) { + builder.addFieldInt64(22, maybeU64, builder.createLong(0, 0)); +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Long defaultU64 + */ +static addDefaultU64(builder:flatbuffers.Builder, defaultU64:flatbuffers.Long) { + builder.addFieldInt64(23, defaultU64, builder.createLong(42, 0)); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justF32 + */ +static addJustF32(builder:flatbuffers.Builder, justF32:number) { + builder.addFieldFloat32(24, justF32, 0.0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeF32 + */ +static addMaybeF32(builder:flatbuffers.Builder, maybeF32:number) { + builder.addFieldFloat32(25, maybeF32, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultF32 + */ +static addDefaultF32(builder:flatbuffers.Builder, defaultF32:number) { + builder.addFieldFloat32(26, defaultF32, 42.0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number justF64 + */ +static addJustF64(builder:flatbuffers.Builder, justF64:number) { + builder.addFieldFloat64(27, justF64, 0.0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number maybeF64 + */ +static addMaybeF64(builder:flatbuffers.Builder, maybeF64:number) { + builder.addFieldFloat64(28, maybeF64, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param number defaultF64 + */ +static addDefaultF64(builder:flatbuffers.Builder, defaultF64:number) { + builder.addFieldFloat64(29, defaultF64, 42.0); +}; + +/** + * @param flatbuffers.Builder builder + * @param boolean justBool + */ +static addJustBool(builder:flatbuffers.Builder, justBool:boolean) { + builder.addFieldInt8(30, +justBool, +false); +}; + +/** + * @param flatbuffers.Builder builder + * @param boolean maybeBool + */ +static addMaybeBool(builder:flatbuffers.Builder, maybeBool:boolean) { + builder.addFieldInt8(31, +maybeBool, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param boolean defaultBool + */ +static addDefaultBool(builder:flatbuffers.Builder, defaultBool:boolean) { + builder.addFieldInt8(32, +defaultBool, +true); +}; + +/** + * @param flatbuffers.Builder builder + * @param optional_scalars.OptionalByte justEnum + */ +static addJustEnum(builder:flatbuffers.Builder, justEnum:optional_scalars.OptionalByte) { + builder.addFieldInt8(33, justEnum, optional_scalars.OptionalByte.None); +}; + +/** + * @param flatbuffers.Builder builder + * @param optional_scalars.OptionalByte maybeEnum + */ +static addMaybeEnum(builder:flatbuffers.Builder, maybeEnum:optional_scalars.OptionalByte) { + builder.addFieldInt8(34, maybeEnum, 0); +}; + +/** + * @param flatbuffers.Builder builder + * @param optional_scalars.OptionalByte defaultEnum + */ +static addDefaultEnum(builder:flatbuffers.Builder, defaultEnum:optional_scalars.OptionalByte) { + builder.addFieldInt8(35, defaultEnum, optional_scalars.OptionalByte.One); +}; + +/** + * @param flatbuffers.Builder builder + * @returns flatbuffers.Offset + */ +static endScalarStuff(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Offset offset + */ +static finishScalarStuffBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) { + builder.finish(offset, 'NULL'); +}; + +/** + * @param flatbuffers.Builder builder + * @param flatbuffers.Offset offset + */ +static finishSizePrefixedScalarStuffBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) { + builder.finish(offset, 'NULL', true); +}; + +static createScalarStuff(builder:flatbuffers.Builder, justI8:number, maybeI8:number|null, defaultI8:number, justU8:number, maybeU8:number|null, defaultU8:number, justI16:number, maybeI16:number|null, defaultI16:number, justU16:number, maybeU16:number|null, defaultU16:number, justI32:number, maybeI32:number|null, defaultI32:number, justU32:number, maybeU32:number|null, defaultU32:number, justI64:flatbuffers.Long, maybeI64:flatbuffers.Long|null, defaultI64:flatbuffers.Long, justU64:flatbuffers.Long, maybeU64:flatbuffers.Long|null, defaultU64:flatbuffers.Long, justF32:number, maybeF32:number|null, defaultF32:number, justF64:number, maybeF64:number|null, defaultF64:number, justBool:boolean, maybeBool:boolean|null, defaultBool:boolean, justEnum:optional_scalars.OptionalByte, maybeEnum:optional_scalars.OptionalByte|null, defaultEnum:optional_scalars.OptionalByte):flatbuffers.Offset { + ScalarStuff.startScalarStuff(builder); + ScalarStuff.addJustI8(builder, justI8); + if (maybeI8 !== null) + ScalarStuff.addMaybeI8(builder, maybeI8); + ScalarStuff.addDefaultI8(builder, defaultI8); + ScalarStuff.addJustU8(builder, justU8); + if (maybeU8 !== null) + ScalarStuff.addMaybeU8(builder, maybeU8); + ScalarStuff.addDefaultU8(builder, defaultU8); + ScalarStuff.addJustI16(builder, justI16); + if (maybeI16 !== null) + ScalarStuff.addMaybeI16(builder, maybeI16); + ScalarStuff.addDefaultI16(builder, defaultI16); + ScalarStuff.addJustU16(builder, justU16); + if (maybeU16 !== null) + ScalarStuff.addMaybeU16(builder, maybeU16); + ScalarStuff.addDefaultU16(builder, defaultU16); + ScalarStuff.addJustI32(builder, justI32); + if (maybeI32 !== null) + ScalarStuff.addMaybeI32(builder, maybeI32); + ScalarStuff.addDefaultI32(builder, defaultI32); + ScalarStuff.addJustU32(builder, justU32); + if (maybeU32 !== null) + ScalarStuff.addMaybeU32(builder, maybeU32); + ScalarStuff.addDefaultU32(builder, defaultU32); + ScalarStuff.addJustI64(builder, justI64); + if (maybeI64 !== null) + ScalarStuff.addMaybeI64(builder, maybeI64); + ScalarStuff.addDefaultI64(builder, defaultI64); + ScalarStuff.addJustU64(builder, justU64); + if (maybeU64 !== null) + ScalarStuff.addMaybeU64(builder, maybeU64); + ScalarStuff.addDefaultU64(builder, defaultU64); + ScalarStuff.addJustF32(builder, justF32); + if (maybeF32 !== null) + ScalarStuff.addMaybeF32(builder, maybeF32); + ScalarStuff.addDefaultF32(builder, defaultF32); + ScalarStuff.addJustF64(builder, justF64); + if (maybeF64 !== null) + ScalarStuff.addMaybeF64(builder, maybeF64); + ScalarStuff.addDefaultF64(builder, defaultF64); + ScalarStuff.addJustBool(builder, justBool); + if (maybeBool !== null) + ScalarStuff.addMaybeBool(builder, maybeBool); + ScalarStuff.addDefaultBool(builder, defaultBool); + ScalarStuff.addJustEnum(builder, justEnum); + if (maybeEnum !== null) + ScalarStuff.addMaybeEnum(builder, maybeEnum); + ScalarStuff.addDefaultEnum(builder, defaultEnum); + return ScalarStuff.endScalarStuff(builder); +} +} +}