From 919d467c86038961d7858c5e163827c9b457715c Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Thu, 16 Mar 2017 14:07:08 +0100 Subject: [PATCH 01/17] Eclipse ignore --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 9dfabefadf1..135dc5c883b 100755 --- a/.gitignore +++ b/.gitignore @@ -66,3 +66,6 @@ build/VS2010/FlatBuffers.opensdf build/VS2010/ipch/**/*.ipch *.so Testing/Temporary +.cproject +.settings/ +.project From 9f07d31190fe2fe70274937eacb1ef0b85bab333 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Fri, 17 Mar 2017 10:17:51 +0100 Subject: [PATCH 02/17] TypeScript support --- CMakeLists.txt | 1 + include/flatbuffers/code_generators.h | 2 + include/flatbuffers/idl.h | 16 + src/code_generators.cpp | 14 + src/flatc.cpp | 3 + src/flatc_main.cpp | 5 + src/idl_gen_ts.cpp | 779 ++++++++++++++++++++++++++ 7 files changed, 820 insertions(+) create mode 100644 src/idl_gen_ts.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index affa05b79ec..242a1b672ba 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,6 +48,7 @@ set(FlatBuffers_Compiler_SRCS src/idl_gen_python.cpp src/idl_gen_fbs.cpp src/idl_gen_grpc.cpp + src/idl_gen_ts.cpp src/flatc.cpp src/flatc_main.cpp grpc/src/compiler/schema_interface.h diff --git a/include/flatbuffers/code_generators.h b/include/flatbuffers/code_generators.h index 16e368ea126..3e85df2a8bf 100644 --- a/include/flatbuffers/code_generators.h +++ b/include/flatbuffers/code_generators.h @@ -114,6 +114,8 @@ class BaseGenerator { std::string WrapInNameSpace(const Definition &def) const; + std::string GetNameSpace(const Definition &def) const; + const Parser &parser_; const std::string &path_; const std::string &file_name_; diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 5b7a72a3c09..dabfb4f418d 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -357,6 +357,7 @@ struct IDLOptions { bool allow_non_utf8; std::string include_prefix; bool binary_schema_comments; + bool skip_flatbuffers_import; // Possible options for the more general generator below. enum Language { @@ -369,6 +370,7 @@ struct IDLOptions { kPhp = 1 << 6, kJson = 1 << 7, kBinary = 1 << 8, + kTs = 1 << 9, kMAX }; @@ -398,6 +400,7 @@ struct IDLOptions { union_value_namespacing(true), allow_non_utf8(false), binary_schema_comments(false), + skip_flatbuffers_import(false), lang(IDLOptions::kJava), lang_to_generate(0) {} }; @@ -654,6 +657,13 @@ extern bool GenerateJS(const Parser &parser, const std::string &path, const std::string &file_name); +// Generate TypeScript code from the definitions in the Parser object. +// See idl_gen_ts. +extern std::string GenerateTS(const Parser &parser); +extern bool GenerateTS(const Parser &parser, + const std::string &path, + const std::string &file_name); + // Generate Go files from the definitions in the Parser object. // See idl_gen_go.cpp. extern bool GenerateGo(const Parser &parser, @@ -704,6 +714,12 @@ extern std::string JSMakeRule(const Parser &parser, const std::string &path, const std::string &file_name); +// Generate a make rule for the generated TypeScript code. +// See idl_gen_ts.cpp. +extern std::string TSMakeRule(const Parser &parser, + const std::string &path, + const std::string &file_name); + // Generate a make rule for the generated C++ header. // See idl_gen_cpp.cpp. extern std::string CPPMakeRule(const Parser &parser, diff --git a/src/code_generators.cpp b/src/code_generators.cpp index 92954699589..b9e73c625a9 100644 --- a/src/code_generators.cpp +++ b/src/code_generators.cpp @@ -135,6 +135,20 @@ std::string BaseGenerator::WrapInNameSpace(const Definition &def) const { return WrapInNameSpace(def.defined_namespace, def.name); } +std::string BaseGenerator::GetNameSpace(const Definition &def) const { + const Namespace *ns = def.defined_namespace; + if (CurrentNameSpace() == ns) return ""; + std::string qualified_name = qualifying_start_; + for (auto it = ns->components.begin(); it != ns->components.end(); ++it) { + qualified_name += *it; + if (std::next(it) != ns->components.end()) { + qualified_name += qualifying_separator_; + } + } + + return qualified_name; +} + // Generate a documentation comment, if available. void GenComment(const std::vector &dc, std::string *code_ptr, const CommentConfig *config, const char *prefix) { diff --git a/src/flatc.cpp b/src/flatc.cpp index 20207de13aa..d18e3472b9c 100644 --- a/src/flatc.cpp +++ b/src/flatc.cpp @@ -100,6 +100,7 @@ std::string FlatCompiler::GetUsageString(const char* program_name) const { " PATH \n" " --include-prefix Prefix this path to any generated include statements.\n" " PATH\n" + " --no-fb-import Don't include flatbuffers import statement for TypeScript.\n" "FILEs may be schemas, or JSON files (conforming to preceding schema)\n" "FILEs after the -- must be binary flatbuffer format files.\n" "Output files are named using the base file name of the input,\n" @@ -207,6 +208,8 @@ int FlatCompiler::Compile(int argc, const char** argv) { grpc_enabled = true; } else if(arg == "--bfbs-comments") { opts.binary_schema_comments = true; + } else if(arg == "--no-fb-import") { + opts.skip_flatbuffers_import = true; } else { for (size_t i = 0; i < params_.num_generators; ++i) { if (arg == params_.generators[i].generator_opt_long || diff --git a/src/flatc_main.cpp b/src/flatc_main.cpp index f4d9557bf00..deb368f51f5 100644 --- a/src/flatc_main.cpp +++ b/src/flatc_main.cpp @@ -76,6 +76,11 @@ int main(int argc, const char *argv[]) { flatbuffers::IDLOptions::kJs, "Generate JavaScript code for tables/structs", flatbuffers::JSMakeRule }, + { flatbuffers::GenerateTS, "-T", "--ts", "TypeScript", + nullptr, + flatbuffers::IDLOptions::kTs, + "Generate TypeScript code for tables/structs", + flatbuffers::TSMakeRule }, { flatbuffers::GenerateGeneral, "-n", "--csharp", "C#", nullptr, flatbuffers::IDLOptions::kCSharp, diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp new file mode 100644 index 00000000000..defd904e731 --- /dev/null +++ b/src/idl_gen_ts.cpp @@ -0,0 +1,779 @@ +/* + * Copyright 2014 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// independent from idl_parser, since this code is not needed for most clients + +#include + +#include "flatbuffers/flatbuffers.h" +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "flatbuffers/code_generators.h" + +namespace flatbuffers { + +static std::string GeneratedFileName(const std::string &path, + const std::string &file_name) { + return path + file_name + "_generated.ts"; +} + +namespace ts { +// Iterate through all definitions we haven't generate code for (enums, structs, +// and tables) and output them to a single file. +class TsGenerator : public BaseGenerator { + public: + // maps source to set of imported types + using ImportedFileSet = std::unordered_set; + + TsGenerator(const Parser &parser, const std::string &path, + const std::string &file_name) + : BaseGenerator(parser, path, file_name, "", "."){}; + // Iterate through all definitions we haven't generate code for (enums, + // structs, and tables) and output them to a single file. + bool generate() { + if (IsEverythingGenerated()) return true; + + ImportedFileSet importedFiles; + + std::string import_code, enum_code, struct_code, code; + generateEnums(&enum_code); + generateStructs(&struct_code, importedFiles); + generateImportDependencies(&import_code, importedFiles); + + code = code + "// " + FlatBuffersGeneratedWarning(); + + // Generate code for all the namespace declarations. + GenNamespaces(&code); + + // Output the main declaration code from above. + code += import_code; + code += enum_code; + code += struct_code; + + return SaveFile(GeneratedFileName(path_, file_name_).c_str(), code, false); + } + + private: + // Generate code for imports + void generateImportDependencies(std::string *code_ptr, const ImportedFileSet &importedFiles) { + std::string &code = *code_ptr; + for (const auto &file : importedFiles) { + const auto basename = + flatbuffers::StripPath(flatbuffers::StripExtension(file)); + if (basename != file_name_) { + code += "import * as "+ GenFileNamespacePrefix(file) + " from \"./" + basename + "_generated\";\n"; + } + } + } + + // Generate code for all enums. + void generateEnums(std::string *enum_code_ptr) { + for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); + ++it) { + auto &enum_def = **it; + GenEnum(enum_def, enum_code_ptr); + } + } + + // Generate code for all structs. + void generateStructs(std::string *decl_code_ptr, ImportedFileSet &importedFiles) { + for (auto it = parser_.structs_.vec.begin(); + it != parser_.structs_.vec.end(); ++it) { + auto &struct_def = **it; + GenStruct(parser_, struct_def, decl_code_ptr, importedFiles); + } + } + + void GenNamespaces(std::string *code_ptr) { + std::set namespaces; + + for (auto it = parser_.namespaces_.begin(); + it != parser_.namespaces_.end(); ++it) { + std::string namespace_so_far; + + // Gather all parent namespaces for this namespace + for (auto component = (*it)->components.begin(); + component != (*it)->components.end(); ++component) { + if (!namespace_so_far.empty()) { + namespace_so_far += '.'; + } + namespace_so_far += *component; + namespaces.insert(namespace_so_far); + } + } + + // Make sure parent namespaces come before child namespaces + std::vector sorted_namespaces( + namespaces.begin(), namespaces.end()); + std::sort(sorted_namespaces.begin(), sorted_namespaces.end()); + + // Emit namespaces in a form that Closure Compiler can optimize + std::string &code = *code_ptr; + for (auto it = sorted_namespaces.begin(); + it != sorted_namespaces.end(); it++) { + if (!parser_.opts.skip_flatbuffers_import && it->find('.') == std::string::npos) { + code += "import { flatbuffers } from \"./flatbuffers\"\n"; + } + } +} + +// Generate a documentation comment, if available. +static void GenDocComment(const std::vector &dc, + std::string *code_ptr, + const std::string &extra_lines, + const char *indent = nullptr) { + if (dc.empty() && extra_lines.empty()) { + // Don't output empty comment blocks with 0 lines of comment content. + return; + } + + std::string &code = *code_ptr; + if (indent) code += indent; + code += "/**\n"; + for (auto it = dc.begin(); it != dc.end(); ++it) { + if (indent) code += indent; + code += " *" + *it + "\n"; + } + if (!extra_lines.empty()) { + if (!dc.empty()) { + if (indent) code += indent; + code += " *\n"; + } + if (indent) code += indent; + std::string::size_type start = 0; + for (;;) { + auto end = extra_lines.find('\n', start); + if (end != std::string::npos) { + code += " * " + extra_lines.substr(start, end - start) + "\n"; + start = end + 1; + } else { + code += " * " + extra_lines.substr(start) + "\n"; + break; + } + } + } + if (indent) code += indent; + code += " */\n"; +} + +static void GenDocComment(std::string *code_ptr, + const std::string &extra_lines) { + GenDocComment(std::vector(), code_ptr, extra_lines); +} + +// Generate an enum declaration and an enum string lookup table. +void GenEnum(EnumDef &enum_def, std::string *code_ptr) { + if (enum_def.generated) return; + std::string &code = *code_ptr; + GenDocComment(enum_def.doc_comment, code_ptr, "@enum"); + code += "export namespace " + GetNameSpace(enum_def) + "{\n" + "export enum " + enum_def.name + "{\n"; + for (auto it = enum_def.vals.vec.begin(); + it != enum_def.vals.vec.end(); ++it) { + auto &ev = **it; + if (!ev.doc_comment.empty()) { + if (it != enum_def.vals.vec.begin()) { + code += '\n'; + } + GenDocComment(ev.doc_comment, code_ptr, "", " "); + } + code += " " + ev.name + "= " + NumToString(ev.value); + code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n"; + } + code += "}};\n\n"; +} + +static std::string GenType(const Type &type) { + switch (type.base_type) { + case BASE_TYPE_BOOL: + case BASE_TYPE_CHAR: return "Int8"; + case BASE_TYPE_UTYPE: + case BASE_TYPE_UCHAR: return "Uint8"; + case BASE_TYPE_SHORT: return "Int16"; + case BASE_TYPE_USHORT: return "Uint16"; + case BASE_TYPE_INT: return "Int32"; + case BASE_TYPE_UINT: return "Uint32"; + case BASE_TYPE_LONG: return "Int64"; + case BASE_TYPE_ULONG: return "Uint64"; + case BASE_TYPE_FLOAT: return "Float32"; + case BASE_TYPE_DOUBLE: return "Float64"; + case BASE_TYPE_STRING: return "String"; + case BASE_TYPE_VECTOR: return GenType(type.VectorType()); + case BASE_TYPE_STRUCT: return type.struct_def->name; + default: return "Table"; + } +} + +std::string GenGetter(const Type &type, const std::string &arguments) { + switch (type.base_type) { + case BASE_TYPE_STRING: return "this.bb.__string" + arguments; + case BASE_TYPE_STRUCT: return "this.bb.__struct" + arguments; + case BASE_TYPE_UNION: return "this.bb.__union" + arguments; + case BASE_TYPE_VECTOR: return GenGetter(type.VectorType(), arguments); + default: { + auto getter = "this.bb.read" + MakeCamel(GenType(type)) + arguments; + if (type.base_type == BASE_TYPE_BOOL) { + getter = "!!" + getter; + } + if (type.enum_def) { + getter = "/** @type {" + WrapInNameSpace(*type.enum_def) + "} */ (" + + getter + ")"; + } + return getter; + } + } +} + +std::string GenDefaultValue(const Value &value, const std::string &context) { + if (value.type.enum_def) { + if (auto val = value.type.enum_def->ReverseLookup( + atoi(value.constant.c_str()), false)) { + return WrapInNameSpace(*value.type.enum_def) + "." + val->name; + } else { + return "/** @type {" + WrapInNameSpace(*value.type.enum_def) + "} */ (" + + value.constant + ")"; + } + } + + switch (value.type.base_type) { + case BASE_TYPE_BOOL: + return value.constant == "0" ? "false" : "true"; + + case BASE_TYPE_STRING: + return "null"; + + case BASE_TYPE_LONG: + case BASE_TYPE_ULONG: { + int64_t constant = StringToInt(value.constant.c_str()); + return context + ".createLong(" + NumToString((int32_t)constant) + + ", " + NumToString((int32_t)(constant >> 32)) + ")"; + } + + default: + return value.constant; + } +} + +std::string GenTypeName(const Type &type, bool input) { + if (!input) { + if (type.base_type == BASE_TYPE_STRING) { + return "string|Uint8Array"; + } + if (type.base_type == BASE_TYPE_STRUCT) { + return WrapInNameSpace(*type.struct_def); + } + } + + switch (type.base_type) { + case BASE_TYPE_BOOL: return "boolean"; + case BASE_TYPE_LONG: + case BASE_TYPE_ULONG: return "flatbuffers.Long"; + default: + if (IsScalar(type.base_type)) { + if (type.enum_def) { + return WrapInNameSpace(*type.enum_def); + } + return "number"; + } + return "flatbuffers.Offset"; + } +} + +// Returns the method name for use with add/put calls. +static std::string GenWriteMethod(const Type &type) { + // Forward to signed versions since unsigned versions don't exist + switch (type.base_type) { + case BASE_TYPE_UTYPE: + case BASE_TYPE_UCHAR: return GenWriteMethod(Type(BASE_TYPE_CHAR)); + case BASE_TYPE_USHORT: return GenWriteMethod(Type(BASE_TYPE_SHORT)); + case BASE_TYPE_UINT: return GenWriteMethod(Type(BASE_TYPE_INT)); + case BASE_TYPE_ULONG: return GenWriteMethod(Type(BASE_TYPE_LONG)); + default: break; + } + + return IsScalar(type.base_type) + ? MakeCamel(GenType(type)) + : (IsStruct(type) ? "Struct" : "Offset"); +} + +template +static std::string MaybeAdd(T value) { + return value != 0 ? " + " + NumToString(value) : ""; +} + +template +static std::string MaybeScale(T value) { + return value != 1 ? " * " + NumToString(value) : ""; +} + +static std::string GenFileNamespacePrefix(const std::string &file) { + return "NS" + std::to_string(std::hash{}(file)); +} + +// Adds a source-dependent prefix, for of import * statements. +std::string GenPrefixedTypeName(const std::string &typeName, const std::string &file) { + const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(file)); + if (basename == file_name_) { + return typeName; + } + return GenFileNamespacePrefix(file) + "." + typeName; +} + +void GenStructArgs(const StructDef &struct_def, + std::string *annotations, + std::string *arguments, + const std::string &nameprefix) { + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (IsStruct(field.value.type)) { + // Generate arguments for a struct inside a struct. To ensure names + // don't clash, and to make it obvious these arguments are constructing + // a nested struct, prefix the name with the field name. + GenStructArgs(*field.value.type.struct_def, annotations, arguments, + nameprefix + field.name + "_"); + } else { + *annotations += "@param {" + GenTypeName(field.value.type, true); + *annotations += "} " + nameprefix + field.name + "\n"; + *arguments += ", " + nameprefix + field.name + ": " + GenTypeName(field.value.type, true); + } + } +} + +static void GenStructBody(const StructDef &struct_def, + std::string *body, + const std::string &nameprefix) { + *body += " builder.prep("; + *body += NumToString(struct_def.minalign) + ", "; + *body += NumToString(struct_def.bytesize) + ");\n"; + + for (auto it = struct_def.fields.vec.rbegin(); + it != struct_def.fields.vec.rend(); ++it) { + auto &field = **it; + if (field.padding) { + *body += " builder.pad(" + NumToString(field.padding) + ");\n"; + } + if (IsStruct(field.value.type)) { + // Generate arguments for a struct inside a struct. To ensure names + // don't clash, and to make it obvious these arguments are constructing + // a nested struct, prefix the name with the field name. + GenStructBody(*field.value.type.struct_def, body, + nameprefix + field.name + "_"); + } else { + *body += " builder.write" + GenWriteMethod(field.value.type) + "("; + if (field.value.type.base_type == BASE_TYPE_BOOL) { + *body += "+"; + } + *body += nameprefix + field.name + ");\n"; + } + } +} + +// Generate an accessor struct with constructor for a flatbuffers struct. +void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_ptr, ImportedFileSet &importedFiles) { + if (struct_def.generated) return; + std::string &code = *code_ptr; + + // Emit constructor + std::string object_name = struct_def.name; + std::string object_namespace = GetNameSpace(struct_def); + GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); + code += "export namespace " + object_namespace + "{\n"; + code += "export class " + struct_def.name; + code += " {\n"; + code += " /**\n"; + code += " * @type {flatbuffers.ByteBuffer}\n"; + code += " */\n"; + code += " bb: flatbuffers.ByteBuffer= null;\n"; + code += "\n"; + code += " /**\n"; + code += " * @type {number}\n"; + code += " */\n"; + code += " bb_pos:number = 0;\n"; + + // Generate the __init method that sets the field in a pre-existing + // accessor object. This is to allow object reuse. + code += "/**\n"; + code += " * @param {number} i\n"; + code += " * @param {flatbuffers.ByteBuffer} bb\n"; + code += " * @returns {" + object_name + "}\n"; + code += " */\n"; + code += "__init(i:number, bb:flatbuffers.ByteBuffer):" + object_name + " {\n"; + code += " this.bb_pos = i;\n"; + code += " this.bb = bb;\n"; + code += " return this;\n"; + code += "};\n\n"; + + // Generate a special accessor for the table that when used as the root of a + // FlatBuffer + if (!struct_def.fixed) { + GenDocComment(code_ptr, + "@param {flatbuffers.ByteBuffer} bb\n" + "@param {" + object_name + "=} obj\n" + "@returns {" + object_name + "}"); + code += "static getRootAs" + struct_def.name; + code += "(bb:flatbuffers.ByteBuffer, obj?:" + object_name + "):" + object_name + " {\n"; + code += " return (obj || new " + object_name; + code += ").__init(bb.readInt32(bb.position()) + bb.position(), bb);\n"; + code += "};\n\n"; + + // Generate the identifier check method + if (parser_.root_struct_def_ == &struct_def && + !parser_.file_identifier_.empty()) { + GenDocComment(code_ptr, + "@param {flatbuffers.ByteBuffer} bb\n" + "@returns {boolean}"); + code += "static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {\n"; + code += " return bb.__has_identifier('" + parser_.file_identifier_; + code += "');\n};\n\n"; + } + } + + // Emit field accessors + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + auto offset_prefix = " var offset = this.bb.__offset(this.bb_pos, " + + NumToString(field.value.offset) + ");\n return offset ? "; + + // Emit a scalar field + if (IsScalar(field.value.type.base_type) || + field.value.type.base_type == BASE_TYPE_STRING) { + GenDocComment(field.doc_comment, code_ptr, + std::string(field.value.type.base_type == BASE_TYPE_STRING ? + "@param {flatbuffers.Encoding=} optionalEncoding\n" : "") + + "@returns {" + GenTypeName(field.value.type, false) + "}"); + std::string prefix = MakeCamel(field.name, false) + "("; + if (field.value.type.base_type == BASE_TYPE_STRING) { + code += prefix + "):string\n"; + code += prefix + "optionalEncoding:flatbuffers.Encoding"+"):" + GenTypeName(field.value.type, false)+"\n"; + code += prefix + "optionalEncoding?:any"; + } else { + code += prefix; + } + code += "):" + GenTypeName(field.value.type, false) + " {\n"; + if (struct_def.fixed) { + code += " return " + GenGetter(field.value.type, "(this.bb_pos" + + MaybeAdd(field.value.offset) + ")") + ";\n"; + } else { + std::string index = "this.bb_pos + offset"; + if (field.value.type.base_type == BASE_TYPE_STRING) { + index += ", optionalEncoding"; + } + code += offset_prefix + GenGetter(field.value.type, + "(" + index + ")") + " : " + GenDefaultValue(field.value, "this.bb"); + code += ";\n"; + } + } + + // Emit an object field + else { + switch (field.value.type.base_type) { + case BASE_TYPE_STRUCT: { + auto type = WrapInNameSpace(*field.value.type.struct_def); + GenDocComment(field.doc_comment, code_ptr, + "@param {" + type + "=} obj\n@returns {" + type + "}"); + type = GenPrefixedTypeName(type, field.value.type.struct_def->file); + code += MakeCamel(field.name, false); + code += "(obj?:" + type + "):" + type + " {\n"; + if (struct_def.fixed) { + code += " return (obj || new " + type; + code += ").__init(this.bb_pos"; + code += MaybeAdd(field.value.offset) + ", this.bb);\n"; + } else { + code += offset_prefix + "(obj || new " + type + ").__init("; + code += field.value.type.struct_def->fixed + ? "this.bb_pos + offset" + : "this.bb.__indirect(this.bb_pos + offset)"; + code += ", this.bb) : null;\n"; + } + importedFiles.insert(field.value.type.struct_def->file); + break; + } + + case BASE_TYPE_VECTOR: { + auto vectortype = field.value.type.VectorType(); + auto vectortypename = GenTypeName(vectortype, false); + auto inline_size = InlineSize(vectortype); + auto index = "this.bb.__vector(this.bb_pos + offset) + index" + + MaybeScale(inline_size); + std::string args = "@param {number} index\n"; + if (vectortype.base_type == BASE_TYPE_STRUCT) { + args += "@param {" + vectortypename + "=} obj\n"; + } else if (vectortype.base_type == BASE_TYPE_STRING) { + args += "@param {flatbuffers.Encoding=} optionalEncoding\n"; + } + GenDocComment(field.doc_comment, code_ptr, args + + "@returns {" + vectortypename + "}"); + std::string prefix = MakeCamel(field.name, false); + prefix += "(index: number"; + if (vectortype.base_type == BASE_TYPE_STRUCT) { + vectortypename = GenPrefixedTypeName(vectortypename, vectortype.struct_def->file); + code += prefix + ", obj?:" + vectortypename; + importedFiles.insert(vectortype.struct_def->file); + } else if (vectortype.base_type == BASE_TYPE_STRING) { + code += prefix + "):string\n"; + code += prefix + ",optionalEncoding:flatbuffers.Encoding" + "):" + vectortypename + "\n"; + code += prefix + ",optionalEncoding?:any"; + } else { + code += prefix; + } + code += "):" + vectortypename + " {\n"; + if (vectortype.base_type == BASE_TYPE_STRUCT) { + code += offset_prefix + "(obj || new " + vectortypename; + code += ").__init("; + code += vectortype.struct_def->fixed + ? index + : "this.bb.__indirect(" + index + ")"; + code += ", this.bb)"; + } else { + if (vectortype.base_type == BASE_TYPE_STRING) { + index += ", optionalEncoding"; + } + code += offset_prefix + GenGetter(vectortype, "(" + index + ")"); + } + code += " : "; + if (field.value.type.element == BASE_TYPE_BOOL) { + code += "false"; + } else if (field.value.type.element == BASE_TYPE_LONG || + field.value.type.element == BASE_TYPE_ULONG) { + code += "this.bb.createLong(0, 0)"; + } else if (IsScalar(field.value.type.element)) { + if (field.value.type.enum_def) { + code += "/** @type {" + + WrapInNameSpace(*field.value.type.enum_def) + "} */ (" + + field.value.constant + ")"; + } else { + code += "0"; + } + } else { + code += "null"; + } + code += ";\n"; + break; + } + + case BASE_TYPE_UNION: + GenDocComment(field.doc_comment, code_ptr, + "@param {flatbuffers.Table} obj\n" + "@returns {?flatbuffers.Table}"); + code += MakeCamel(field.name, false); + code += "(obj:T):T {\n"; + code += offset_prefix + GenGetter(field.value.type, + "(obj, this.bb_pos + offset)") + " : null;\n"; + break; + + default: + assert(0); + } + } + code += "};\n\n"; + + // Adds the mutable scalar value to the output + if (IsScalar(field.value.type.base_type) && parser.opts.mutable_buffer) { + std::string annotations = "@param {" + GenTypeName(field.value.type, true) + "} value\n"; + GenDocComment(code_ptr, annotations + + "@returns {boolean}"); + + code += "mutate_" + field.name + "(value:" + GenTypeName(field.value.type, true) + "):boolean {\n"; + code += " var offset = this.bb.__offset(this.bb_pos, " + NumToString(field.value.offset) + ");\n\n"; + code += " if (offset === 0) {\n"; + code += " return false;\n"; + code += " }\n\n"; + code += " this.bb.write" + MakeCamel(GenType(field.value.type)) + "(this.bb_pos + offset, value);\n"; + code += " return true;\n"; + code += "};\n\n"; + } + + // Emit vector helpers + if (field.value.type.base_type == BASE_TYPE_VECTOR) { + // Emit a length helper + GenDocComment(code_ptr, "@returns {number}"); + code += MakeCamel(field.name, false); + code += "Length():number {\n" + offset_prefix; + code += "this.bb.__vector_len(this.bb_pos + offset) : 0;\n};\n\n"; + + // For scalar types, emit a typed array helper + auto vectorType = field.value.type.VectorType(); + if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) { + GenDocComment(code_ptr, "@returns {" + GenType(vectorType) + "Array}"); + code += MakeCamel(field.name, false); + code += "Array():" + GenType(vectorType) + "Array {\n" + offset_prefix; + code += "new " + GenType(vectorType) + "Array(this.bb.bytes().buffer, " + "this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), " + "this.bb.__vector_len(this.bb_pos + offset)) : null;\n};\n\n"; + } + } + } + + // Emit a factory constructor + if (struct_def.fixed) { + std::string annotations = "@param {flatbuffers.Builder} builder\n"; + std::string arguments; + GenStructArgs(struct_def, &annotations, &arguments, ""); + GenDocComment(code_ptr, annotations + + "@returns {flatbuffers.Offset}"); + code += "static create" + struct_def.name + "(builder:flatbuffers.Builder"; + code += arguments + "):flatbuffers.Offset {\n"; + GenStructBody(struct_def, &code, ""); + code += " return builder.offset();\n};\n\n"; + } else { + // Generate a method to start building a new object + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder"); + code += "static start" + struct_def.name; + code += "(builder:flatbuffers.Builder) {\n"; + code += " builder.startObject(" + NumToString( + struct_def.fields.vec.size()) + ");\n"; + code += "};\n\n"; + + // Generate a set of static methods that allow table construction + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + auto argname = MakeCamel(field.name, false); + if (!IsScalar(field.value.type.base_type)) { + argname += "Offset"; + } + + // Generate the field insertion method + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@param {" + GenTypeName(field.value.type, true) + "} " + + argname); + code += "static add" + MakeCamel(field.name); + code += "(builder:flatbuffers.Builder, " + argname + ":" + GenTypeName(field.value.type, true) + ") {\n"; + code += " builder.addField" + GenWriteMethod(field.value.type) + "("; + code += NumToString(it - struct_def.fields.vec.begin()) + ", "; + if (field.value.type.base_type == BASE_TYPE_BOOL) { + code += "+"; + } + code += argname + ", "; + if (!IsScalar(field.value.type.base_type)) { + code += "0"; + } else { + if (field.value.type.base_type == BASE_TYPE_BOOL) { + code += "+"; + } + code += GenDefaultValue(field.value, "builder"); + } + code += ");\n};\n\n"; + + if (field.value.type.base_type == BASE_TYPE_VECTOR) { + auto vector_type = field.value.type.VectorType(); + auto alignment = InlineAlignment(vector_type); + auto elem_size = InlineSize(vector_type); + + // Generate a method to create a vector from a JavaScript array + if (!IsStruct(vector_type)) { + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@param {Array.<" + GenTypeName(vector_type, true) + + ">} data\n" + "@returns {flatbuffers.Offset}"); + code += "static create" + MakeCamel(field.name); + std::string type = GenTypeName(vector_type, true) + "[]"; + if (type == "number[]") { + type += " | Uint8Array"; + } + code += "Vector(builder:flatbuffers.Builder, data:" + type+"):flatbuffers.Offset {\n"; + code += "if(!data){\n return null\n}\n"; + 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"; + } + + // Generate a method to start a vector, data to be added manually after + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@param {number} numElems"); + code += "static start" + MakeCamel(field.name); + code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n"; + code += " builder.startVector(" + NumToString(elem_size); + code += ", numElems, " + NumToString(alignment) + ");\n"; + code += "};\n\n"; + } + } + + // Generate a method to stop building a new object + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@returns {flatbuffers.Offset}"); + code += "static end" + struct_def.name; + code += "(builder:flatbuffers.Builder):flatbuffers.Offset {\n"; + code += " var offset = builder.endObject();\n"; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (!field.deprecated && field.required) { + code += " builder.requiredField(offset, "; + code += NumToString(field.value.offset); + code += "); // " + field.name + "\n"; + } + } + code += " return offset;\n"; + code += "};\n\n"; + + // Generate the method to complete buffer construction + if (parser_.root_struct_def_ == &struct_def) { + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@param {flatbuffers.Offset} offset"); + code += "static finish" + struct_def.name + "Buffer"; + code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n"; + code += " builder.finish(offset"; + if (!parser_.file_identifier_.empty()) { + code += ", '" + parser_.file_identifier_ + "'"; + } + code += ");\n"; + code += "};\n\n"; + } + } + code += "}\n}\n"; +} +}; +} // namespace ts + +bool GenerateTS(const Parser &parser, const std::string &path, + const std::string &file_name) { + ts::TsGenerator generator(parser, path, file_name); + return generator.generate(); +} + +std::string TSMakeRule(const Parser &parser, + const std::string &path, + const std::string &file_name) { + std::string filebase = flatbuffers::StripPath( + flatbuffers::StripExtension(file_name)); + std::string make_rule = GeneratedFileName(path, filebase) + ": "; + auto included_files = parser.GetIncludedFilesRecursive(file_name); + for (auto it = included_files.begin(); + it != included_files.end(); ++it) { + make_rule += " " + *it; + } + return make_rule; +} + +} // namespace flatbuffers From 608653b38313afd75766e9a62e01dcb2e886bb1c Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Fri, 17 Mar 2017 11:07:50 +0100 Subject: [PATCH 03/17] Prefixing enums --- src/idl_gen_ts.cpp | 27 +++++++++++++++++++++++---- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp index defd904e731..c20e9e9e1b2 100644 --- a/src/idl_gen_ts.cpp +++ b/src/idl_gen_ts.cpp @@ -240,7 +240,7 @@ std::string GenDefaultValue(const Value &value, const std::string &context) { if (value.type.enum_def) { if (auto val = value.type.enum_def->ReverseLookup( atoi(value.constant.c_str()), false)) { - return WrapInNameSpace(*value.type.enum_def) + "." + val->name; + return GenPrefixedTypeName(WrapInNameSpace(*value.type.enum_def), value.type.enum_def->file) + "." + val->name; } else { return "/** @type {" + WrapInNameSpace(*value.type.enum_def) + "} */ (" + value.constant + ")"; @@ -464,7 +464,11 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt } else { code += prefix; } - code += "):" + GenTypeName(field.value.type, false) + " {\n"; + if (field.value.type.enum_def) { + code += "):" + GenPrefixedTypeName(GenTypeName(field.value.type, false), field.value.type.enum_def->file) + " {\n"; + } else { + code += "):" + GenTypeName(field.value.type, false) + " {\n"; + } if (struct_def.fixed) { code += " return " + GenGetter(field.value.type, "(this.bb_pos" + MaybeAdd(field.value.offset) + ")") + ";\n"; @@ -588,7 +592,14 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, annotations + "@returns {boolean}"); - code += "mutate_" + field.name + "(value:" + GenTypeName(field.value.type, true) + "):boolean {\n"; + std::string type; + if (field.value.type.enum_def) { + type = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); + } else { + type = GenTypeName(field.value.type, true); + } + + code += "mutate_" + field.name + "(value:" + type + "):boolean {\n"; code += " var offset = this.bb.__offset(this.bb_pos, " + NumToString(field.value.offset) + ");\n\n"; code += " if (offset === 0) {\n"; code += " return false;\n"; @@ -655,8 +666,16 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {flatbuffers.Builder} builder\n" "@param {" + GenTypeName(field.value.type, true) + "} " + argname); + + std::string argType; + if (field.value.type.enum_def) { + argType = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); + } else { + argType = GenTypeName(field.value.type, true); + } + code += "static add" + MakeCamel(field.name); - code += "(builder:flatbuffers.Builder, " + argname + ":" + GenTypeName(field.value.type, true) + ") {\n"; + code += "(builder:flatbuffers.Builder, " + argname + ":" + argType + ") {\n"; code += " builder.addField" + GenWriteMethod(field.value.type) + "("; code += NumToString(it - struct_def.fields.vec.begin()) + ", "; if (field.value.type.base_type == BASE_TYPE_BOOL) { From 246048e053eff69bf4082fc32886461aec56af28 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Fri, 17 Mar 2017 11:08:21 +0100 Subject: [PATCH 04/17] Test results --- tests/generate_code.sh | 4 +- tests/monster_test_generated.ts | 1566 +++++++++++++++++ .../namespace_test1_generated.ts | 180 ++ .../namespace_test2_generated.ts | 277 +++ 4 files changed, 2025 insertions(+), 2 deletions(-) create mode 100644 tests/monster_test_generated.ts create mode 100644 tests/namespace_test/namespace_test1_generated.ts create mode 100644 tests/namespace_test/namespace_test2_generated.ts diff --git a/tests/generate_code.sh b/tests/generate_code.sh index a5354ebce88..00d87f7c716 100755 --- a/tests/generate_code.sh +++ b/tests/generate_code.sh @@ -14,8 +14,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -../flatc --cpp --java --csharp --go --binary --python --js --php --grpc --gen-mutable --gen-object-api --no-includes monster_test.fbs monsterdata_test.json -../flatc --cpp --java --csharp --go --binary --python --js --php --gen-mutable -o namespace_test namespace_test/namespace_test1.fbs namespace_test/namespace_test2.fbs +../flatc --cpp --java --csharp --go --binary --python --js --ts --php --grpc --gen-mutable --gen-object-api --no-includes monster_test.fbs monsterdata_test.json +../flatc --cpp --java --csharp --go --binary --python --js --ts --php --gen-mutable -o namespace_test namespace_test/namespace_test1.fbs namespace_test/namespace_test2.fbs ../flatc --cpp -o union_vector ./union_vector/union_vector.fbs ../flatc -b --schema --bfbs-comments monster_test.fbs cd ../samples diff --git a/tests/monster_test_generated.ts b/tests/monster_test_generated.ts new file mode 100644 index 00000000000..525db782996 --- /dev/null +++ b/tests/monster_test_generated.ts @@ -0,0 +1,1566 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import { flatbuffers } from "./flatbuffers" +/** + * @enum + */ +export namespace MyGame.Example{ +export enum Color{ + Red= 1, + Green= 2, + Blue= 8 +}}; + +/** + * @enum + */ +export namespace MyGame.Example{ +export enum Any{ + NONE= 0, + Monster= 1, + TestSimpleTableWithEnum= 2, + MyGame_Example2_Monster= 3 +}}; + +/** + * @constructor + */ +export namespace MyGame.Example2{ +export class Monster { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Monster} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):Monster { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Monster=} obj + * @returns {Monster} + */ +static getRootAsMonster(bb:flatbuffers.ByteBuffer, obj?:Monster):Monster { + return (obj || new Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startMonster(builder:flatbuffers.Builder) { + builder.startObject(0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} +/** + * @constructor + */ +export namespace MyGame.Example{ +export class Test { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Test} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):Test { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +a():number { + return this.bb.readInt16(this.bb_pos); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_a(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 0); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +b():number { + return this.bb.readInt8(this.bb_pos + 2); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_b(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 2); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} a + * @param {number} b + * @returns {flatbuffers.Offset} + */ +static createTest(builder:flatbuffers.Builder, a: number, b: number):flatbuffers.Offset { + builder.prep(2, 4); + builder.pad(1); + builder.writeInt8(b); + builder.writeInt16(a); + return builder.offset(); +}; + +} +} +/** + * @constructor + */ +export namespace MyGame.Example{ +export class TestSimpleTableWithEnum { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {TestSimpleTableWithEnum} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):TestSimpleTableWithEnum { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {TestSimpleTableWithEnum=} obj + * @returns {TestSimpleTableWithEnum} + */ +static getRootAsTestSimpleTableWithEnum(bb:flatbuffers.ByteBuffer, obj?:TestSimpleTableWithEnum):TestSimpleTableWithEnum { + return (obj || new TestSimpleTableWithEnum).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {MyGame.Example.Color} + */ +color():MyGame.Example.Color { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Green; +}; + +/** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ +mutate_color(value:MyGame.Example.Color):boolean { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startTestSimpleTableWithEnum(builder:flatbuffers.Builder) { + builder.startObject(1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Color} color + */ +static addColor(builder:flatbuffers.Builder, color:MyGame.Example.Color) { + builder.addFieldInt8(0, color, MyGame.Example.Color.Green); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endTestSimpleTableWithEnum(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} +/** + * @constructor + */ +export namespace MyGame.Example{ +export class Vec3 { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Vec3} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):Vec3 { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +x():number { + return this.bb.readFloat32(this.bb_pos); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_x(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 0); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +y():number { + return this.bb.readFloat32(this.bb_pos + 4); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_y(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +z():number { + return this.bb.readFloat32(this.bb_pos + 8); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_z(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +test1():number { + return this.bb.readFloat64(this.bb_pos + 16); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_test1(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 16); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {MyGame.Example.Color} + */ +test2():MyGame.Example.Color { + return /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + 24)); +}; + +/** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ +mutate_test2(value:MyGame.Example.Color):boolean { + var offset = this.bb.__offset(this.bb_pos, 24); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {MyGame.Example.Test=} obj + * @returns {MyGame.Example.Test} + */ +test3(obj?:MyGame.Example.Test):MyGame.Example.Test { + return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} x + * @param {number} y + * @param {number} z + * @param {number} test1 + * @param {MyGame.Example.Color} test2 + * @param {number} test3_a + * @param {number} test3_b + * @returns {flatbuffers.Offset} + */ +static createVec3(builder:flatbuffers.Builder, x: number, y: number, z: number, test1: number, test2: MyGame.Example.Color, test3_a: number, test3_b: number):flatbuffers.Offset { + builder.prep(16, 32); + builder.pad(2); + builder.prep(2, 4); + builder.pad(1); + builder.writeInt8(test3_b); + builder.writeInt16(test3_a); + builder.pad(1); + builder.writeInt8(test2); + builder.writeFloat64(test1); + builder.pad(4); + builder.writeFloat32(z); + builder.writeFloat32(y); + builder.writeFloat32(x); + return builder.offset(); +}; + +} +} +/** + * @constructor + */ +export namespace MyGame.Example{ +export class Stat { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Stat} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):Stat { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Stat=} obj + * @returns {Stat} + */ +static getRootAsStat(bb:flatbuffers.ByteBuffer, obj?:Stat):Stat { + return (obj || new Stat).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +id():string +id(optionalEncoding:flatbuffers.Encoding):string|Uint8Array +id(optionalEncoding?:any):string|Uint8Array { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @returns {flatbuffers.Long} + */ +val():flatbuffers.Long { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +mutate_val(value:flatbuffers.Long):boolean { + var offset = this.bb.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +count():number { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_count(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeUint16(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startStat(builder:flatbuffers.Builder) { + builder.startObject(3); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} idOffset + */ +static addId(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, idOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} val + */ +static addVal(builder:flatbuffers.Builder, val:flatbuffers.Long) { + builder.addFieldInt64(1, val, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} count + */ +static addCount(builder:flatbuffers.Builder, count:number) { + builder.addFieldInt16(2, count, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endStat(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} +/** + * an example documentation comment: monster object + * + * @constructor + */ +export namespace MyGame.Example{ +export class Monster { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Monster} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):Monster { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Monster=} obj + * @returns {Monster} + */ +static getRootAsMonster(bb:flatbuffers.ByteBuffer, obj?:Monster):Monster { + return (obj || new Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @returns {boolean} + */ +static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean { + return bb.__has_identifier('MONS'); +}; + +/** + * @param {MyGame.Example.Vec3=} obj + * @returns {MyGame.Example.Vec3} + */ +pos(obj?:MyGame.Example.Vec3):MyGame.Example.Vec3 { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb) : null; +}; + +/** + * @returns {number} + */ +mana():number { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 150; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_mana(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +hp():number { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 100; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_hp(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +name():string +name(optionalEncoding:flatbuffers.Encoding):string|Uint8Array +name(optionalEncoding?:any):string|Uint8Array { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +inventory(index: number):number { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +inventoryLength():number { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +inventoryArray():Uint8Array { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {MyGame.Example.Color} + */ +color():MyGame.Example.Color { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Blue; +}; + +/** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ +mutate_color(value:MyGame.Example.Color):boolean { + var offset = this.bb.__offset(this.bb_pos, 16); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {MyGame.Example.Any} + */ +testType():MyGame.Example.Any { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? /** @type {MyGame.Example.Any} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE; +}; + +/** + * @param {MyGame.Example.Any} value + * @returns {boolean} + */ +mutate_test_type(value:MyGame.Example.Any):boolean { + var offset = this.bb.__offset(this.bb_pos, 18); + + if (offset === 0) { + return false; + } + + this.bb.writeUint8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Table} obj + * @returns {?flatbuffers.Table} + */ +test(obj:T):T { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__union(obj, this.bb_pos + offset) : null; +}; + +/** + * @param {number} index + * @param {MyGame.Example.Test=} obj + * @returns {MyGame.Example.Test} + */ +test4(index: number, obj?:MyGame.Example.Test):MyGame.Example.Test { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null; +}; + +/** + * @returns {number} + */ +test4Length():number { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +testarrayofstring(index: number):string +testarrayofstring(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array +testarrayofstring(index: number,optionalEncoding?:any):string|Uint8Array { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +testarrayofstringLength():number { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * an example documentation comment: this will end up in the generated code + * multiline too + * + * @param {number} index + * @param {MyGame.Example.Monster=} obj + * @returns {MyGame.Example.Monster} + */ +testarrayoftables(index: number, obj?:MyGame.Example.Monster):MyGame.Example.Monster { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +testarrayoftablesLength():number { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {MyGame.Example.Monster=} obj + * @returns {MyGame.Example.Monster} + */ +enemy(obj?:MyGame.Example.Monster):MyGame.Example.Monster { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +testnestedflatbuffer(index: number):number { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +testnestedflatbufferLength():number { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +testnestedflatbufferArray():Uint8Array { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {MyGame.Example.Stat=} obj + * @returns {MyGame.Example.Stat} + */ +testempty(obj?:MyGame.Example.Stat):MyGame.Example.Stat { + var offset = this.bb.__offset(this.bb_pos, 32); + return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @returns {boolean} + */ +testbool():boolean { + var offset = this.bb.__offset(this.bb_pos, 34); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; +}; + +/** + * @param {boolean} value + * @returns {boolean} + */ +mutate_testbool(value:boolean):boolean { + var offset = this.bb.__offset(this.bb_pos, 34); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +testhashs32Fnv1():number { + var offset = this.bb.__offset(this.bb_pos, 36); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_testhashs32_fnv1(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 36); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +testhashu32Fnv1():number { + var offset = this.bb.__offset(this.bb_pos, 38); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_testhashu32_fnv1(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 38); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +testhashs64Fnv1():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); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +mutate_testhashs64_fnv1(value:flatbuffers.Long):boolean { + var offset = this.bb.__offset(this.bb_pos, 40); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +testhashu64Fnv1():flatbuffers.Long { + var offset = this.bb.__offset(this.bb_pos, 42); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +mutate_testhashu64_fnv1(value:flatbuffers.Long):boolean { + var offset = this.bb.__offset(this.bb_pos, 42); + + if (offset === 0) { + return false; + } + + this.bb.writeUint64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +testhashs32Fnv1a():number { + var offset = this.bb.__offset(this.bb_pos, 44); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_testhashs32_fnv1a(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 44); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +testhashu32Fnv1a():number { + var offset = this.bb.__offset(this.bb_pos, 46); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_testhashu32_fnv1a(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 46); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +testhashs64Fnv1a():flatbuffers.Long { + var offset = this.bb.__offset(this.bb_pos, 48); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +mutate_testhashs64_fnv1a(value:flatbuffers.Long):boolean { + var offset = this.bb.__offset(this.bb_pos, 48); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +testhashu64Fnv1a():flatbuffers.Long { + var offset = this.bb.__offset(this.bb_pos, 50); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +mutate_testhashu64_fnv1a(value:flatbuffers.Long):boolean { + var offset = this.bb.__offset(this.bb_pos, 50); + + if (offset === 0) { + return false; + } + + this.bb.writeUint64(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {number} index + * @returns {boolean} + */ +testarrayofbools(index: number):boolean { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false; +}; + +/** + * @returns {number} + */ +testarrayofboolsLength():number { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Int8Array} + */ +testarrayofboolsArray():Int8Array { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +testf():number { + var offset = this.bb.__offset(this.bb_pos, 54); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.14159; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_testf(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 54); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +testf2():number { + var offset = this.bb.__offset(this.bb_pos, 56); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_testf2(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 56); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +testf3():number { + var offset = this.bb.__offset(this.bb_pos, 58); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_testf3(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 58); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {number} index + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +testarrayofstring2(index: number):string +testarrayofstring2(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array +testarrayofstring2(index: number,optionalEncoding?:any):string|Uint8Array { + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +testarrayofstring2Length():number { + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startMonster(builder:flatbuffers.Builder) { + builder.startObject(29); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} posOffset + */ +static addPos(builder:flatbuffers.Builder, posOffset:flatbuffers.Offset) { + builder.addFieldStruct(0, posOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} mana + */ +static addMana(builder:flatbuffers.Builder, mana:number) { + builder.addFieldInt16(1, mana, 150); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} hp + */ +static addHp(builder:flatbuffers.Builder, hp:number) { + builder.addFieldInt16(2, hp, 100); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} nameOffset + */ +static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) { + builder.addFieldOffset(3, nameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} inventoryOffset + */ +static addInventory(builder:flatbuffers.Builder, inventoryOffset:flatbuffers.Offset) { + builder.addFieldOffset(5, inventoryOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createInventoryVector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset { +if(!data){ + return null +} + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startInventoryVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Color} color + */ +static addColor(builder:flatbuffers.Builder, color:MyGame.Example.Color) { + builder.addFieldInt8(6, color, MyGame.Example.Color.Blue); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Any} testType + */ +static addTestType(builder:flatbuffers.Builder, testType:MyGame.Example.Any) { + builder.addFieldInt8(7, testType, MyGame.Example.Any.NONE); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testOffset + */ +static addTest(builder:flatbuffers.Builder, testOffset:flatbuffers.Offset) { + builder.addFieldOffset(8, testOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} test4Offset + */ +static addTest4(builder:flatbuffers.Builder, test4Offset:flatbuffers.Offset) { + builder.addFieldOffset(9, test4Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startTest4Vector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofstringOffset + */ +static addTestarrayofstring(builder:flatbuffers.Builder, testarrayofstringOffset:flatbuffers.Offset) { + builder.addFieldOffset(10, testarrayofstringOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createTestarrayofstringVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { +if(!data){ + return null +} + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startTestarrayofstringVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayoftablesOffset + */ +static addTestarrayoftables(builder:flatbuffers.Builder, testarrayoftablesOffset:flatbuffers.Offset) { + builder.addFieldOffset(11, testarrayoftablesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createTestarrayoftablesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { +if(!data){ + return null +} + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startTestarrayoftablesVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} enemyOffset + */ +static addEnemy(builder:flatbuffers.Builder, enemyOffset:flatbuffers.Offset) { + builder.addFieldOffset(12, enemyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testnestedflatbufferOffset + */ +static addTestnestedflatbuffer(builder:flatbuffers.Builder, testnestedflatbufferOffset:flatbuffers.Offset) { + builder.addFieldOffset(13, testnestedflatbufferOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createTestnestedflatbufferVector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset { +if(!data){ + return null +} + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startTestnestedflatbufferVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testemptyOffset + */ +static addTestempty(builder:flatbuffers.Builder, testemptyOffset:flatbuffers.Offset) { + builder.addFieldOffset(14, testemptyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} testbool + */ +static addTestbool(builder:flatbuffers.Builder, testbool:boolean) { + builder.addFieldInt8(15, +testbool, +false); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashs32Fnv1 + */ +static addTesthashs32Fnv1(builder:flatbuffers.Builder, testhashs32Fnv1:number) { + builder.addFieldInt32(16, testhashs32Fnv1, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashu32Fnv1 + */ +static addTesthashu32Fnv1(builder:flatbuffers.Builder, testhashu32Fnv1:number) { + builder.addFieldInt32(17, testhashu32Fnv1, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashs64Fnv1 + */ +static addTesthashs64Fnv1(builder:flatbuffers.Builder, testhashs64Fnv1:flatbuffers.Long) { + builder.addFieldInt64(18, testhashs64Fnv1, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashu64Fnv1 + */ +static addTesthashu64Fnv1(builder:flatbuffers.Builder, testhashu64Fnv1:flatbuffers.Long) { + builder.addFieldInt64(19, testhashu64Fnv1, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashs32Fnv1a + */ +static addTesthashs32Fnv1a(builder:flatbuffers.Builder, testhashs32Fnv1a:number) { + builder.addFieldInt32(20, testhashs32Fnv1a, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashu32Fnv1a + */ +static addTesthashu32Fnv1a(builder:flatbuffers.Builder, testhashu32Fnv1a:number) { + builder.addFieldInt32(21, testhashu32Fnv1a, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashs64Fnv1a + */ +static addTesthashs64Fnv1a(builder:flatbuffers.Builder, testhashs64Fnv1a:flatbuffers.Long) { + builder.addFieldInt64(22, testhashs64Fnv1a, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashu64Fnv1a + */ +static addTesthashu64Fnv1a(builder:flatbuffers.Builder, testhashu64Fnv1a:flatbuffers.Long) { + builder.addFieldInt64(23, testhashu64Fnv1a, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofboolsOffset + */ +static addTestarrayofbools(builder:flatbuffers.Builder, testarrayofboolsOffset:flatbuffers.Offset) { + builder.addFieldOffset(24, testarrayofboolsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createTestarrayofboolsVector(builder:flatbuffers.Builder, data:boolean[]):flatbuffers.Offset { +if(!data){ + return null +} + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(+data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startTestarrayofboolsVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testf + */ +static addTestf(builder:flatbuffers.Builder, testf:number) { + builder.addFieldFloat32(25, testf, 3.14159); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testf2 + */ +static addTestf2(builder:flatbuffers.Builder, testf2:number) { + builder.addFieldFloat32(26, testf2, 3.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testf3 + */ +static addTestf3(builder:flatbuffers.Builder, testf3:number) { + builder.addFieldFloat32(27, testf3, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofstring2Offset + */ +static addTestarrayofstring2(builder:flatbuffers.Builder, testarrayofstring2Offset:flatbuffers.Offset) { + builder.addFieldOffset(28, testarrayofstring2Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createTestarrayofstring2Vector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { +if(!data){ + return null +} + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startTestarrayofstring2Vector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + builder.requiredField(offset, 10); // name + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +static finishMonsterBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) { + builder.finish(offset, 'MONS'); +}; + +} +} diff --git a/tests/namespace_test/namespace_test1_generated.ts b/tests/namespace_test/namespace_test1_generated.ts new file mode 100644 index 00000000000..f94d14a52e7 --- /dev/null +++ b/tests/namespace_test/namespace_test1_generated.ts @@ -0,0 +1,180 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import { flatbuffers } from "./flatbuffers" +/** + * @enum + */ +export namespace NamespaceA.NamespaceB{ +export enum EnumInNestedNS{ + A= 0, + B= 1, + C= 2 +}}; + +/** + * @constructor + */ +export namespace NamespaceA.NamespaceB{ +export class TableInNestedNS { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {TableInNestedNS} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):TableInNestedNS { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {TableInNestedNS=} obj + * @returns {TableInNestedNS} + */ +static getRootAsTableInNestedNS(bb:flatbuffers.ByteBuffer, obj?:TableInNestedNS):TableInNestedNS { + return (obj || new TableInNestedNS).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +foo():number { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_foo(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startTableInNestedNS(builder:flatbuffers.Builder) { + builder.startObject(1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} foo + */ +static addFoo(builder:flatbuffers.Builder, foo:number) { + builder.addFieldInt32(0, foo, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endTableInNestedNS(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} +/** + * @constructor + */ +export namespace NamespaceA.NamespaceB{ +export class StructInNestedNS { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {StructInNestedNS} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):StructInNestedNS { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +a():number { + return this.bb.readInt32(this.bb_pos); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_a(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 0); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +b():number { + return this.bb.readInt32(this.bb_pos + 4); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_b(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} a + * @param {number} b + * @returns {flatbuffers.Offset} + */ +static createStructInNestedNS(builder:flatbuffers.Builder, a: number, b: number):flatbuffers.Offset { + builder.prep(4, 8); + builder.writeInt32(b); + builder.writeInt32(a); + return builder.offset(); +}; + +} +} diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts new file mode 100644 index 00000000000..3d638988695 --- /dev/null +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -0,0 +1,277 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import { flatbuffers } from "./flatbuffers" +import { flatbuffers } from "./flatbuffers" +import * as NS9459827973991502386 from "./namespace_test1_generated"; +/** + * @constructor + */ +export namespace NamespaceA{ +export class TableInFirstNS { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {TableInFirstNS} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):TableInFirstNS { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {TableInFirstNS=} obj + * @returns {TableInFirstNS} + */ +static getRootAsTableInFirstNS(bb:flatbuffers.ByteBuffer, obj?:TableInFirstNS):TableInFirstNS { + return (obj || new TableInFirstNS).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {NamespaceA.NamespaceB.TableInNestedNS=} obj + * @returns {NamespaceA.NamespaceB.TableInNestedNS} + */ +fooTable(obj?:NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @returns {NamespaceA.NamespaceB.EnumInNestedNS} + */ +fooEnum():NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb.readInt8(this.bb_pos + offset)) : NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A; +}; + +/** + * @param {NamespaceA.NamespaceB.EnumInNestedNS} value + * @returns {boolean} + */ +mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS):boolean { + var offset = this.bb.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {NamespaceA.NamespaceB.StructInNestedNS=} obj + * @returns {NamespaceA.NamespaceB.StructInNestedNS} + */ +fooStruct(obj?:NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startTableInFirstNS(builder:flatbuffers.Builder) { + builder.startObject(3); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} fooTableOffset + */ +static addFooTable(builder:flatbuffers.Builder, fooTableOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, fooTableOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {NamespaceA.NamespaceB.EnumInNestedNS} fooEnum + */ +static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS) { + builder.addFieldInt8(1, fooEnum, NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} fooStructOffset + */ +static addFooStruct(builder:flatbuffers.Builder, fooStructOffset:flatbuffers.Offset) { + builder.addFieldStruct(2, fooStructOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endTableInFirstNS(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} +/** + * @constructor + */ +export namespace NamespaceC{ +export class TableInC { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {TableInC} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):TableInC { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {TableInC=} obj + * @returns {TableInC} + */ +static getRootAsTableInC(bb:flatbuffers.ByteBuffer, obj?:TableInC):TableInC { + return (obj || new TableInC).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {NamespaceA.TableInFirstNS=} obj + * @returns {NamespaceA.TableInFirstNS} + */ +referToA1(obj?:NamespaceA.TableInFirstNS):NamespaceA.TableInFirstNS { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new NamespaceA.TableInFirstNS).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {NamespaceA.SecondTableInA=} obj + * @returns {NamespaceA.SecondTableInA} + */ +referToA2(obj?:NamespaceA.SecondTableInA):NamespaceA.SecondTableInA { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? (obj || new NamespaceA.SecondTableInA).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startTableInC(builder:flatbuffers.Builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} referToA1Offset + */ +static addReferToA1(builder:flatbuffers.Builder, referToA1Offset:flatbuffers.Offset) { + builder.addFieldOffset(0, referToA1Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} referToA2Offset + */ +static addReferToA2(builder:flatbuffers.Builder, referToA2Offset:flatbuffers.Offset) { + builder.addFieldOffset(1, referToA2Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endTableInC(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} +/** + * @constructor + */ +export namespace NamespaceA{ +export class SecondTableInA { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {SecondTableInA} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):SecondTableInA { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {SecondTableInA=} obj + * @returns {SecondTableInA} + */ +static getRootAsSecondTableInA(bb:flatbuffers.ByteBuffer, obj?:SecondTableInA):SecondTableInA { + return (obj || new SecondTableInA).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {NamespaceC.TableInC=} obj + * @returns {NamespaceC.TableInC} + */ +referToC(obj?:NamespaceC.TableInC):NamespaceC.TableInC { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new NamespaceC.TableInC).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startSecondTableInA(builder:flatbuffers.Builder) { + builder.startObject(1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} referToCOffset + */ +static addReferToC(builder:flatbuffers.Builder, referToCOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, referToCOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endSecondTableInA(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} From 4684fe618fa1bc3692e6dc9563b1f25f91e62082 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Tue, 21 Mar 2017 09:51:23 +0100 Subject: [PATCH 05/17] Merged JS and TS generators --- CMakeLists.txt | 1 - src/idl_gen_js.cpp | 474 ++++++++--- src/idl_gen_ts.cpp | 798 ------------------ .../namespace_test2_generated.ts | 1 - 4 files changed, 372 insertions(+), 902 deletions(-) delete mode 100644 src/idl_gen_ts.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 242a1b672ba..affa05b79ec 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,7 +48,6 @@ set(FlatBuffers_Compiler_SRCS src/idl_gen_python.cpp src/idl_gen_fbs.cpp src/idl_gen_grpc.cpp - src/idl_gen_ts.cpp src/flatc.cpp src/flatc_main.cpp grpc/src/compiler/schema_interface.h diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index e1daf0af5a3..2343fc4adea 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -15,6 +15,7 @@ */ // independent from idl_parser, since this code is not needed for most clients +#include #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" @@ -24,8 +25,9 @@ namespace flatbuffers { static std::string GeneratedFileName(const std::string &path, - const std::string &file_name) { - return path + file_name + "_generated.js"; + const std::string &file_name, + bool ts) { + return path + file_name + ((ts) ? ("_generated.ts") : ("_generated.js")); } namespace js { @@ -33,17 +35,25 @@ namespace js { // and tables) and output them to a single file. class JsGenerator : public BaseGenerator { public: + typedef std::unordered_set ImportedFileSet; + JsGenerator(const Parser &parser, const std::string &path, - const std::string &file_name) - : BaseGenerator(parser, path, file_name, "", "."){}; + const std::string &file_name, bool ts) + : BaseGenerator(parser, path, file_name, "", ".") + , ts_(ts) + { + }; // Iterate through all definitions we haven't generate code for (enums, // structs, and tables) and output them to a single file. bool generate() { if (IsEverythingGenerated()) return true; - std::string enum_code, struct_code, exports_code, code; + ImportedFileSet importedFiles; + + std::string enum_code, struct_code, import_code, exports_code, code; generateEnums(&enum_code, &exports_code); - generateStructs(&struct_code, &exports_code); + generateStructs(&struct_code, &exports_code, importedFiles); + generateImportDependencies(&import_code, importedFiles); code = code + "// " + FlatBuffersGeneratedWarning(); @@ -51,18 +61,36 @@ class JsGenerator : public BaseGenerator { GenNamespaces(&code, &exports_code); // Output the main declaration code from above. + if (ts_) { + code += import_code; + } + code += enum_code; code += struct_code; - if (!exports_code.empty() && !parser_.opts.skip_js_exports) { + if (!ts_ && !exports_code.empty() && !parser_.opts.skip_js_exports) { code += "// Exports for Node.js and RequireJS\n"; code += exports_code; } - return SaveFile(GeneratedFileName(path_, file_name_).c_str(), code, false); + return SaveFile(GeneratedFileName(path_, file_name_, ts_).c_str(), code, false); } private: + bool ts_; + + // Generate code for imports + void generateImportDependencies(std::string *code_ptr, const ImportedFileSet &importedFiles) { + std::string &code = *code_ptr; + for (const auto &file : importedFiles) { + const auto basename = + flatbuffers::StripPath(flatbuffers::StripExtension(file)); + if (basename != file_name_) { + code += "import * as "+ GenFileNamespacePrefix(file) + " from \"./" + basename + "_generated\";\n"; + } + } + } + // Generate code for all enums. void generateEnums(std::string *enum_code_ptr, std::string *exports_code_ptr) { @@ -75,14 +103,19 @@ class JsGenerator : public BaseGenerator { // Generate code for all structs. void generateStructs(std::string *decl_code_ptr, - std::string *exports_code_ptr) { + std::string *exports_code_ptr, + ImportedFileSet &importedFiles) { for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end(); ++it) { auto &struct_def = **it; - GenStruct(parser_, struct_def, decl_code_ptr, exports_code_ptr); + GenStruct(parser_, struct_def, decl_code_ptr, exports_code_ptr, importedFiles); } } void GenNamespaces(std::string *code_ptr, std::string *exports_ptr) { + if (ts_ && parser_.opts.skip_flatbuffers_import) { + return; + } + std::set namespaces; for (auto it = parser_.namespaces_.begin(); @@ -110,16 +143,23 @@ class JsGenerator : public BaseGenerator { std::string &exports = *exports_ptr; for (auto it = sorted_namespaces.begin(); it != sorted_namespaces.end(); it++) { - code += "/**\n * @const\n * @namespace\n */\n"; - if (it->find('.') == std::string::npos) { - code += "var "; - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportSymbol('" + *it + "', " + *it + ");\n"; - } else { - exports += "this." + *it + " = " + *it + ";\n"; + if (ts_) { + if (it->find('.') == std::string::npos) { + code += "import { flatbuffers } from \"./flatbuffers\"\n"; + break; } + } else { + code += "/**\n * @const\n * @namespace\n */\n"; + if (it->find('.') == std::string::npos) { + code += "var "; + if(parser_.opts.use_goog_js_export_format) { + exports += "goog.exportSymbol('" + *it + "', " + *it + ");\n"; + } else { + exports += "this." + *it + " = " + *it + ";\n"; + } + } + code += *it + " = " + *it + " || {};\n\n"; } - code += *it + " = " + *it + " || {};\n\n"; } } @@ -174,16 +214,20 @@ void GenEnum(EnumDef &enum_def, std::string *code_ptr, std::string &code = *code_ptr; std::string &exports = *exports_ptr; GenDocComment(enum_def.doc_comment, code_ptr, "@enum"); - if (enum_def.defined_namespace->components.empty()) { - code += "var "; - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportSymbol('" + enum_def.name + "', " + enum_def.name + - ");\n"; - } else { - exports += "this." + enum_def.name + " = " + enum_def.name + ";\n"; + if (ts_) { + code += "export namespace " + GetNameSpace(enum_def) + "{\n" + "export enum " + enum_def.name + "{\n"; + } else { + if (enum_def.defined_namespace->components.empty()) { + code += "var "; + if(parser_.opts.use_goog_js_export_format) { + exports += "goog.exportSymbol('" + enum_def.name + "', " + enum_def.name + + ");\n"; + } else { + exports += "this." + enum_def.name + " = " + enum_def.name + ";\n"; + } } + code += WrapInNameSpace(enum_def) + " = {\n"; } - code += WrapInNameSpace(enum_def) + " = {\n"; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { auto &ev = **it; @@ -193,10 +237,15 @@ void GenEnum(EnumDef &enum_def, std::string *code_ptr, } GenDocComment(ev.doc_comment, code_ptr, "", " "); } - code += " " + ev.name + ": " + NumToString(ev.value); + code += " " + ev.name + ((ts_) ? ("= ") : (": ")) + NumToString(ev.value); code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n"; } - code += "};\n\n"; + + if (ts_) { + code += "}};\n\n"; + } else { + code += "};\n\n"; + } } static std::string GenType(const Type &type) { @@ -244,7 +293,11 @@ std::string GenDefaultValue(const Value &value, const std::string &context) { if (value.type.enum_def) { if (auto val = value.type.enum_def->ReverseLookup( atoi(value.constant.c_str()), false)) { - return WrapInNameSpace(*value.type.enum_def) + "." + val->name; + if (ts_) { + return GenPrefixedTypeName(WrapInNameSpace(*value.type.enum_def), value.type.enum_def->file) + "." + val->name; + } else { + return WrapInNameSpace(*value.type.enum_def) + "." + val->name; + } } else { return "/** @type {" + WrapInNameSpace(*value.type.enum_def) + "} */ (" + value.constant + ")"; @@ -322,6 +375,19 @@ static std::string MaybeScale(T value) { return value != 1 ? " * " + NumToString(value) : ""; } +static std::string GenFileNamespacePrefix(const std::string &file) { + return "NS" + std::to_string(std::hash{}(file)); +} + +// Adds a source-dependent prefix, for of import * statements. +std::string GenPrefixedTypeName(const std::string &typeName, const std::string &file) { + const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(file)); + if (basename == file_name_) { + return typeName; + } + return GenFileNamespacePrefix(file) + "." + typeName; +} + void GenStructArgs(const StructDef &struct_def, std::string *annotations, std::string *arguments, @@ -338,7 +404,12 @@ void GenStructArgs(const StructDef &struct_def, } else { *annotations += "@param {" + GenTypeName(field.value.type, true); *annotations += "} " + nameprefix + field.name + "\n"; - *arguments += ", " + nameprefix + field.name; + + if (ts_) { + *arguments += ", " + nameprefix + field.name + ": " + GenTypeName(field.value.type, true); + } else { + *arguments += ", " + nameprefix + field.name; + } } } } @@ -373,37 +444,58 @@ static void GenStructBody(const StructDef &struct_def, } // Generate an accessor struct with constructor for a flatbuffers struct. -void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_ptr, std::string *exports_ptr) { +void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_ptr, std::string *exports_ptr, + ImportedFileSet &importedFiles) { if (struct_def.generated) return; std::string &code = *code_ptr; std::string &exports = *exports_ptr; + std::string object_name; + // Emit constructor - bool isStatement = struct_def.defined_namespace->components.empty(); - std::string object_name = WrapInNameSpace(struct_def); - GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); - if (isStatement) { - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportSymbol('" + struct_def.name + "', " + - struct_def.name + ");\n"; + if (ts_) { + object_name = struct_def.name; + std::string object_namespace = GetNameSpace(struct_def); + GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); + code += "export namespace " + object_namespace + "{\n"; + code += "export class " + struct_def.name; + code += " {\n"; + code += " /**\n"; + code += " * @type {flatbuffers.ByteBuffer}\n"; + code += " */\n"; + code += " bb: flatbuffers.ByteBuffer= null;\n"; + code += "\n"; + code += " /**\n"; + code += " * @type {number}\n"; + code += " */\n"; + code += " bb_pos:number = 0;\n"; + } else { + bool isStatement = struct_def.defined_namespace->components.empty(); + object_name = WrapInNameSpace(struct_def); + GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); + if (isStatement) { + if(parser_.opts.use_goog_js_export_format) { + exports += "goog.exportSymbol('" + struct_def.name + "', " + + struct_def.name + ");\n"; + } else { + exports += "this." + struct_def.name + " = " + struct_def.name + ";\n"; + } + code += "function " + object_name; } else { - exports += "this." + struct_def.name + " = " + struct_def.name + ";\n"; + code += object_name + " = function"; } - code += "function " + object_name; - } else { - code += object_name + " = function"; + code += "() {\n"; + code += " /**\n"; + code += " * @type {flatbuffers.ByteBuffer}\n"; + code += " */\n"; + code += " this.bb = null;\n"; + code += "\n"; + code += " /**\n"; + code += " * @type {number}\n"; + code += " */\n"; + code += " this.bb_pos = 0;\n"; + code += isStatement ? "}\n\n" : "};\n\n"; } - code += "() {\n"; - code += " /**\n"; - code += " * @type {flatbuffers.ByteBuffer}\n"; - code += " */\n"; - code += " this.bb = null;\n"; - code += "\n"; - code += " /**\n"; - code += " * @type {number}\n"; - code += " */\n"; - code += " this.bb_pos = 0;\n"; - code += isStatement ? "}\n\n" : "};\n\n"; // Generate the __init method that sets the field in a pre-existing // accessor object. This is to allow object reuse. @@ -412,7 +504,13 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt code += " * @param {flatbuffers.ByteBuffer} bb\n"; code += " * @returns {" + object_name + "}\n"; code += " */\n"; - code += object_name + ".prototype.__init = function(i, bb) {\n"; + + if (ts_) { + code += "__init(i:number, bb:flatbuffers.ByteBuffer):" + object_name + " {\n"; + } else { + code += object_name + ".prototype.__init = function(i, bb) {\n"; + } + code += " this.bb_pos = i;\n"; code += " this.bb = bb;\n"; code += " return this;\n"; @@ -425,8 +523,13 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {flatbuffers.ByteBuffer} bb\n" "@param {" + object_name + "=} obj\n" "@returns {" + object_name + "}"); - code += object_name + ".getRootAs" + struct_def.name; - code += " = function(bb, obj) {\n"; + if (ts_) { + code += "static getRootAs" + struct_def.name; + code += "(bb:flatbuffers.ByteBuffer, obj?:" + object_name + "):" + object_name + " {\n"; + } else { + code += object_name + ".getRootAs" + struct_def.name; + code += " = function(bb, obj) {\n"; + } code += " return (obj || new " + object_name; code += ").__init(bb.readInt32(bb.position()) + bb.position(), bb);\n"; code += "};\n\n"; @@ -437,7 +540,12 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, "@param {flatbuffers.ByteBuffer} bb\n" "@returns {boolean}"); - code += object_name + ".bufferHasIdentifier = function(bb) {\n"; + if (ts_) { + code += "static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {\n"; + } else { + code += object_name + ".bufferHasIdentifier = function(bb) {\n"; + } + code += " return bb.__has_identifier('" + parser_.file_identifier_; code += "');\n};\n\n"; } @@ -458,12 +566,29 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt std::string(field.value.type.base_type == BASE_TYPE_STRING ? "@param {flatbuffers.Encoding=} optionalEncoding\n" : "") + "@returns {" + GenTypeName(field.value.type, false) + "}"); - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function("; - if (field.value.type.base_type == BASE_TYPE_STRING) { - code += "optionalEncoding"; + if (ts_) { + std::string prefix = MakeCamel(field.name, false) + "("; + if (field.value.type.base_type == BASE_TYPE_STRING) { + code += prefix + "):string\n"; + code += prefix + "optionalEncoding:flatbuffers.Encoding"+"):" + GenTypeName(field.value.type, false)+"\n"; + code += prefix + "optionalEncoding?:any"; + } else { + code += prefix; + } + if (field.value.type.enum_def) { + code += "):" + GenPrefixedTypeName(GenTypeName(field.value.type, false), field.value.type.enum_def->file) + " {\n"; + } else { + code += "):" + GenTypeName(field.value.type, false) + " {\n"; + } + } else { + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function("; + if (field.value.type.base_type == BASE_TYPE_STRING) { + code += "optionalEncoding"; + } + code += ") {\n"; } - code += ") {\n"; + if (struct_def.fixed) { code += " return " + GenGetter(field.value.type, "(this.bb_pos" + MaybeAdd(field.value.offset) + ")") + ";\n"; @@ -485,8 +610,15 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt auto type = WrapInNameSpace(*field.value.type.struct_def); GenDocComment(field.doc_comment, code_ptr, "@param {" + type + "=} obj\n@returns {" + type + "}"); - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function(obj) {\n"; + if (ts_) { + type = GenPrefixedTypeName(type, field.value.type.struct_def->file); + code += MakeCamel(field.name, false); + code += "(obj?:" + type + "):" + type + " {\n"; + } else { + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function(obj) {\n"; + } + if (struct_def.fixed) { code += " return (obj || new " + type; code += ").__init(this.bb_pos"; @@ -498,6 +630,11 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt : "this.bb.__indirect(this.bb_pos + offset)"; code += ", this.bb) : null;\n"; } + + if (ts_) { + importedFiles.insert(field.value.type.struct_def->file); + } + break; } @@ -515,14 +652,32 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt } GenDocComment(field.doc_comment, code_ptr, args + "@returns {" + vectortypename + "}"); - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function(index"; - if (vectortype.base_type == BASE_TYPE_STRUCT) { - code += ", obj"; - } else if (vectortype.base_type == BASE_TYPE_STRING) { - code += ", optionalEncoding"; + if (ts_) { + std::string prefix = MakeCamel(field.name, false); + prefix += "(index: number"; + if (vectortype.base_type == BASE_TYPE_STRUCT) { + vectortypename = GenPrefixedTypeName(vectortypename, vectortype.struct_def->file); + code += prefix + ", obj?:" + vectortypename; + importedFiles.insert(vectortype.struct_def->file); + } else if (vectortype.base_type == BASE_TYPE_STRING) { + code += prefix + "):string\n"; + code += prefix + ",optionalEncoding:flatbuffers.Encoding" + "):" + vectortypename + "\n"; + code += prefix + ",optionalEncoding?:any"; + } else { + code += prefix; + } + code += "):" + vectortypename + " {\n"; + } else { + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function(index"; + if (vectortype.base_type == BASE_TYPE_STRUCT) { + code += ", obj"; + } else if (vectortype.base_type == BASE_TYPE_STRING) { + code += ", optionalEncoding"; + } + code += ") {\n"; } - code += ") {\n"; + if (vectortype.base_type == BASE_TYPE_STRUCT) { code += offset_prefix + "(obj || new " + vectortypename; code += ").__init("; @@ -561,8 +716,14 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(field.doc_comment, code_ptr, "@param {flatbuffers.Table} obj\n" "@returns {?flatbuffers.Table}"); - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function(obj) {\n"; + if (ts_) { + code += MakeCamel(field.name, false); + code += "(obj:T):T {\n"; + } else { + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function(obj) {\n"; + } + code += offset_prefix + GenGetter(field.value.type, "(obj, this.bb_pos + offset)") + " : null;\n"; break; @@ -585,7 +746,19 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, annotations + "@returns {boolean}"); - code += object_name + ".prototype.mutate_" + field.name + " = function(value) {\n"; + if (ts_) { + std::string type; + if (field.value.type.enum_def) { + type = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); + } else { + type = GenTypeName(field.value.type, true); + } + + code += "mutate_" + field.name + "(value:" + type + "):boolean {\n"; + } else { + code += object_name + ".prototype.mutate_" + field.name + " = function(value) {\n"; + } + code += " var offset = this.bb.__offset(this.bb_pos, " + NumToString(field.value.offset) + ");\n\n"; code += " if (offset === 0) {\n"; code += " return false;\n"; @@ -605,8 +778,14 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt if (field.value.type.base_type == BASE_TYPE_VECTOR) { // Emit a length helper GenDocComment(code_ptr, "@returns {number}"); - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += "Length = function() {\n" + offset_prefix; + if (ts_) { + code += MakeCamel(field.name, false); + code += "Length():number {\n" + offset_prefix; + } else { + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += "Length = function() {\n" + offset_prefix; + } + code += "this.bb.__vector_len(this.bb_pos + offset) : 0;\n};\n\n"; if(parser_.opts.use_goog_js_export_format) { @@ -619,8 +798,15 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt auto vectorType = field.value.type.VectorType(); if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) { GenDocComment(code_ptr, "@returns {" + GenType(vectorType) + "Array}"); - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += "Array = function() {\n" + offset_prefix; + + if (ts_) { + code += MakeCamel(field.name, false); + code += "Array():" + GenType(vectorType) + "Array {\n" + offset_prefix; + } else { + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += "Array = function() {\n" + offset_prefix; + } + code += "new " + GenType(vectorType) + "Array(this.bb.bytes().buffer, " "this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), " "this.bb.__vector_len(this.bb_pos + offset)) : null;\n};\n\n"; @@ -641,16 +827,30 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenStructArgs(struct_def, &annotations, &arguments, ""); GenDocComment(code_ptr, annotations + "@returns {flatbuffers.Offset}"); - code += object_name + ".create" + struct_def.name + " = function(builder"; - code += arguments + ") {\n"; + + if (ts_) { + code += "static create" + struct_def.name + "(builder:flatbuffers.Builder"; + code += arguments + "):flatbuffers.Offset {\n"; + } else { + code += object_name + ".create" + struct_def.name + " = function(builder"; + code += arguments + ") {\n"; + } + GenStructBody(struct_def, &code, ""); code += " return builder.offset();\n};\n\n"; } else { // Generate a method to start building a new object GenDocComment(code_ptr, "@param {flatbuffers.Builder} builder"); - code += object_name + ".start" + struct_def.name; - code += " = function(builder) {\n"; + + if (ts_) { + code += "static start" + struct_def.name; + code += "(builder:flatbuffers.Builder) {\n"; + } else { + code += object_name + ".start" + struct_def.name; + code += " = function(builder) {\n"; + } + code += " builder.startObject(" + NumToString( struct_def.fields.vec.size()) + ");\n"; code += "};\n\n"; @@ -670,8 +870,22 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {flatbuffers.Builder} builder\n" "@param {" + GenTypeName(field.value.type, true) + "} " + argname); - code += object_name + ".add" + MakeCamel(field.name); - code += " = function(builder, " + argname + ") {\n"; + + if (ts_) { + std::string argType; + if (field.value.type.enum_def) { + argType = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); + } else { + argType = GenTypeName(field.value.type, true); + } + + code += "static add" + MakeCamel(field.name); + code += "(builder:flatbuffers.Builder, " + argname + ":" + argType + ") {\n"; + } else { + code += object_name + ".add" + MakeCamel(field.name); + code += " = function(builder, " + argname + ") {\n"; + } + code += " builder.addField" + GenWriteMethod(field.value.type) + "("; code += NumToString(it - struct_def.fields.vec.begin()) + ", "; if (field.value.type.base_type == BASE_TYPE_BOOL) { @@ -700,8 +914,20 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {Array.<" + GenTypeName(vector_type, true) + ">} data\n" "@returns {flatbuffers.Offset}"); - code += object_name + ".create" + MakeCamel(field.name); - code += "Vector = function(builder, data) {\n"; + + if (ts_) { + code += "static create" + MakeCamel(field.name); + std::string type = GenTypeName(vector_type, true) + "[]"; + if (type == "number[]") { + type += " | Uint8Array"; + } + code += "Vector(builder:flatbuffers.Builder, data:" + type+"):flatbuffers.Offset {\n"; + code += "if(!data){\n return null\n}\n"; + } else { + code += object_name + ".create" + MakeCamel(field.name); + code += "Vector = function(builder, data) {\n"; + } + code += " builder.startVector(" + NumToString(elem_size); code += ", data.length, " + NumToString(alignment) + ");\n"; code += " for (var i = data.length - 1; i >= 0; i--) {\n"; @@ -719,8 +945,15 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, "@param {flatbuffers.Builder} builder\n" "@param {number} numElems"); - code += object_name + ".start" + MakeCamel(field.name); - code += "Vector = function(builder, numElems) {\n"; + + if (ts_) { + code += "static start" + MakeCamel(field.name); + code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n"; + } else { + code += object_name + ".start" + MakeCamel(field.name); + code += "Vector = function(builder, numElems) {\n"; + } + code += " builder.startVector(" + NumToString(elem_size); code += ", numElems, " + NumToString(alignment) + ");\n"; code += "};\n\n"; @@ -731,8 +964,15 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, "@param {flatbuffers.Builder} builder\n" "@returns {flatbuffers.Offset}"); - code += object_name + ".end" + struct_def.name; - code += " = function(builder) {\n"; + + if (ts_) { + code += "static end" + struct_def.name; + code += "(builder:flatbuffers.Builder):flatbuffers.Offset {\n"; + } else { + code += object_name + ".end" + struct_def.name; + code += " = function(builder) {\n"; + } + code += " var offset = builder.endObject();\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { @@ -751,8 +991,15 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, "@param {flatbuffers.Builder} builder\n" "@param {flatbuffers.Offset} offset"); - code += object_name + ".finish" + struct_def.name + "Buffer"; - code += " = function(builder, offset) {\n"; + + if (ts_) { + code += "static finish" + struct_def.name + "Buffer"; + code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n"; + } else { + code += object_name + ".finish" + struct_def.name + "Buffer"; + code += " = function(builder, offset) {\n"; + } + code += " builder.finish(offset"; if (!parser_.file_identifier_.empty()) { code += ", '" + parser_.file_identifier_ + "'"; @@ -761,22 +1008,21 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt code += "};\n\n"; } } + + if (ts_) { + code += "}\n}\n"; + } } }; } // namespace js -bool GenerateJS(const Parser &parser, const std::string &path, - const std::string &file_name) { - js::JsGenerator generator(parser, path, file_name); - return generator.generate(); -} - -std::string JSMakeRule(const Parser &parser, - const std::string &path, - const std::string &file_name) { +std::string MakeRule(const Parser &parser, + const std::string &path, + const std::string &file_name, + bool ts) { std::string filebase = flatbuffers::StripPath( flatbuffers::StripExtension(file_name)); - std::string make_rule = GeneratedFileName(path, filebase) + ": "; + std::string make_rule = GeneratedFileName(path, filebase, ts) + ": "; auto included_files = parser.GetIncludedFilesRecursive(file_name); for (auto it = included_files.begin(); it != included_files.end(); ++it) { @@ -785,4 +1031,28 @@ std::string JSMakeRule(const Parser &parser, return make_rule; } +bool GenerateJS(const Parser &parser, const std::string &path, + const std::string &file_name) { + js::JsGenerator generator(parser, path, file_name, false); + return generator.generate(); +} + +std::string JSMakeRule(const Parser &parser, + const std::string &path, + const std::string &file_name) { + return MakeRule(parser, path, file_name, false); +} + +bool GenerateTS(const Parser &parser, const std::string &path, + const std::string &file_name) { + js::JsGenerator generator(parser, path, file_name, true); + return generator.generate(); +} + +std::string TSMakeRule(const Parser &parser, + const std::string &path, + const std::string &file_name) { + return MakeRule(parser, path, file_name, true); +} + } // namespace flatbuffers diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp deleted file mode 100644 index c20e9e9e1b2..00000000000 --- a/src/idl_gen_ts.cpp +++ /dev/null @@ -1,798 +0,0 @@ -/* - * Copyright 2014 Google Inc. All rights reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// independent from idl_parser, since this code is not needed for most clients - -#include - -#include "flatbuffers/flatbuffers.h" -#include "flatbuffers/idl.h" -#include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" - -namespace flatbuffers { - -static std::string GeneratedFileName(const std::string &path, - const std::string &file_name) { - return path + file_name + "_generated.ts"; -} - -namespace ts { -// Iterate through all definitions we haven't generate code for (enums, structs, -// and tables) and output them to a single file. -class TsGenerator : public BaseGenerator { - public: - // maps source to set of imported types - using ImportedFileSet = std::unordered_set; - - TsGenerator(const Parser &parser, const std::string &path, - const std::string &file_name) - : BaseGenerator(parser, path, file_name, "", "."){}; - // Iterate through all definitions we haven't generate code for (enums, - // structs, and tables) and output them to a single file. - bool generate() { - if (IsEverythingGenerated()) return true; - - ImportedFileSet importedFiles; - - std::string import_code, enum_code, struct_code, code; - generateEnums(&enum_code); - generateStructs(&struct_code, importedFiles); - generateImportDependencies(&import_code, importedFiles); - - code = code + "// " + FlatBuffersGeneratedWarning(); - - // Generate code for all the namespace declarations. - GenNamespaces(&code); - - // Output the main declaration code from above. - code += import_code; - code += enum_code; - code += struct_code; - - return SaveFile(GeneratedFileName(path_, file_name_).c_str(), code, false); - } - - private: - // Generate code for imports - void generateImportDependencies(std::string *code_ptr, const ImportedFileSet &importedFiles) { - std::string &code = *code_ptr; - for (const auto &file : importedFiles) { - const auto basename = - flatbuffers::StripPath(flatbuffers::StripExtension(file)); - if (basename != file_name_) { - code += "import * as "+ GenFileNamespacePrefix(file) + " from \"./" + basename + "_generated\";\n"; - } - } - } - - // Generate code for all enums. - void generateEnums(std::string *enum_code_ptr) { - for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); - ++it) { - auto &enum_def = **it; - GenEnum(enum_def, enum_code_ptr); - } - } - - // Generate code for all structs. - void generateStructs(std::string *decl_code_ptr, ImportedFileSet &importedFiles) { - for (auto it = parser_.structs_.vec.begin(); - it != parser_.structs_.vec.end(); ++it) { - auto &struct_def = **it; - GenStruct(parser_, struct_def, decl_code_ptr, importedFiles); - } - } - - void GenNamespaces(std::string *code_ptr) { - std::set namespaces; - - for (auto it = parser_.namespaces_.begin(); - it != parser_.namespaces_.end(); ++it) { - std::string namespace_so_far; - - // Gather all parent namespaces for this namespace - for (auto component = (*it)->components.begin(); - component != (*it)->components.end(); ++component) { - if (!namespace_so_far.empty()) { - namespace_so_far += '.'; - } - namespace_so_far += *component; - namespaces.insert(namespace_so_far); - } - } - - // Make sure parent namespaces come before child namespaces - std::vector sorted_namespaces( - namespaces.begin(), namespaces.end()); - std::sort(sorted_namespaces.begin(), sorted_namespaces.end()); - - // Emit namespaces in a form that Closure Compiler can optimize - std::string &code = *code_ptr; - for (auto it = sorted_namespaces.begin(); - it != sorted_namespaces.end(); it++) { - if (!parser_.opts.skip_flatbuffers_import && it->find('.') == std::string::npos) { - code += "import { flatbuffers } from \"./flatbuffers\"\n"; - } - } -} - -// Generate a documentation comment, if available. -static void GenDocComment(const std::vector &dc, - std::string *code_ptr, - const std::string &extra_lines, - const char *indent = nullptr) { - if (dc.empty() && extra_lines.empty()) { - // Don't output empty comment blocks with 0 lines of comment content. - return; - } - - std::string &code = *code_ptr; - if (indent) code += indent; - code += "/**\n"; - for (auto it = dc.begin(); it != dc.end(); ++it) { - if (indent) code += indent; - code += " *" + *it + "\n"; - } - if (!extra_lines.empty()) { - if (!dc.empty()) { - if (indent) code += indent; - code += " *\n"; - } - if (indent) code += indent; - std::string::size_type start = 0; - for (;;) { - auto end = extra_lines.find('\n', start); - if (end != std::string::npos) { - code += " * " + extra_lines.substr(start, end - start) + "\n"; - start = end + 1; - } else { - code += " * " + extra_lines.substr(start) + "\n"; - break; - } - } - } - if (indent) code += indent; - code += " */\n"; -} - -static void GenDocComment(std::string *code_ptr, - const std::string &extra_lines) { - GenDocComment(std::vector(), code_ptr, extra_lines); -} - -// Generate an enum declaration and an enum string lookup table. -void GenEnum(EnumDef &enum_def, std::string *code_ptr) { - if (enum_def.generated) return; - std::string &code = *code_ptr; - GenDocComment(enum_def.doc_comment, code_ptr, "@enum"); - code += "export namespace " + GetNameSpace(enum_def) + "{\n" + "export enum " + enum_def.name + "{\n"; - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); ++it) { - auto &ev = **it; - if (!ev.doc_comment.empty()) { - if (it != enum_def.vals.vec.begin()) { - code += '\n'; - } - GenDocComment(ev.doc_comment, code_ptr, "", " "); - } - code += " " + ev.name + "= " + NumToString(ev.value); - code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n"; - } - code += "}};\n\n"; -} - -static std::string GenType(const Type &type) { - switch (type.base_type) { - case BASE_TYPE_BOOL: - case BASE_TYPE_CHAR: return "Int8"; - case BASE_TYPE_UTYPE: - case BASE_TYPE_UCHAR: return "Uint8"; - case BASE_TYPE_SHORT: return "Int16"; - case BASE_TYPE_USHORT: return "Uint16"; - case BASE_TYPE_INT: return "Int32"; - case BASE_TYPE_UINT: return "Uint32"; - case BASE_TYPE_LONG: return "Int64"; - case BASE_TYPE_ULONG: return "Uint64"; - case BASE_TYPE_FLOAT: return "Float32"; - case BASE_TYPE_DOUBLE: return "Float64"; - case BASE_TYPE_STRING: return "String"; - case BASE_TYPE_VECTOR: return GenType(type.VectorType()); - case BASE_TYPE_STRUCT: return type.struct_def->name; - default: return "Table"; - } -} - -std::string GenGetter(const Type &type, const std::string &arguments) { - switch (type.base_type) { - case BASE_TYPE_STRING: return "this.bb.__string" + arguments; - case BASE_TYPE_STRUCT: return "this.bb.__struct" + arguments; - case BASE_TYPE_UNION: return "this.bb.__union" + arguments; - case BASE_TYPE_VECTOR: return GenGetter(type.VectorType(), arguments); - default: { - auto getter = "this.bb.read" + MakeCamel(GenType(type)) + arguments; - if (type.base_type == BASE_TYPE_BOOL) { - getter = "!!" + getter; - } - if (type.enum_def) { - getter = "/** @type {" + WrapInNameSpace(*type.enum_def) + "} */ (" + - getter + ")"; - } - return getter; - } - } -} - -std::string GenDefaultValue(const Value &value, const std::string &context) { - if (value.type.enum_def) { - if (auto val = value.type.enum_def->ReverseLookup( - atoi(value.constant.c_str()), false)) { - return GenPrefixedTypeName(WrapInNameSpace(*value.type.enum_def), value.type.enum_def->file) + "." + val->name; - } else { - return "/** @type {" + WrapInNameSpace(*value.type.enum_def) + "} */ (" - + value.constant + ")"; - } - } - - switch (value.type.base_type) { - case BASE_TYPE_BOOL: - return value.constant == "0" ? "false" : "true"; - - case BASE_TYPE_STRING: - return "null"; - - case BASE_TYPE_LONG: - case BASE_TYPE_ULONG: { - int64_t constant = StringToInt(value.constant.c_str()); - return context + ".createLong(" + NumToString((int32_t)constant) + - ", " + NumToString((int32_t)(constant >> 32)) + ")"; - } - - default: - return value.constant; - } -} - -std::string GenTypeName(const Type &type, bool input) { - if (!input) { - if (type.base_type == BASE_TYPE_STRING) { - return "string|Uint8Array"; - } - if (type.base_type == BASE_TYPE_STRUCT) { - return WrapInNameSpace(*type.struct_def); - } - } - - switch (type.base_type) { - case BASE_TYPE_BOOL: return "boolean"; - case BASE_TYPE_LONG: - case BASE_TYPE_ULONG: return "flatbuffers.Long"; - default: - if (IsScalar(type.base_type)) { - if (type.enum_def) { - return WrapInNameSpace(*type.enum_def); - } - return "number"; - } - return "flatbuffers.Offset"; - } -} - -// Returns the method name for use with add/put calls. -static std::string GenWriteMethod(const Type &type) { - // Forward to signed versions since unsigned versions don't exist - switch (type.base_type) { - case BASE_TYPE_UTYPE: - case BASE_TYPE_UCHAR: return GenWriteMethod(Type(BASE_TYPE_CHAR)); - case BASE_TYPE_USHORT: return GenWriteMethod(Type(BASE_TYPE_SHORT)); - case BASE_TYPE_UINT: return GenWriteMethod(Type(BASE_TYPE_INT)); - case BASE_TYPE_ULONG: return GenWriteMethod(Type(BASE_TYPE_LONG)); - default: break; - } - - return IsScalar(type.base_type) - ? MakeCamel(GenType(type)) - : (IsStruct(type) ? "Struct" : "Offset"); -} - -template -static std::string MaybeAdd(T value) { - return value != 0 ? " + " + NumToString(value) : ""; -} - -template -static std::string MaybeScale(T value) { - return value != 1 ? " * " + NumToString(value) : ""; -} - -static std::string GenFileNamespacePrefix(const std::string &file) { - return "NS" + std::to_string(std::hash{}(file)); -} - -// Adds a source-dependent prefix, for of import * statements. -std::string GenPrefixedTypeName(const std::string &typeName, const std::string &file) { - const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(file)); - if (basename == file_name_) { - return typeName; - } - return GenFileNamespacePrefix(file) + "." + typeName; -} - -void GenStructArgs(const StructDef &struct_def, - std::string *annotations, - std::string *arguments, - const std::string &nameprefix) { - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (IsStruct(field.value.type)) { - // Generate arguments for a struct inside a struct. To ensure names - // don't clash, and to make it obvious these arguments are constructing - // a nested struct, prefix the name with the field name. - GenStructArgs(*field.value.type.struct_def, annotations, arguments, - nameprefix + field.name + "_"); - } else { - *annotations += "@param {" + GenTypeName(field.value.type, true); - *annotations += "} " + nameprefix + field.name + "\n"; - *arguments += ", " + nameprefix + field.name + ": " + GenTypeName(field.value.type, true); - } - } -} - -static void GenStructBody(const StructDef &struct_def, - std::string *body, - const std::string &nameprefix) { - *body += " builder.prep("; - *body += NumToString(struct_def.minalign) + ", "; - *body += NumToString(struct_def.bytesize) + ");\n"; - - for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); ++it) { - auto &field = **it; - if (field.padding) { - *body += " builder.pad(" + NumToString(field.padding) + ");\n"; - } - if (IsStruct(field.value.type)) { - // Generate arguments for a struct inside a struct. To ensure names - // don't clash, and to make it obvious these arguments are constructing - // a nested struct, prefix the name with the field name. - GenStructBody(*field.value.type.struct_def, body, - nameprefix + field.name + "_"); - } else { - *body += " builder.write" + GenWriteMethod(field.value.type) + "("; - if (field.value.type.base_type == BASE_TYPE_BOOL) { - *body += "+"; - } - *body += nameprefix + field.name + ");\n"; - } - } -} - -// Generate an accessor struct with constructor for a flatbuffers struct. -void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_ptr, ImportedFileSet &importedFiles) { - if (struct_def.generated) return; - std::string &code = *code_ptr; - - // Emit constructor - std::string object_name = struct_def.name; - std::string object_namespace = GetNameSpace(struct_def); - GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); - code += "export namespace " + object_namespace + "{\n"; - code += "export class " + struct_def.name; - code += " {\n"; - code += " /**\n"; - code += " * @type {flatbuffers.ByteBuffer}\n"; - code += " */\n"; - code += " bb: flatbuffers.ByteBuffer= null;\n"; - code += "\n"; - code += " /**\n"; - code += " * @type {number}\n"; - code += " */\n"; - code += " bb_pos:number = 0;\n"; - - // Generate the __init method that sets the field in a pre-existing - // accessor object. This is to allow object reuse. - code += "/**\n"; - code += " * @param {number} i\n"; - code += " * @param {flatbuffers.ByteBuffer} bb\n"; - code += " * @returns {" + object_name + "}\n"; - code += " */\n"; - code += "__init(i:number, bb:flatbuffers.ByteBuffer):" + object_name + " {\n"; - code += " this.bb_pos = i;\n"; - code += " this.bb = bb;\n"; - code += " return this;\n"; - code += "};\n\n"; - - // Generate a special accessor for the table that when used as the root of a - // FlatBuffer - if (!struct_def.fixed) { - GenDocComment(code_ptr, - "@param {flatbuffers.ByteBuffer} bb\n" - "@param {" + object_name + "=} obj\n" - "@returns {" + object_name + "}"); - code += "static getRootAs" + struct_def.name; - code += "(bb:flatbuffers.ByteBuffer, obj?:" + object_name + "):" + object_name + " {\n"; - code += " return (obj || new " + object_name; - code += ").__init(bb.readInt32(bb.position()) + bb.position(), bb);\n"; - code += "};\n\n"; - - // Generate the identifier check method - if (parser_.root_struct_def_ == &struct_def && - !parser_.file_identifier_.empty()) { - GenDocComment(code_ptr, - "@param {flatbuffers.ByteBuffer} bb\n" - "@returns {boolean}"); - code += "static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {\n"; - code += " return bb.__has_identifier('" + parser_.file_identifier_; - code += "');\n};\n\n"; - } - } - - // Emit field accessors - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; - auto offset_prefix = " var offset = this.bb.__offset(this.bb_pos, " + - NumToString(field.value.offset) + ");\n return offset ? "; - - // Emit a scalar field - if (IsScalar(field.value.type.base_type) || - field.value.type.base_type == BASE_TYPE_STRING) { - GenDocComment(field.doc_comment, code_ptr, - std::string(field.value.type.base_type == BASE_TYPE_STRING ? - "@param {flatbuffers.Encoding=} optionalEncoding\n" : "") + - "@returns {" + GenTypeName(field.value.type, false) + "}"); - std::string prefix = MakeCamel(field.name, false) + "("; - if (field.value.type.base_type == BASE_TYPE_STRING) { - code += prefix + "):string\n"; - code += prefix + "optionalEncoding:flatbuffers.Encoding"+"):" + GenTypeName(field.value.type, false)+"\n"; - code += prefix + "optionalEncoding?:any"; - } else { - code += prefix; - } - if (field.value.type.enum_def) { - code += "):" + GenPrefixedTypeName(GenTypeName(field.value.type, false), field.value.type.enum_def->file) + " {\n"; - } else { - code += "):" + GenTypeName(field.value.type, false) + " {\n"; - } - if (struct_def.fixed) { - code += " return " + GenGetter(field.value.type, "(this.bb_pos" + - MaybeAdd(field.value.offset) + ")") + ";\n"; - } else { - std::string index = "this.bb_pos + offset"; - if (field.value.type.base_type == BASE_TYPE_STRING) { - index += ", optionalEncoding"; - } - code += offset_prefix + GenGetter(field.value.type, - "(" + index + ")") + " : " + GenDefaultValue(field.value, "this.bb"); - code += ";\n"; - } - } - - // Emit an object field - else { - switch (field.value.type.base_type) { - case BASE_TYPE_STRUCT: { - auto type = WrapInNameSpace(*field.value.type.struct_def); - GenDocComment(field.doc_comment, code_ptr, - "@param {" + type + "=} obj\n@returns {" + type + "}"); - type = GenPrefixedTypeName(type, field.value.type.struct_def->file); - code += MakeCamel(field.name, false); - code += "(obj?:" + type + "):" + type + " {\n"; - if (struct_def.fixed) { - code += " return (obj || new " + type; - code += ").__init(this.bb_pos"; - code += MaybeAdd(field.value.offset) + ", this.bb);\n"; - } else { - code += offset_prefix + "(obj || new " + type + ").__init("; - code += field.value.type.struct_def->fixed - ? "this.bb_pos + offset" - : "this.bb.__indirect(this.bb_pos + offset)"; - code += ", this.bb) : null;\n"; - } - importedFiles.insert(field.value.type.struct_def->file); - break; - } - - case BASE_TYPE_VECTOR: { - auto vectortype = field.value.type.VectorType(); - auto vectortypename = GenTypeName(vectortype, false); - auto inline_size = InlineSize(vectortype); - auto index = "this.bb.__vector(this.bb_pos + offset) + index" + - MaybeScale(inline_size); - std::string args = "@param {number} index\n"; - if (vectortype.base_type == BASE_TYPE_STRUCT) { - args += "@param {" + vectortypename + "=} obj\n"; - } else if (vectortype.base_type == BASE_TYPE_STRING) { - args += "@param {flatbuffers.Encoding=} optionalEncoding\n"; - } - GenDocComment(field.doc_comment, code_ptr, args + - "@returns {" + vectortypename + "}"); - std::string prefix = MakeCamel(field.name, false); - prefix += "(index: number"; - if (vectortype.base_type == BASE_TYPE_STRUCT) { - vectortypename = GenPrefixedTypeName(vectortypename, vectortype.struct_def->file); - code += prefix + ", obj?:" + vectortypename; - importedFiles.insert(vectortype.struct_def->file); - } else if (vectortype.base_type == BASE_TYPE_STRING) { - code += prefix + "):string\n"; - code += prefix + ",optionalEncoding:flatbuffers.Encoding" + "):" + vectortypename + "\n"; - code += prefix + ",optionalEncoding?:any"; - } else { - code += prefix; - } - code += "):" + vectortypename + " {\n"; - if (vectortype.base_type == BASE_TYPE_STRUCT) { - code += offset_prefix + "(obj || new " + vectortypename; - code += ").__init("; - code += vectortype.struct_def->fixed - ? index - : "this.bb.__indirect(" + index + ")"; - code += ", this.bb)"; - } else { - if (vectortype.base_type == BASE_TYPE_STRING) { - index += ", optionalEncoding"; - } - code += offset_prefix + GenGetter(vectortype, "(" + index + ")"); - } - code += " : "; - if (field.value.type.element == BASE_TYPE_BOOL) { - code += "false"; - } else if (field.value.type.element == BASE_TYPE_LONG || - field.value.type.element == BASE_TYPE_ULONG) { - code += "this.bb.createLong(0, 0)"; - } else if (IsScalar(field.value.type.element)) { - if (field.value.type.enum_def) { - code += "/** @type {" + - WrapInNameSpace(*field.value.type.enum_def) + "} */ (" + - field.value.constant + ")"; - } else { - code += "0"; - } - } else { - code += "null"; - } - code += ";\n"; - break; - } - - case BASE_TYPE_UNION: - GenDocComment(field.doc_comment, code_ptr, - "@param {flatbuffers.Table} obj\n" - "@returns {?flatbuffers.Table}"); - code += MakeCamel(field.name, false); - code += "(obj:T):T {\n"; - code += offset_prefix + GenGetter(field.value.type, - "(obj, this.bb_pos + offset)") + " : null;\n"; - break; - - default: - assert(0); - } - } - code += "};\n\n"; - - // Adds the mutable scalar value to the output - if (IsScalar(field.value.type.base_type) && parser.opts.mutable_buffer) { - std::string annotations = "@param {" + GenTypeName(field.value.type, true) + "} value\n"; - GenDocComment(code_ptr, annotations + - "@returns {boolean}"); - - std::string type; - if (field.value.type.enum_def) { - type = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); - } else { - type = GenTypeName(field.value.type, true); - } - - code += "mutate_" + field.name + "(value:" + type + "):boolean {\n"; - code += " var offset = this.bb.__offset(this.bb_pos, " + NumToString(field.value.offset) + ");\n\n"; - code += " if (offset === 0) {\n"; - code += " return false;\n"; - code += " }\n\n"; - code += " this.bb.write" + MakeCamel(GenType(field.value.type)) + "(this.bb_pos + offset, value);\n"; - code += " return true;\n"; - code += "};\n\n"; - } - - // Emit vector helpers - if (field.value.type.base_type == BASE_TYPE_VECTOR) { - // Emit a length helper - GenDocComment(code_ptr, "@returns {number}"); - code += MakeCamel(field.name, false); - code += "Length():number {\n" + offset_prefix; - code += "this.bb.__vector_len(this.bb_pos + offset) : 0;\n};\n\n"; - - // For scalar types, emit a typed array helper - auto vectorType = field.value.type.VectorType(); - if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) { - GenDocComment(code_ptr, "@returns {" + GenType(vectorType) + "Array}"); - code += MakeCamel(field.name, false); - code += "Array():" + GenType(vectorType) + "Array {\n" + offset_prefix; - code += "new " + GenType(vectorType) + "Array(this.bb.bytes().buffer, " - "this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), " - "this.bb.__vector_len(this.bb_pos + offset)) : null;\n};\n\n"; - } - } - } - - // Emit a factory constructor - if (struct_def.fixed) { - std::string annotations = "@param {flatbuffers.Builder} builder\n"; - std::string arguments; - GenStructArgs(struct_def, &annotations, &arguments, ""); - GenDocComment(code_ptr, annotations + - "@returns {flatbuffers.Offset}"); - code += "static create" + struct_def.name + "(builder:flatbuffers.Builder"; - code += arguments + "):flatbuffers.Offset {\n"; - GenStructBody(struct_def, &code, ""); - code += " return builder.offset();\n};\n\n"; - } else { - // Generate a method to start building a new object - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder"); - code += "static start" + struct_def.name; - code += "(builder:flatbuffers.Builder) {\n"; - code += " builder.startObject(" + NumToString( - struct_def.fields.vec.size()) + ");\n"; - code += "};\n\n"; - - // Generate a set of static methods that allow table construction - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; - auto argname = MakeCamel(field.name, false); - if (!IsScalar(field.value.type.base_type)) { - argname += "Offset"; - } - - // Generate the field insertion method - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {" + GenTypeName(field.value.type, true) + "} " + - argname); - - std::string argType; - if (field.value.type.enum_def) { - argType = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); - } else { - argType = GenTypeName(field.value.type, true); - } - - code += "static add" + MakeCamel(field.name); - code += "(builder:flatbuffers.Builder, " + argname + ":" + argType + ") {\n"; - code += " builder.addField" + GenWriteMethod(field.value.type) + "("; - code += NumToString(it - struct_def.fields.vec.begin()) + ", "; - if (field.value.type.base_type == BASE_TYPE_BOOL) { - code += "+"; - } - code += argname + ", "; - if (!IsScalar(field.value.type.base_type)) { - code += "0"; - } else { - if (field.value.type.base_type == BASE_TYPE_BOOL) { - code += "+"; - } - code += GenDefaultValue(field.value, "builder"); - } - code += ");\n};\n\n"; - - if (field.value.type.base_type == BASE_TYPE_VECTOR) { - auto vector_type = field.value.type.VectorType(); - auto alignment = InlineAlignment(vector_type); - auto elem_size = InlineSize(vector_type); - - // Generate a method to create a vector from a JavaScript array - if (!IsStruct(vector_type)) { - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {Array.<" + GenTypeName(vector_type, true) + - ">} data\n" - "@returns {flatbuffers.Offset}"); - code += "static create" + MakeCamel(field.name); - std::string type = GenTypeName(vector_type, true) + "[]"; - if (type == "number[]") { - type += " | Uint8Array"; - } - code += "Vector(builder:flatbuffers.Builder, data:" + type+"):flatbuffers.Offset {\n"; - code += "if(!data){\n return null\n}\n"; - 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"; - } - - // Generate a method to start a vector, data to be added manually after - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {number} numElems"); - code += "static start" + MakeCamel(field.name); - code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n"; - code += " builder.startVector(" + NumToString(elem_size); - code += ", numElems, " + NumToString(alignment) + ");\n"; - code += "};\n\n"; - } - } - - // Generate a method to stop building a new object - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@returns {flatbuffers.Offset}"); - code += "static end" + struct_def.name; - code += "(builder:flatbuffers.Builder):flatbuffers.Offset {\n"; - code += " var offset = builder.endObject();\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (!field.deprecated && field.required) { - code += " builder.requiredField(offset, "; - code += NumToString(field.value.offset); - code += "); // " + field.name + "\n"; - } - } - code += " return offset;\n"; - code += "};\n\n"; - - // Generate the method to complete buffer construction - if (parser_.root_struct_def_ == &struct_def) { - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {flatbuffers.Offset} offset"); - code += "static finish" + struct_def.name + "Buffer"; - code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n"; - code += " builder.finish(offset"; - if (!parser_.file_identifier_.empty()) { - code += ", '" + parser_.file_identifier_ + "'"; - } - code += ");\n"; - code += "};\n\n"; - } - } - code += "}\n}\n"; -} -}; -} // namespace ts - -bool GenerateTS(const Parser &parser, const std::string &path, - const std::string &file_name) { - ts::TsGenerator generator(parser, path, file_name); - return generator.generate(); -} - -std::string TSMakeRule(const Parser &parser, - const std::string &path, - const std::string &file_name) { - std::string filebase = flatbuffers::StripPath( - flatbuffers::StripExtension(file_name)); - std::string make_rule = GeneratedFileName(path, filebase) + ": "; - auto included_files = parser.GetIncludedFilesRecursive(file_name); - for (auto it = included_files.begin(); - it != included_files.end(); ++it) { - make_rule += " " + *it; - } - return make_rule; -} - -} // namespace flatbuffers diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index 3d638988695..843e88c5c33 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -1,6 +1,5 @@ // automatically generated by the FlatBuffers compiler, do not modify -import { flatbuffers } from "./flatbuffers" import { flatbuffers } from "./flatbuffers" import * as NS9459827973991502386 from "./namespace_test1_generated"; /** From 2627ba0ee200fcd2afc345ee8886eb22b3e34229 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Tue, 21 Mar 2017 10:01:15 +0100 Subject: [PATCH 06/17] Fixed AppVeyor build problems --- src/idl_gen_js.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index 2343fc4adea..66c8576a397 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -82,7 +82,8 @@ class JsGenerator : public BaseGenerator { // Generate code for imports void generateImportDependencies(std::string *code_ptr, const ImportedFileSet &importedFiles) { std::string &code = *code_ptr; - for (const auto &file : importedFiles) { + for (auto it = importedFiles.begin(); it != importedFiles.end(); ++it) { + const auto &file = *it; const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(file)); if (basename != file_name_) { From 8be41c491c58395281b2cc97a4c3e4993440f99b Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Tue, 21 Mar 2017 10:06:46 +0100 Subject: [PATCH 07/17] Fixed more AppVeyor build problems --- src/idl_gen_js.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index 66c8576a397..b6ab7b12fef 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -377,7 +377,7 @@ static std::string MaybeScale(T value) { } static std::string GenFileNamespacePrefix(const std::string &file) { - return "NS" + std::to_string(std::hash{}(file)); + return "NS" + std::to_string(std::hash()(file)); } // Adds a source-dependent prefix, for of import * statements. From 14b0986ccf2fcd6226ce8c50729761723b3160c2 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Tue, 21 Mar 2017 10:15:32 +0100 Subject: [PATCH 08/17] Fixed more AppVeyor build problems --- src/idl_gen_js.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index b6ab7b12fef..77352a337ba 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -377,7 +377,7 @@ static std::string MaybeScale(T value) { } static std::string GenFileNamespacePrefix(const std::string &file) { - return "NS" + std::to_string(std::hash()(file)); + return "NS" + std::to_string(static_cast(std::hash()(file))); } // Adds a source-dependent prefix, for of import * statements. From 00825db948f1ffb5f3f318b9cad701b5f18de443 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Mon, 27 Mar 2017 08:17:15 +0200 Subject: [PATCH 09/17] Changed TS flag to options struct --- include/flatbuffers/idl.h | 17 +--- src/flatc_main.cpp | 4 +- src/idl_gen_js.cpp | 165 ++++++++++++++++++++------------------ 3 files changed, 92 insertions(+), 94 deletions(-) diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index b8cf636513d..5d67f332c56 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -653,20 +653,13 @@ extern bool GenerateCPP(const Parser &parser, const std::string &path, const std::string &file_name); -// Generate JavaScript code from the definitions in the Parser object. +// Generate JavaScript or TypeScript code from the definitions in the Parser object. // See idl_gen_js. extern std::string GenerateJS(const Parser &parser); extern bool GenerateJS(const Parser &parser, const std::string &path, const std::string &file_name); -// Generate TypeScript code from the definitions in the Parser object. -// See idl_gen_ts. -extern std::string GenerateTS(const Parser &parser); -extern bool GenerateTS(const Parser &parser, - const std::string &path, - const std::string &file_name); - // Generate Go files from the definitions in the Parser object. // See idl_gen_go.cpp. extern bool GenerateGo(const Parser &parser, @@ -711,18 +704,12 @@ extern bool GenerateFBS(const Parser &parser, const std::string &path, const std::string &file_name); -// Generate a make rule for the generated JavaScript code. +// Generate a make rule for the generated JavaScript or TypeScript code. // See idl_gen_js.cpp. extern std::string JSMakeRule(const Parser &parser, const std::string &path, const std::string &file_name); -// Generate a make rule for the generated TypeScript code. -// See idl_gen_ts.cpp. -extern std::string TSMakeRule(const Parser &parser, - const std::string &path, - const std::string &file_name); - // Generate a make rule for the generated C++ header. // See idl_gen_cpp.cpp. extern std::string CPPMakeRule(const Parser &parser, diff --git a/src/flatc_main.cpp b/src/flatc_main.cpp index deb368f51f5..d838bac8996 100644 --- a/src/flatc_main.cpp +++ b/src/flatc_main.cpp @@ -76,11 +76,11 @@ int main(int argc, const char *argv[]) { flatbuffers::IDLOptions::kJs, "Generate JavaScript code for tables/structs", flatbuffers::JSMakeRule }, - { flatbuffers::GenerateTS, "-T", "--ts", "TypeScript", + { flatbuffers::GenerateJS, "-T", "--ts", "TypeScript", nullptr, flatbuffers::IDLOptions::kTs, "Generate TypeScript code for tables/structs", - flatbuffers::TSMakeRule }, + flatbuffers::JSMakeRule }, { flatbuffers::GenerateGeneral, "-n", "--csharp", "C#", nullptr, flatbuffers::IDLOptions::kCSharp, diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index 77352a337ba..7d0b11cf649 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -16,6 +16,7 @@ // independent from idl_parser, since this code is not needed for most clients #include +#include #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" @@ -24,10 +25,37 @@ namespace flatbuffers { +const std::string kGeneratedFileNamePostfix = "_generated"; + +struct JsLanguageParameters { + IDLOptions::Language language; + std::string file_extension; +}; + +const JsLanguageParameters& GetJsLangParams(IDLOptions::Language lang) { + static JsLanguageParameters js_language_parameters[] = { + { + IDLOptions::kJs, + ".js", + }, + { + IDLOptions::kTs, + ".ts", + }, + }; + + if (lang == IDLOptions::kJs) { + return js_language_parameters[0]; + } else { + assert(lang == IDLOptions::kTs); + return js_language_parameters[1]; + } +} + static std::string GeneratedFileName(const std::string &path, const std::string &file_name, - bool ts) { - return path + file_name + ((ts) ? ("_generated.ts") : ("_generated.js")); + const JsLanguageParameters &lang) { + return path + file_name + kGeneratedFileNamePostfix + lang.file_extension; } namespace js { @@ -35,12 +63,12 @@ namespace js { // and tables) and output them to a single file. class JsGenerator : public BaseGenerator { public: - typedef std::unordered_set ImportedFileSet; + typedef std::unordered_set imported_fileset; JsGenerator(const Parser &parser, const std::string &path, - const std::string &file_name, bool ts) - : BaseGenerator(parser, path, file_name, "", ".") - , ts_(ts) + const std::string &file_name) + : BaseGenerator(parser, path, file_name, "", "."), + lang_(GetJsLangParams(parser_.opts.lang)) { }; // Iterate through all definitions we haven't generate code for (enums, @@ -48,12 +76,12 @@ class JsGenerator : public BaseGenerator { bool generate() { if (IsEverythingGenerated()) return true; - ImportedFileSet importedFiles; + imported_fileset imported_files; std::string enum_code, struct_code, import_code, exports_code, code; generateEnums(&enum_code, &exports_code); - generateStructs(&struct_code, &exports_code, importedFiles); - generateImportDependencies(&import_code, importedFiles); + generateStructs(&struct_code, &exports_code, imported_files); + generateImportDependencies(&import_code, imported_files); code = code + "// " + FlatBuffersGeneratedWarning(); @@ -61,33 +89,31 @@ class JsGenerator : public BaseGenerator { GenNamespaces(&code, &exports_code); // Output the main declaration code from above. - if (ts_) { - code += import_code; - } + code += import_code; code += enum_code; code += struct_code; - if (!ts_ && !exports_code.empty() && !parser_.opts.skip_js_exports) { + if (lang_.language == IDLOptions::kJs && !exports_code.empty() && !parser_.opts.skip_js_exports) { code += "// Exports for Node.js and RequireJS\n"; code += exports_code; } - return SaveFile(GeneratedFileName(path_, file_name_, ts_).c_str(), code, false); + return SaveFile(GeneratedFileName(path_, file_name_, lang_).c_str(), code, false); } private: - bool ts_; + const JsLanguageParameters& lang_; // Generate code for imports - void generateImportDependencies(std::string *code_ptr, const ImportedFileSet &importedFiles) { + void generateImportDependencies(std::string *code_ptr, const imported_fileset &imported_files) { std::string &code = *code_ptr; - for (auto it = importedFiles.begin(); it != importedFiles.end(); ++it) { + for (auto it = imported_files.begin(); it != imported_files.end(); ++it) { const auto &file = *it; const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(file)); if (basename != file_name_) { - code += "import * as "+ GenFileNamespacePrefix(file) + " from \"./" + basename + "_generated\";\n"; + code += "import * as "+ GenFileNamespacePrefix(file) + " from \"./" + basename + kGeneratedFileNamePostfix + "\";\n"; } } } @@ -105,15 +131,15 @@ class JsGenerator : public BaseGenerator { // Generate code for all structs. void generateStructs(std::string *decl_code_ptr, std::string *exports_code_ptr, - ImportedFileSet &importedFiles) { + imported_fileset &imported_files) { for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end(); ++it) { auto &struct_def = **it; - GenStruct(parser_, struct_def, decl_code_ptr, exports_code_ptr, importedFiles); + GenStruct(parser_, struct_def, decl_code_ptr, exports_code_ptr, imported_files); } } void GenNamespaces(std::string *code_ptr, std::string *exports_ptr) { - if (ts_ && parser_.opts.skip_flatbuffers_import) { + if (lang_.language == IDLOptions::kTs && parser_.opts.skip_flatbuffers_import) { return; } @@ -144,7 +170,7 @@ class JsGenerator : public BaseGenerator { std::string &exports = *exports_ptr; for (auto it = sorted_namespaces.begin(); it != sorted_namespaces.end(); it++) { - if (ts_) { + if (lang_.language == IDLOptions::kTs) { if (it->find('.') == std::string::npos) { code += "import { flatbuffers } from \"./flatbuffers\"\n"; break; @@ -215,7 +241,7 @@ void GenEnum(EnumDef &enum_def, std::string *code_ptr, std::string &code = *code_ptr; std::string &exports = *exports_ptr; GenDocComment(enum_def.doc_comment, code_ptr, "@enum"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "export namespace " + GetNameSpace(enum_def) + "{\n" + "export enum " + enum_def.name + "{\n"; } else { if (enum_def.defined_namespace->components.empty()) { @@ -238,11 +264,11 @@ void GenEnum(EnumDef &enum_def, std::string *code_ptr, } GenDocComment(ev.doc_comment, code_ptr, "", " "); } - code += " " + ev.name + ((ts_) ? ("= ") : (": ")) + NumToString(ev.value); + code += " " + ev.name + ((lang_.language == IDLOptions::kTs) ? ("= ") : (": ")) + NumToString(ev.value); code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n"; } - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "}};\n\n"; } else { code += "};\n\n"; @@ -294,7 +320,7 @@ std::string GenDefaultValue(const Value &value, const std::string &context) { if (value.type.enum_def) { if (auto val = value.type.enum_def->ReverseLookup( atoi(value.constant.c_str()), false)) { - if (ts_) { + if (lang_.language == IDLOptions::kTs) { return GenPrefixedTypeName(WrapInNameSpace(*value.type.enum_def), value.type.enum_def->file) + "." + val->name; } else { return WrapInNameSpace(*value.type.enum_def) + "." + val->name; @@ -406,7 +432,7 @@ void GenStructArgs(const StructDef &struct_def, *annotations += "@param {" + GenTypeName(field.value.type, true); *annotations += "} " + nameprefix + field.name + "\n"; - if (ts_) { + if (lang_.language == IDLOptions::kTs) { *arguments += ", " + nameprefix + field.name + ": " + GenTypeName(field.value.type, true); } else { *arguments += ", " + nameprefix + field.name; @@ -446,7 +472,7 @@ static void GenStructBody(const StructDef &struct_def, // Generate an accessor struct with constructor for a flatbuffers struct. void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_ptr, std::string *exports_ptr, - ImportedFileSet &importedFiles) { + imported_fileset &imported_files) { if (struct_def.generated) return; std::string &code = *code_ptr; std::string &exports = *exports_ptr; @@ -454,7 +480,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt std::string object_name; // Emit constructor - if (ts_) { + if (lang_.language == IDLOptions::kTs) { object_name = struct_def.name; std::string object_namespace = GetNameSpace(struct_def); GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); @@ -506,7 +532,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt code += " * @returns {" + object_name + "}\n"; code += " */\n"; - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "__init(i:number, bb:flatbuffers.ByteBuffer):" + object_name + " {\n"; } else { code += object_name + ".prototype.__init = function(i, bb) {\n"; @@ -524,7 +550,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {flatbuffers.ByteBuffer} bb\n" "@param {" + object_name + "=} obj\n" "@returns {" + object_name + "}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static getRootAs" + struct_def.name; code += "(bb:flatbuffers.ByteBuffer, obj?:" + object_name + "):" + object_name + " {\n"; } else { @@ -541,7 +567,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, "@param {flatbuffers.ByteBuffer} bb\n" "@returns {boolean}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {\n"; } else { code += object_name + ".bufferHasIdentifier = function(bb) {\n"; @@ -567,7 +593,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt std::string(field.value.type.base_type == BASE_TYPE_STRING ? "@param {flatbuffers.Encoding=} optionalEncoding\n" : "") + "@returns {" + GenTypeName(field.value.type, false) + "}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { std::string prefix = MakeCamel(field.name, false) + "("; if (field.value.type.base_type == BASE_TYPE_STRING) { code += prefix + "):string\n"; @@ -611,7 +637,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt auto type = WrapInNameSpace(*field.value.type.struct_def); GenDocComment(field.doc_comment, code_ptr, "@param {" + type + "=} obj\n@returns {" + type + "}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { type = GenPrefixedTypeName(type, field.value.type.struct_def->file); code += MakeCamel(field.name, false); code += "(obj?:" + type + "):" + type + " {\n"; @@ -632,8 +658,8 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt code += ", this.bb) : null;\n"; } - if (ts_) { - importedFiles.insert(field.value.type.struct_def->file); + if (lang_.language == IDLOptions::kTs) { + imported_files.insert(field.value.type.struct_def->file); } break; @@ -653,13 +679,13 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt } GenDocComment(field.doc_comment, code_ptr, args + "@returns {" + vectortypename + "}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { std::string prefix = MakeCamel(field.name, false); prefix += "(index: number"; if (vectortype.base_type == BASE_TYPE_STRUCT) { vectortypename = GenPrefixedTypeName(vectortypename, vectortype.struct_def->file); code += prefix + ", obj?:" + vectortypename; - importedFiles.insert(vectortype.struct_def->file); + imported_files.insert(vectortype.struct_def->file); } else if (vectortype.base_type == BASE_TYPE_STRING) { code += prefix + "):string\n"; code += prefix + ",optionalEncoding:flatbuffers.Encoding" + "):" + vectortypename + "\n"; @@ -717,7 +743,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(field.doc_comment, code_ptr, "@param {flatbuffers.Table} obj\n" "@returns {?flatbuffers.Table}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += MakeCamel(field.name, false); code += "(obj:T):T {\n"; } else { @@ -747,7 +773,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, annotations + "@returns {boolean}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { std::string type; if (field.value.type.enum_def) { type = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); @@ -779,7 +805,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt if (field.value.type.base_type == BASE_TYPE_VECTOR) { // Emit a length helper GenDocComment(code_ptr, "@returns {number}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += MakeCamel(field.name, false); code += "Length():number {\n" + offset_prefix; } else { @@ -800,7 +826,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) { GenDocComment(code_ptr, "@returns {" + GenType(vectorType) + "Array}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += MakeCamel(field.name, false); code += "Array():" + GenType(vectorType) + "Array {\n" + offset_prefix; } else { @@ -829,7 +855,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, annotations + "@returns {flatbuffers.Offset}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static create" + struct_def.name + "(builder:flatbuffers.Builder"; code += arguments + "):flatbuffers.Offset {\n"; } else { @@ -844,7 +870,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt GenDocComment(code_ptr, "@param {flatbuffers.Builder} builder"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static start" + struct_def.name; code += "(builder:flatbuffers.Builder) {\n"; } else { @@ -872,7 +898,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {" + GenTypeName(field.value.type, true) + "} " + argname); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { std::string argType; if (field.value.type.enum_def) { argType = GenPrefixedTypeName(GenTypeName(field.value.type, true), field.value.type.enum_def->file); @@ -916,7 +942,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt ">} data\n" "@returns {flatbuffers.Offset}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static create" + MakeCamel(field.name); std::string type = GenTypeName(vector_type, true) + "[]"; if (type == "number[]") { @@ -947,7 +973,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {flatbuffers.Builder} builder\n" "@param {number} numElems"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static start" + MakeCamel(field.name); code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n"; } else { @@ -966,7 +992,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {flatbuffers.Builder} builder\n" "@returns {flatbuffers.Offset}"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static end" + struct_def.name; code += "(builder:flatbuffers.Builder):flatbuffers.Offset {\n"; } else { @@ -993,7 +1019,7 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt "@param {flatbuffers.Builder} builder\n" "@param {flatbuffers.Offset} offset"); - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "static finish" + struct_def.name + "Buffer"; code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n"; } else { @@ -1010,50 +1036,35 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt } } - if (ts_) { + if (lang_.language == IDLOptions::kTs) { code += "}\n}\n"; } } }; } // namespace js -std::string MakeRule(const Parser &parser, - const std::string &path, - const std::string &file_name, - bool ts) { - std::string filebase = flatbuffers::StripPath( - flatbuffers::StripExtension(file_name)); - std::string make_rule = GeneratedFileName(path, filebase, ts) + ": "; - auto included_files = parser.GetIncludedFilesRecursive(file_name); - for (auto it = included_files.begin(); - it != included_files.end(); ++it) { - make_rule += " " + *it; - } - return make_rule; -} - bool GenerateJS(const Parser &parser, const std::string &path, const std::string &file_name) { - js::JsGenerator generator(parser, path, file_name, false); + js::JsGenerator generator(parser, path, file_name); return generator.generate(); } std::string JSMakeRule(const Parser &parser, const std::string &path, const std::string &file_name) { - return MakeRule(parser, path, file_name, false); -} + assert(parser.opts.lang <= IDLOptions::kMAX); + const auto &lang = GetJsLangParams(parser.opts.lang); -bool GenerateTS(const Parser &parser, const std::string &path, - const std::string &file_name) { - js::JsGenerator generator(parser, path, file_name, true); - return generator.generate(); -} + std::string filebase = flatbuffers::StripPath( + flatbuffers::StripExtension(file_name)); + std::string make_rule = GeneratedFileName(path, filebase, lang) + ": "; -std::string TSMakeRule(const Parser &parser, - const std::string &path, - const std::string &file_name) { - return MakeRule(parser, path, file_name, true); + auto included_files = parser.GetIncludedFilesRecursive(file_name); + for (auto it = included_files.begin(); + it != included_files.end(); ++it) { + make_rule += " " + *it; + } +return make_rule; } } // namespace flatbuffers From 65d1a315eb0c580c8cf3127a1a4d57fb64351438 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Mon, 27 Mar 2017 08:35:37 +0200 Subject: [PATCH 10/17] Storing options by value --- src/idl_gen_js.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index 7d0b11cf649..8d4213f0e6f 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -103,7 +103,7 @@ class JsGenerator : public BaseGenerator { } private: - const JsLanguageParameters& lang_; + const JsLanguageParameters lang_; // Generate code for imports void generateImportDependencies(std::string *code_ptr, const imported_fileset &imported_files) { From 8755370d05ec982e38570d2bc4d099bc39f63f87 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Mon, 27 Mar 2017 08:44:08 +0200 Subject: [PATCH 11/17] Removed unneeded const --- src/idl_gen_js.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index 8d4213f0e6f..9d4fa5772d0 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -103,7 +103,7 @@ class JsGenerator : public BaseGenerator { } private: - const JsLanguageParameters lang_; + JsLanguageParameters lang_; // Generate code for imports void generateImportDependencies(std::string *code_ptr, const imported_fileset &imported_files) { From 0fa4373bfb3e6313079a0eaa4444264619156c2e Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Thu, 30 Mar 2017 09:01:40 +0200 Subject: [PATCH 12/17] Re-export support for unions --- include/flatbuffers/idl.h | 2 + src/flatc.cpp | 3 + src/idl_gen_js.cpp | 60 ++++++++- tests/monster_test_generated.ts | 120 +++++++++++++++++- .../namespace_test2_generated.ts | 1 + 5 files changed, 180 insertions(+), 6 deletions(-) diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 5d67f332c56..9978d34ec83 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -360,6 +360,7 @@ struct IDLOptions { bool binary_schema_comments; bool skip_flatbuffers_import; std::string go_namespace; + bool reexport_ts_modules; // Possible options for the more general generator below. enum Language { @@ -403,6 +404,7 @@ struct IDLOptions { allow_non_utf8(false), binary_schema_comments(false), skip_flatbuffers_import(false), + reexport_ts_modules(true), lang(IDLOptions::kJava), lang_to_generate(0) {} }; diff --git a/src/flatc.cpp b/src/flatc.cpp index 8670f96334e..7e324eb14f7 100644 --- a/src/flatc.cpp +++ b/src/flatc.cpp @@ -104,6 +104,7 @@ std::string FlatCompiler::GetUsageString(const char* program_name) const { " --include-prefix Prefix this path to any generated include statements.\n" " PATH\n" " --no-fb-import Don't include flatbuffers import statement for TypeScript.\n" + " --no-ts-reexport Don't re-export imported dependencies for TypeScript.\n" "FILEs may be schemas, or JSON files (conforming to preceding schema)\n" "FILEs after the -- must be binary flatbuffer format files.\n" "Output files are named using the base file name of the input,\n" @@ -219,6 +220,8 @@ int FlatCompiler::Compile(int argc, const char** argv) { opts.binary_schema_comments = true; } else if(arg == "--no-fb-import") { opts.skip_flatbuffers_import = true; + } else if(arg == "--no-ts-reexport") { + opts.reexport_ts_modules = false; } else { for (size_t i = 0; i < params_.num_generators; ++i) { if (arg == params_.generators[i].generator_opt_long || diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index 9d4fa5772d0..7798610b8e2 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -16,6 +16,7 @@ // independent from idl_parser, since this code is not needed for most clients #include +#include #include #include "flatbuffers/flatbuffers.h" @@ -32,6 +33,12 @@ struct JsLanguageParameters { std::string file_extension; }; +struct ReexportDescription { + std::string symbol; + std::string source_namespace; + std::string target_namespace; +}; + const JsLanguageParameters& GetJsLangParams(IDLOptions::Language lang) { static JsLanguageParameters js_language_parameters[] = { { @@ -64,6 +71,7 @@ namespace js { class JsGenerator : public BaseGenerator { public: typedef std::unordered_set imported_fileset; + typedef std::unordered_multimap reexport_map; JsGenerator(const Parser &parser, const std::string &path, const std::string &file_name) @@ -77,11 +85,13 @@ class JsGenerator : public BaseGenerator { if (IsEverythingGenerated()) return true; imported_fileset imported_files; + reexport_map reexports; std::string enum_code, struct_code, import_code, exports_code, code; - generateEnums(&enum_code, &exports_code); + generateEnums(&enum_code, &exports_code, reexports); generateStructs(&struct_code, &exports_code, imported_files); generateImportDependencies(&import_code, imported_files); + generateReexports(&import_code, reexports, imported_files); code = code + "// " + FlatBuffersGeneratedWarning(); @@ -113,18 +123,48 @@ class JsGenerator : public BaseGenerator { const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(file)); if (basename != file_name_) { - code += "import * as "+ GenFileNamespacePrefix(file) + " from \"./" + basename + kGeneratedFileNamePostfix + "\";\n"; + const auto file_name = basename + kGeneratedFileNamePostfix; + code += GenPrefixedImport(file, file_name); } } } + // Generate reexports, which might not have been explicitly imported using the "export import" trick + void generateReexports(std::string *code_ptr, + const reexport_map &reexports, + imported_fileset imported_files) { + if (!parser_.opts.reexport_ts_modules || lang_.language != IDLOptions::kTs) { + return; + } + + std::string &code = *code_ptr; + for (auto it = reexports.begin(); it != reexports.end(); ++it) { + const auto &file = *it; + const auto basename = + flatbuffers::StripPath(flatbuffers::StripExtension(file.first)); + if (basename != file_name_) { + const auto file_name = basename + kGeneratedFileNamePostfix; + + if (imported_files.find(file.first) == imported_files.end()) { + code += GenPrefixedImport(file.first, file_name); + imported_files.emplace(file.first); + } + + code += "export namespace " + file.second.target_namespace + " { \n"; + code += "export import " + file.second.symbol + " = "; + code += GenFileNamespacePrefix(file.first) + "." + file.second.source_namespace + "." + file.second.symbol + "; }\n"; + } + } + } + // Generate code for all enums. void generateEnums(std::string *enum_code_ptr, - std::string *exports_code_ptr) { + std::string *exports_code_ptr, + reexport_map &reexports) { for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); ++it) { auto &enum_def = **it; - GenEnum(enum_def, enum_code_ptr, exports_code_ptr); + GenEnum(enum_def, enum_code_ptr, exports_code_ptr, reexports); } } @@ -236,7 +276,7 @@ static void GenDocComment(std::string *code_ptr, // Generate an enum declaration and an enum string lookup table. void GenEnum(EnumDef &enum_def, std::string *code_ptr, - std::string *exports_ptr) { + std::string *exports_ptr, reexport_map &reexports) { if (enum_def.generated) return; std::string &code = *code_ptr; std::string &exports = *exports_ptr; @@ -266,6 +306,11 @@ void GenEnum(EnumDef &enum_def, std::string *code_ptr, } code += " " + ev.name + ((lang_.language == IDLOptions::kTs) ? ("= ") : (": ")) + NumToString(ev.value); code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n"; + + if (ev.struct_def) { + ReexportDescription desc = { ev.name, GetNameSpace(*ev.struct_def), GetNameSpace(enum_def) }; + reexports.insert(std::make_pair(ev.struct_def->file, std::move(desc))); + } } if (lang_.language == IDLOptions::kTs) { @@ -406,6 +451,11 @@ static std::string GenFileNamespacePrefix(const std::string &file) { return "NS" + std::to_string(static_cast(std::hash()(file))); } +static std::string GenPrefixedImport(const std::string &full_file_name, + const std::string &base_file_name) { + return "import * as "+ GenFileNamespacePrefix(full_file_name) + " from \"./" + base_file_name + "\";\n"; +} + // Adds a source-dependent prefix, for of import * statements. std::string GenPrefixedTypeName(const std::string &typeName, const std::string &file) { const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(file)); diff --git a/tests/monster_test_generated.ts b/tests/monster_test_generated.ts index 525db782996..564334d479c 100644 --- a/tests/monster_test_generated.ts +++ b/tests/monster_test_generated.ts @@ -413,6 +413,90 @@ static createVec3(builder:flatbuffers.Builder, x: number, y: number, z: number, return builder.offset(); }; +} +} +/** + * @constructor + */ +export namespace MyGame.Example{ +export class Ability { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer= null; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Ability} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):Ability { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +id():number { + return this.bb.readUint32(this.bb_pos); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_id(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 0); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +distance():number { + return this.bb.readUint32(this.bb_pos + 4); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_distance(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} id + * @param {number} distance + * @returns {flatbuffers.Offset} + */ +static createAbility(builder:flatbuffers.Builder, id: number, distance: number):flatbuffers.Offset { + builder.prep(4, 8); + builder.writeInt32(distance); + builder.writeInt32(id); + return builder.offset(); +}; + } } /** @@ -1161,11 +1245,29 @@ testarrayofstring2Length():number { return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; +/** + * @param {number} index + * @param {MyGame.Example.Ability=} obj + * @returns {MyGame.Example.Ability} + */ +testarrayofsortedstruct(index: number, obj?:MyGame.Example.Ability):MyGame.Example.Ability { + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? (obj || new MyGame.Example.Ability).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; +}; + +/** + * @returns {number} + */ +testarrayofsortedstructLength():number { + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + /** * @param {flatbuffers.Builder} builder */ static startMonster(builder:flatbuffers.Builder) { - builder.startObject(29); + builder.startObject(30); }; /** @@ -1544,6 +1646,22 @@ static startTestarrayofstring2Vector(builder:flatbuffers.Builder, numElems:numbe builder.startVector(4, numElems, 4); }; +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofsortedstructOffset + */ +static addTestarrayofsortedstruct(builder:flatbuffers.Builder, testarrayofsortedstructOffset:flatbuffers.Offset) { + builder.addFieldOffset(29, testarrayofsortedstructOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startTestarrayofsortedstructVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(8, numElems, 4); +}; + /** * @param {flatbuffers.Builder} builder * @returns {flatbuffers.Offset} diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index 843e88c5c33..babf8adca45 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -2,6 +2,7 @@ import { flatbuffers } from "./flatbuffers" import * as NS9459827973991502386 from "./namespace_test1_generated"; +export * from "./namespace_test1_generated"; /** * @constructor */ From e04992489baa2433cd81e4b5ae019a750f864d27 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Tue, 4 Apr 2017 14:30:04 +0200 Subject: [PATCH 13/17] Uint support --- js/flatbuffers.js | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/js/flatbuffers.js b/js/flatbuffers.js index 2e34e98b997..ccbd362ab32 100644 --- a/js/flatbuffers.js +++ b/js/flatbuffers.js @@ -967,6 +967,15 @@ flatbuffers.ByteBuffer.prototype.writeInt16 = function(offset, value) { this.bytes_[offset + 1] = value >> 8; }; +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeUint16 = function(offset, value) { + this.bytes_[offset] = value; + this.bytes_[offset + 1] = value >> 8; +}; + /** * @param {number} offset * @param {number} value @@ -978,6 +987,17 @@ flatbuffers.ByteBuffer.prototype.writeInt32 = function(offset, value) { this.bytes_[offset + 3] = value >> 24; }; +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeUint32 = function(offset, value) { + this.bytes_[offset] = value; + this.bytes_[offset + 1] = value >> 8; + this.bytes_[offset + 2] = value >> 16; + this.bytes_[offset + 3] = value >> 24; +}; + /** * @param {number} offset * @param {flatbuffers.Long} value @@ -987,6 +1007,15 @@ flatbuffers.ByteBuffer.prototype.writeInt64 = function(offset, value) { this.writeInt32(offset + 4, value.high); }; +/** + * @param {number} offset + * @param {flatbuffers.Long} value + */ +flatbuffers.ByteBuffer.prototype.writeUint64 = function(offset, value) { + this.writeUint32(offset, value.low); + this.writeUint32(offset + 4, value.high); +}; + /** * @param {number} offset * @param {number} value From 08697cf6fd01a5ae203ee9f215b65e99cc002a7f Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Tue, 4 Apr 2017 14:31:07 +0200 Subject: [PATCH 14/17] Casting bools to numbers for mutation --- src/idl_gen_js.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index 7798610b8e2..e39387e66e2 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -840,7 +840,14 @@ void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_pt code += " if (offset === 0) {\n"; code += " return false;\n"; code += " }\n\n"; - code += " this.bb.write" + MakeCamel(GenType(field.value.type)) + "(this.bb_pos + offset, value);\n"; + + // special case for bools, which are treated as uint8 + code += " this.bb.write" + MakeCamel(GenType(field.value.type)) + "(this.bb_pos + offset, "; + if (field.value.type.base_type == BASE_TYPE_BOOL && lang_.language == IDLOptions::kTs) { + code += "+"; + } + + code += "value);\n"; code += " return true;\n"; code += "};\n\n"; From 35cb7161fed15311293bc69383c557aabe5667d3 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Tue, 4 Apr 2017 14:31:49 +0200 Subject: [PATCH 15/17] TS shell tests --- .gitignore | 1 + tests/TypeScriptTest.sh | 22 + tests/monster_test_generated.js | 3269 +++++++++++++++---------------- tests/monster_test_generated.ts | 3 +- 4 files changed, 1649 insertions(+), 1646 deletions(-) create mode 100755 tests/TypeScriptTest.sh diff --git a/.gitignore b/.gitignore index 729e5a119e6..c6c3067a3e9 100755 --- a/.gitignore +++ b/.gitignore @@ -70,3 +70,4 @@ Testing/Temporary .settings/ .project net/**/obj +node_modules/ diff --git a/tests/TypeScriptTest.sh b/tests/TypeScriptTest.sh new file mode 100755 index 00000000000..8576c7312ba --- /dev/null +++ b/tests/TypeScriptTest.sh @@ -0,0 +1,22 @@ +#!/bin/sh +# +# Copyright 2016 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +pushd "$(dirname $0)" >/dev/null +../flatc --ts --no-fb-import --gen-mutable monster_test.fbs unicode_test.json +npm install @types/flatbuffers +tsc monster_test_generated.ts +npm uninstall @types/flatbuffers +node JavaScriptTest diff --git a/tests/monster_test_generated.js b/tests/monster_test_generated.js index 7b0165c5543..88c3d130d40 100644 --- a/tests/monster_test_generated.js +++ b/tests/monster_test_generated.js @@ -1,1674 +1,1655 @@ // automatically generated by the FlatBuffers compiler, do not modify - -/** - * @const - * @namespace - */ -var MyGame = MyGame || {}; - -/** - * @const - * @namespace - */ -MyGame.Example = MyGame.Example || {}; - -/** - * @const - * @namespace - */ -MyGame.Example2 = MyGame.Example2 || {}; - -/** - * @const - * @namespace - */ -MyGame.OtherNameSpace = MyGame.OtherNameSpace || {}; - +"use strict"; +exports.__esModule = true; /** * @enum */ -MyGame.Example.Color = { - Red: 1, - Green: 2, - Blue: 8 -}; - +var MyGame; +(function (MyGame) { + var Example; + (function (Example) { + var Color; + (function (Color) { + Color[Color["Red"] = 1] = "Red"; + Color[Color["Green"] = 2] = "Green"; + Color[Color["Blue"] = 8] = "Blue"; + })(Color = Example.Color || (Example.Color = {})); + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); +; /** * @enum */ -MyGame.Example.Any = { - NONE: 0, - Monster: 1, - TestSimpleTableWithEnum: 2, - MyGame_Example2_Monster: 3 -}; - +(function (MyGame) { + var Example; + (function (Example) { + var Any; + (function (Any) { + Any[Any["NONE"] = 0] = "NONE"; + Any[Any["Monster"] = 1] = "Monster"; + Any[Any["TestSimpleTableWithEnum"] = 2] = "TestSimpleTableWithEnum"; + Any[Any["MyGame_Example2_Monster"] = 3] = "MyGame_Example2_Monster"; + })(Any = Example.Any || (Example.Any = {})); + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); +; /** * @constructor */ -MyGame.Example2.Monster = function() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - - /** - * @type {number} - */ - this.bb_pos = 0; -}; - -/** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {MyGame.Example2.Monster} - */ -MyGame.Example2.Monster.prototype.__init = function(i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; -}; - -/** - * @param {flatbuffers.ByteBuffer} bb - * @param {MyGame.Example2.Monster=} obj - * @returns {MyGame.Example2.Monster} - */ -MyGame.Example2.Monster.getRootAsMonster = function(bb, obj) { - return (obj || new MyGame.Example2.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); -}; - -/** - * @param {flatbuffers.Builder} builder - */ -MyGame.Example2.Monster.startMonster = function(builder) { - builder.startObject(0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ -MyGame.Example2.Monster.endMonster = function(builder) { - var offset = builder.endObject(); - return offset; -}; - +(function (MyGame) { + var Example2; + (function (Example2) { + var Monster = (function () { + function Monster() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + /** + * @type {number} + */ + this.bb_pos = 0; + } + /** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Monster} + */ + Monster.prototype.__init = function (i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + }; + ; + /** + * @param {flatbuffers.ByteBuffer} bb + * @param {Monster=} obj + * @returns {Monster} + */ + Monster.getRootAsMonster = function (bb, obj) { + return (obj || new Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); + }; + ; + /** + * @param {flatbuffers.Builder} builder + */ + Monster.startMonster = function (builder) { + builder.startObject(0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ + Monster.endMonster = function (builder) { + var offset = builder.endObject(); + return offset; + }; + ; + return Monster; + }()); + Example2.Monster = Monster; + })(Example2 = MyGame.Example2 || (MyGame.Example2 = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); /** * @constructor */ -MyGame.Example.Test = function() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - - /** - * @type {number} - */ - this.bb_pos = 0; -}; - -/** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {MyGame.Example.Test} - */ -MyGame.Example.Test.prototype.__init = function(i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; -}; - -/** - * @returns {number} - */ -MyGame.Example.Test.prototype.a = function() { - return this.bb.readInt16(this.bb_pos); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Test.prototype.mutate_a = function(value) { - var offset = this.bb.__offset(this.bb_pos, 0); - - if (offset === 0) { - return false; - } - - this.bb.writeInt16(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Test.prototype.b = function() { - return this.bb.readInt8(this.bb_pos + 2); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Test.prototype.mutate_b = function(value) { - var offset = this.bb.__offset(this.bb_pos, 2); - - if (offset === 0) { - return false; - } - - this.bb.writeInt8(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} a - * @param {number} b - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Test.createTest = function(builder, a, b) { - builder.prep(2, 4); - builder.pad(1); - builder.writeInt8(b); - builder.writeInt16(a); - return builder.offset(); -}; - +(function (MyGame) { + var Example; + (function (Example) { + var Test = (function () { + function Test() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + /** + * @type {number} + */ + this.bb_pos = 0; + } + /** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Test} + */ + Test.prototype.__init = function (i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + }; + ; + /** + * @returns {number} + */ + Test.prototype.a = function () { + return this.bb.readInt16(this.bb_pos); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Test.prototype.mutate_a = function (value) { + var offset = this.bb.__offset(this.bb_pos, 0); + if (offset === 0) { + return false; + } + this.bb.writeInt16(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Test.prototype.b = function () { + return this.bb.readInt8(this.bb_pos + 2); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Test.prototype.mutate_b = function (value) { + var offset = this.bb.__offset(this.bb_pos, 2); + if (offset === 0) { + return false; + } + this.bb.writeInt8(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} a + * @param {number} b + * @returns {flatbuffers.Offset} + */ + Test.createTest = function (builder, a, b) { + builder.prep(2, 4); + builder.pad(1); + builder.writeInt8(b); + builder.writeInt16(a); + return builder.offset(); + }; + ; + return Test; + }()); + Example.Test = Test; + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); /** * @constructor */ -MyGame.Example.TestSimpleTableWithEnum = function() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - - /** - * @type {number} - */ - this.bb_pos = 0; -}; - -/** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {MyGame.Example.TestSimpleTableWithEnum} - */ -MyGame.Example.TestSimpleTableWithEnum.prototype.__init = function(i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; -}; - -/** - * @param {flatbuffers.ByteBuffer} bb - * @param {MyGame.Example.TestSimpleTableWithEnum=} obj - * @returns {MyGame.Example.TestSimpleTableWithEnum} - */ -MyGame.Example.TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum = function(bb, obj) { - return (obj || new MyGame.Example.TestSimpleTableWithEnum).__init(bb.readInt32(bb.position()) + bb.position(), bb); -}; - -/** - * @returns {MyGame.Example.Color} - */ -MyGame.Example.TestSimpleTableWithEnum.prototype.color = function() { - var offset = this.bb.__offset(this.bb_pos, 4); - return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Green; -}; - -/** - * @param {MyGame.Example.Color} value - * @returns {boolean} - */ -MyGame.Example.TestSimpleTableWithEnum.prototype.mutate_color = function(value) { - var offset = this.bb.__offset(this.bb_pos, 4); - - if (offset === 0) { - return false; - } - - this.bb.writeInt8(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {flatbuffers.Builder} builder - */ -MyGame.Example.TestSimpleTableWithEnum.startTestSimpleTableWithEnum = function(builder) { - builder.startObject(1); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {MyGame.Example.Color} color - */ -MyGame.Example.TestSimpleTableWithEnum.addColor = function(builder, color) { - builder.addFieldInt8(0, color, MyGame.Example.Color.Green); -}; - -/** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ -MyGame.Example.TestSimpleTableWithEnum.endTestSimpleTableWithEnum = function(builder) { - var offset = builder.endObject(); - return offset; -}; - +(function (MyGame) { + var Example; + (function (Example) { + var TestSimpleTableWithEnum = (function () { + function TestSimpleTableWithEnum() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + /** + * @type {number} + */ + this.bb_pos = 0; + } + /** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {TestSimpleTableWithEnum} + */ + TestSimpleTableWithEnum.prototype.__init = function (i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + }; + ; + /** + * @param {flatbuffers.ByteBuffer} bb + * @param {TestSimpleTableWithEnum=} obj + * @returns {TestSimpleTableWithEnum} + */ + TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum = function (bb, obj) { + return (obj || new TestSimpleTableWithEnum).__init(bb.readInt32(bb.position()) + bb.position(), bb); + }; + ; + /** + * @returns {MyGame.Example.Color} + */ + TestSimpleTableWithEnum.prototype.color = function () { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Green; + }; + ; + /** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ + TestSimpleTableWithEnum.prototype.mutate_color = function (value) { + var offset = this.bb.__offset(this.bb_pos, 4); + if (offset === 0) { + return false; + } + this.bb.writeInt8(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @param {flatbuffers.Builder} builder + */ + TestSimpleTableWithEnum.startTestSimpleTableWithEnum = function (builder) { + builder.startObject(1); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Color} color + */ + TestSimpleTableWithEnum.addColor = function (builder, color) { + builder.addFieldInt8(0, color, MyGame.Example.Color.Green); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ + TestSimpleTableWithEnum.endTestSimpleTableWithEnum = function (builder) { + var offset = builder.endObject(); + return offset; + }; + ; + return TestSimpleTableWithEnum; + }()); + Example.TestSimpleTableWithEnum = TestSimpleTableWithEnum; + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); /** * @constructor */ -MyGame.Example.Vec3 = function() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - - /** - * @type {number} - */ - this.bb_pos = 0; -}; - -/** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {MyGame.Example.Vec3} - */ -MyGame.Example.Vec3.prototype.__init = function(i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; -}; - -/** - * @returns {number} - */ -MyGame.Example.Vec3.prototype.x = function() { - return this.bb.readFloat32(this.bb_pos); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Vec3.prototype.mutate_x = function(value) { - var offset = this.bb.__offset(this.bb_pos, 0); - - if (offset === 0) { - return false; - } - - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Vec3.prototype.y = function() { - return this.bb.readFloat32(this.bb_pos + 4); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Vec3.prototype.mutate_y = function(value) { - var offset = this.bb.__offset(this.bb_pos, 4); - - if (offset === 0) { - return false; - } - - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Vec3.prototype.z = function() { - return this.bb.readFloat32(this.bb_pos + 8); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Vec3.prototype.mutate_z = function(value) { - var offset = this.bb.__offset(this.bb_pos, 8); - - if (offset === 0) { - return false; - } - - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Vec3.prototype.test1 = function() { - return this.bb.readFloat64(this.bb_pos + 16); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Vec3.prototype.mutate_test1 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 16); - - if (offset === 0) { - return false; - } - - this.bb.writeFloat64(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {MyGame.Example.Color} - */ -MyGame.Example.Vec3.prototype.test2 = function() { - return /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + 24)); -}; - -/** - * @param {MyGame.Example.Color} value - * @returns {boolean} - */ -MyGame.Example.Vec3.prototype.mutate_test2 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 24); - - if (offset === 0) { - return false; - } - - this.bb.writeInt8(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {MyGame.Example.Test=} obj - * @returns {MyGame.Example.Test} - */ -MyGame.Example.Vec3.prototype.test3 = function(obj) { - return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} x - * @param {number} y - * @param {number} z - * @param {number} test1 - * @param {MyGame.Example.Color} test2 - * @param {number} test3_a - * @param {number} test3_b - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Vec3.createVec3 = function(builder, x, y, z, test1, test2, test3_a, test3_b) { - builder.prep(16, 32); - builder.pad(2); - builder.prep(2, 4); - builder.pad(1); - builder.writeInt8(test3_b); - builder.writeInt16(test3_a); - builder.pad(1); - builder.writeInt8(test2); - builder.writeFloat64(test1); - builder.pad(4); - builder.writeFloat32(z); - builder.writeFloat32(y); - builder.writeFloat32(x); - return builder.offset(); -}; - +(function (MyGame) { + var Example; + (function (Example) { + var Vec3 = (function () { + function Vec3() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + /** + * @type {number} + */ + this.bb_pos = 0; + } + /** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Vec3} + */ + Vec3.prototype.__init = function (i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + }; + ; + /** + * @returns {number} + */ + Vec3.prototype.x = function () { + return this.bb.readFloat32(this.bb_pos); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Vec3.prototype.mutate_x = function (value) { + var offset = this.bb.__offset(this.bb_pos, 0); + if (offset === 0) { + return false; + } + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Vec3.prototype.y = function () { + return this.bb.readFloat32(this.bb_pos + 4); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Vec3.prototype.mutate_y = function (value) { + var offset = this.bb.__offset(this.bb_pos, 4); + if (offset === 0) { + return false; + } + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Vec3.prototype.z = function () { + return this.bb.readFloat32(this.bb_pos + 8); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Vec3.prototype.mutate_z = function (value) { + var offset = this.bb.__offset(this.bb_pos, 8); + if (offset === 0) { + return false; + } + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Vec3.prototype.test1 = function () { + return this.bb.readFloat64(this.bb_pos + 16); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Vec3.prototype.mutate_test1 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 16); + if (offset === 0) { + return false; + } + this.bb.writeFloat64(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {MyGame.Example.Color} + */ + Vec3.prototype.test2 = function () { + return (this.bb.readInt8(this.bb_pos + 24)); + }; + ; + /** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ + Vec3.prototype.mutate_test2 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 24); + if (offset === 0) { + return false; + } + this.bb.writeInt8(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @param {MyGame.Example.Test=} obj + * @returns {MyGame.Example.Test} + */ + Vec3.prototype.test3 = function (obj) { + return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} x + * @param {number} y + * @param {number} z + * @param {number} test1 + * @param {MyGame.Example.Color} test2 + * @param {number} test3_a + * @param {number} test3_b + * @returns {flatbuffers.Offset} + */ + Vec3.createVec3 = function (builder, x, y, z, test1, test2, test3_a, test3_b) { + builder.prep(16, 32); + builder.pad(2); + builder.prep(2, 4); + builder.pad(1); + builder.writeInt8(test3_b); + builder.writeInt16(test3_a); + builder.pad(1); + builder.writeInt8(test2); + builder.writeFloat64(test1); + builder.pad(4); + builder.writeFloat32(z); + builder.writeFloat32(y); + builder.writeFloat32(x); + return builder.offset(); + }; + ; + return Vec3; + }()); + Example.Vec3 = Vec3; + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); /** * @constructor */ -MyGame.Example.Ability = function() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - - /** - * @type {number} - */ - this.bb_pos = 0; -}; - -/** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {MyGame.Example.Ability} - */ -MyGame.Example.Ability.prototype.__init = function(i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; -}; - -/** - * @returns {number} - */ -MyGame.Example.Ability.prototype.id = function() { - return this.bb.readUint32(this.bb_pos); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Ability.prototype.mutate_id = function(value) { - var offset = this.bb.__offset(this.bb_pos, 0); - - if (offset === 0) { - return false; - } - - this.bb.writeUint32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Ability.prototype.distance = function() { - return this.bb.readUint32(this.bb_pos + 4); -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Ability.prototype.mutate_distance = function(value) { - var offset = this.bb.__offset(this.bb_pos, 4); - - if (offset === 0) { - return false; - } - - this.bb.writeUint32(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} id - * @param {number} distance - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Ability.createAbility = function(builder, id, distance) { - builder.prep(4, 8); - builder.writeInt32(distance); - builder.writeInt32(id); - return builder.offset(); -}; - +(function (MyGame) { + var Example; + (function (Example) { + var Ability = (function () { + function Ability() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + /** + * @type {number} + */ + this.bb_pos = 0; + } + /** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Ability} + */ + Ability.prototype.__init = function (i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + }; + ; + /** + * @returns {number} + */ + Ability.prototype.id = function () { + return this.bb.readUint32(this.bb_pos); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Ability.prototype.mutate_id = function (value) { + var offset = this.bb.__offset(this.bb_pos, 0); + if (offset === 0) { + return false; + } + this.bb.writeUint32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Ability.prototype.distance = function () { + return this.bb.readUint32(this.bb_pos + 4); + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Ability.prototype.mutate_distance = function (value) { + var offset = this.bb.__offset(this.bb_pos, 4); + if (offset === 0) { + return false; + } + this.bb.writeUint32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} id + * @param {number} distance + * @returns {flatbuffers.Offset} + */ + Ability.createAbility = function (builder, id, distance) { + builder.prep(4, 8); + builder.writeInt32(distance); + builder.writeInt32(id); + return builder.offset(); + }; + ; + return Ability; + }()); + Example.Ability = Ability; + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); /** * @constructor */ -MyGame.Example.Stat = function() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - - /** - * @type {number} - */ - this.bb_pos = 0; -}; - -/** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {MyGame.Example.Stat} - */ -MyGame.Example.Stat.prototype.__init = function(i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; -}; - -/** - * @param {flatbuffers.ByteBuffer} bb - * @param {MyGame.Example.Stat=} obj - * @returns {MyGame.Example.Stat} - */ -MyGame.Example.Stat.getRootAsStat = function(bb, obj) { - return (obj || new MyGame.Example.Stat).__init(bb.readInt32(bb.position()) + bb.position(), bb); -}; - -/** - * @param {flatbuffers.Encoding=} optionalEncoding - * @returns {string|Uint8Array} - */ -MyGame.Example.Stat.prototype.id = function(optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 4); - return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; -}; - -/** - * @returns {flatbuffers.Long} - */ -MyGame.Example.Stat.prototype.val = function() { - var offset = this.bb.__offset(this.bb_pos, 6); - return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); -}; - -/** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ -MyGame.Example.Stat.prototype.mutate_val = function(value) { - var offset = this.bb.__offset(this.bb_pos, 6); - - if (offset === 0) { - return false; - } - - this.bb.writeInt64(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Stat.prototype.count = function() { - var offset = this.bb.__offset(this.bb_pos, 8); - return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Stat.prototype.mutate_count = function(value) { - var offset = this.bb.__offset(this.bb_pos, 8); - - if (offset === 0) { - return false; - } - - this.bb.writeUint16(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {flatbuffers.Builder} builder - */ -MyGame.Example.Stat.startStat = function(builder) { - builder.startObject(3); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} idOffset - */ -MyGame.Example.Stat.addId = function(builder, idOffset) { - builder.addFieldOffset(0, idOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} val - */ -MyGame.Example.Stat.addVal = function(builder, val) { - builder.addFieldInt64(1, val, builder.createLong(0, 0)); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} count - */ -MyGame.Example.Stat.addCount = function(builder, count) { - builder.addFieldInt16(2, count, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Stat.endStat = function(builder) { - var offset = builder.endObject(); - return offset; -}; - +(function (MyGame) { + var Example; + (function (Example) { + var Stat = (function () { + function Stat() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + /** + * @type {number} + */ + this.bb_pos = 0; + } + /** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Stat} + */ + Stat.prototype.__init = function (i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + }; + ; + /** + * @param {flatbuffers.ByteBuffer} bb + * @param {Stat=} obj + * @returns {Stat} + */ + Stat.getRootAsStat = function (bb, obj) { + return (obj || new Stat).__init(bb.readInt32(bb.position()) + bb.position(), bb); + }; + ; + Stat.prototype.id = function (optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; + }; + ; + /** + * @returns {flatbuffers.Long} + */ + Stat.prototype.val = function () { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); + }; + ; + /** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ + Stat.prototype.mutate_val = function (value) { + var offset = this.bb.__offset(this.bb_pos, 6); + if (offset === 0) { + return false; + } + this.bb.writeInt64(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Stat.prototype.count = function () { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Stat.prototype.mutate_count = function (value) { + var offset = this.bb.__offset(this.bb_pos, 8); + if (offset === 0) { + return false; + } + this.bb.writeUint16(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @param {flatbuffers.Builder} builder + */ + Stat.startStat = function (builder) { + builder.startObject(3); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} idOffset + */ + Stat.addId = function (builder, idOffset) { + builder.addFieldOffset(0, idOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} val + */ + Stat.addVal = function (builder, val) { + builder.addFieldInt64(1, val, builder.createLong(0, 0)); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} count + */ + Stat.addCount = function (builder, count) { + builder.addFieldInt16(2, count, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ + Stat.endStat = function (builder) { + var offset = builder.endObject(); + return offset; + }; + ; + return Stat; + }()); + Example.Stat = Stat; + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); /** * an example documentation comment: monster object * * @constructor */ -MyGame.Example.Monster = function() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - - /** - * @type {number} - */ - this.bb_pos = 0; -}; - -/** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {MyGame.Example.Monster} - */ -MyGame.Example.Monster.prototype.__init = function(i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; -}; - -/** - * @param {flatbuffers.ByteBuffer} bb - * @param {MyGame.Example.Monster=} obj - * @returns {MyGame.Example.Monster} - */ -MyGame.Example.Monster.getRootAsMonster = function(bb, obj) { - return (obj || new MyGame.Example.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); -}; - -/** - * @param {flatbuffers.ByteBuffer} bb - * @returns {boolean} - */ -MyGame.Example.Monster.bufferHasIdentifier = function(bb) { - return bb.__has_identifier('MONS'); -}; - -/** - * @param {MyGame.Example.Vec3=} obj - * @returns {MyGame.Example.Vec3} - */ -MyGame.Example.Monster.prototype.pos = function(obj) { - var offset = this.bb.__offset(this.bb_pos, 4); - return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb) : null; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.mana = function() { - var offset = this.bb.__offset(this.bb_pos, 6); - return offset ? this.bb.readInt16(this.bb_pos + offset) : 150; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_mana = function(value) { - var offset = this.bb.__offset(this.bb_pos, 6); - - if (offset === 0) { - return false; - } - - this.bb.writeInt16(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.hp = function() { - var offset = this.bb.__offset(this.bb_pos, 8); - return offset ? this.bb.readInt16(this.bb_pos + offset) : 100; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_hp = function(value) { - var offset = this.bb.__offset(this.bb_pos, 8); - - if (offset === 0) { - return false; - } - - this.bb.writeInt16(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {flatbuffers.Encoding=} optionalEncoding - * @returns {string|Uint8Array} - */ -MyGame.Example.Monster.prototype.name = function(optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 10); - return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; -}; - -/** - * @param {number} index - * @returns {number} - */ -MyGame.Example.Monster.prototype.inventory = function(index) { - var offset = this.bb.__offset(this.bb_pos, 14); - return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.inventoryLength = function() { - var offset = this.bb.__offset(this.bb_pos, 14); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * @returns {Uint8Array} - */ -MyGame.Example.Monster.prototype.inventoryArray = function() { - var offset = this.bb.__offset(this.bb_pos, 14); - return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; -}; - -/** - * @returns {MyGame.Example.Color} - */ -MyGame.Example.Monster.prototype.color = function() { - var offset = this.bb.__offset(this.bb_pos, 16); - return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Blue; -}; - -/** - * @param {MyGame.Example.Color} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_color = function(value) { - var offset = this.bb.__offset(this.bb_pos, 16); - - if (offset === 0) { - return false; - } - - this.bb.writeInt8(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {MyGame.Example.Any} - */ -MyGame.Example.Monster.prototype.testType = function() { - var offset = this.bb.__offset(this.bb_pos, 18); - return offset ? /** @type {MyGame.Example.Any} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE; -}; - -/** - * @param {MyGame.Example.Any} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_test_type = function(value) { - var offset = this.bb.__offset(this.bb_pos, 18); - - if (offset === 0) { - return false; - } - - this.bb.writeUint8(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {flatbuffers.Table} obj - * @returns {?flatbuffers.Table} - */ -MyGame.Example.Monster.prototype.test = function(obj) { - var offset = this.bb.__offset(this.bb_pos, 20); - return offset ? this.bb.__union(obj, this.bb_pos + offset) : null; -}; - -/** - * @param {number} index - * @param {MyGame.Example.Test=} obj - * @returns {MyGame.Example.Test} - */ -MyGame.Example.Monster.prototype.test4 = function(index, obj) { - var offset = this.bb.__offset(this.bb_pos, 22); - return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.test4Length = function() { - var offset = this.bb.__offset(this.bb_pos, 22); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * @param {number} index - * @param {flatbuffers.Encoding=} optionalEncoding - * @returns {string|Uint8Array} - */ -MyGame.Example.Monster.prototype.testarrayofstring = function(index, optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 24); - return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testarrayofstringLength = function() { - var offset = this.bb.__offset(this.bb_pos, 24); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * an example documentation comment: this will end up in the generated code - * multiline too - * - * @param {number} index - * @param {MyGame.Example.Monster=} obj - * @returns {MyGame.Example.Monster} - */ -MyGame.Example.Monster.prototype.testarrayoftables = function(index, obj) { - var offset = this.bb.__offset(this.bb_pos, 26); - return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testarrayoftablesLength = function() { - var offset = this.bb.__offset(this.bb_pos, 26); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * @param {MyGame.Example.Monster=} obj - * @returns {MyGame.Example.Monster} - */ -MyGame.Example.Monster.prototype.enemy = function(obj) { - var offset = this.bb.__offset(this.bb_pos, 28); - return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; -}; - -/** - * @param {number} index - * @returns {number} - */ -MyGame.Example.Monster.prototype.testnestedflatbuffer = function(index) { - var offset = this.bb.__offset(this.bb_pos, 30); - return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testnestedflatbufferLength = function() { - var offset = this.bb.__offset(this.bb_pos, 30); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * @returns {Uint8Array} - */ -MyGame.Example.Monster.prototype.testnestedflatbufferArray = function() { - var offset = this.bb.__offset(this.bb_pos, 30); - return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; -}; - -/** - * @param {MyGame.Example.Stat=} obj - * @returns {MyGame.Example.Stat} - */ -MyGame.Example.Monster.prototype.testempty = function(obj) { - var offset = this.bb.__offset(this.bb_pos, 32); - return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; -}; - -/** - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.testbool = function() { - var offset = this.bb.__offset(this.bb_pos, 34); - return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; -}; - -/** - * @param {boolean} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testbool = function(value) { - var offset = this.bb.__offset(this.bb_pos, 34); - - if (offset === 0) { - return false; - } - - this.bb.writeInt8(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testhashs32Fnv1 = function() { - var offset = this.bb.__offset(this.bb_pos, 36); - return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashs32_fnv1 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 36); - - if (offset === 0) { - return false; - } - - this.bb.writeInt32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testhashu32Fnv1 = function() { - var offset = this.bb.__offset(this.bb_pos, 38); - return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashu32_fnv1 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 38); - - if (offset === 0) { - return false; - } - - this.bb.writeUint32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {flatbuffers.Long} - */ -MyGame.Example.Monster.prototype.testhashs64Fnv1 = function() { - var offset = this.bb.__offset(this.bb_pos, 40); - return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); -}; - -/** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashs64_fnv1 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 40); - - if (offset === 0) { - return false; - } - - this.bb.writeInt64(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {flatbuffers.Long} - */ -MyGame.Example.Monster.prototype.testhashu64Fnv1 = function() { - var offset = this.bb.__offset(this.bb_pos, 42); - return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); -}; - -/** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashu64_fnv1 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 42); - - if (offset === 0) { - return false; - } - - this.bb.writeUint64(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testhashs32Fnv1a = function() { - var offset = this.bb.__offset(this.bb_pos, 44); - return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashs32_fnv1a = function(value) { - var offset = this.bb.__offset(this.bb_pos, 44); - - if (offset === 0) { - return false; - } - - this.bb.writeInt32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testhashu32Fnv1a = function() { - var offset = this.bb.__offset(this.bb_pos, 46); - return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashu32_fnv1a = function(value) { - var offset = this.bb.__offset(this.bb_pos, 46); - - if (offset === 0) { - return false; - } - - this.bb.writeUint32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {flatbuffers.Long} - */ -MyGame.Example.Monster.prototype.testhashs64Fnv1a = function() { - var offset = this.bb.__offset(this.bb_pos, 48); - return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); -}; - -/** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashs64_fnv1a = function(value) { - var offset = this.bb.__offset(this.bb_pos, 48); - - if (offset === 0) { - return false; - } - - this.bb.writeInt64(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {flatbuffers.Long} - */ -MyGame.Example.Monster.prototype.testhashu64Fnv1a = function() { - var offset = this.bb.__offset(this.bb_pos, 50); - return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); -}; - -/** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testhashu64_fnv1a = function(value) { - var offset = this.bb.__offset(this.bb_pos, 50); - - if (offset === 0) { - return false; - } - - this.bb.writeUint64(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {number} index - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.testarrayofbools = function(index) { - var offset = this.bb.__offset(this.bb_pos, 52); - return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testarrayofboolsLength = function() { - var offset = this.bb.__offset(this.bb_pos, 52); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * @returns {Int8Array} - */ -MyGame.Example.Monster.prototype.testarrayofboolsArray = function() { - var offset = this.bb.__offset(this.bb_pos, 52); - return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testf = function() { - var offset = this.bb.__offset(this.bb_pos, 54); - return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.14159; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testf = function(value) { - var offset = this.bb.__offset(this.bb_pos, 54); - - if (offset === 0) { - return false; - } - - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testf2 = function() { - var offset = this.bb.__offset(this.bb_pos, 56); - return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.0; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testf2 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 56); - - if (offset === 0) { - return false; - } - - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testf3 = function() { - var offset = this.bb.__offset(this.bb_pos, 58); - return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; -}; - -/** - * @param {number} value - * @returns {boolean} - */ -MyGame.Example.Monster.prototype.mutate_testf3 = function(value) { - var offset = this.bb.__offset(this.bb_pos, 58); - - if (offset === 0) { - return false; - } - - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; -}; - -/** - * @param {number} index - * @param {flatbuffers.Encoding=} optionalEncoding - * @returns {string|Uint8Array} - */ -MyGame.Example.Monster.prototype.testarrayofstring2 = function(index, optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 60); - return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testarrayofstring2Length = function() { - var offset = this.bb.__offset(this.bb_pos, 60); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * @param {number} index - * @param {MyGame.Example.Ability=} obj - * @returns {MyGame.Example.Ability} - */ -MyGame.Example.Monster.prototype.testarrayofsortedstruct = function(index, obj) { - var offset = this.bb.__offset(this.bb_pos, 62); - return offset ? (obj || new MyGame.Example.Ability).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; -}; - -/** - * @returns {number} - */ -MyGame.Example.Monster.prototype.testarrayofsortedstructLength = function() { - var offset = this.bb.__offset(this.bb_pos, 62); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; -}; - -/** - * @param {flatbuffers.Builder} builder - */ -MyGame.Example.Monster.startMonster = function(builder) { - builder.startObject(30); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} posOffset - */ -MyGame.Example.Monster.addPos = function(builder, posOffset) { - builder.addFieldStruct(0, posOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} mana - */ -MyGame.Example.Monster.addMana = function(builder, mana) { - builder.addFieldInt16(1, mana, 150); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} hp - */ -MyGame.Example.Monster.addHp = function(builder, hp) { - builder.addFieldInt16(2, hp, 100); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} nameOffset - */ -MyGame.Example.Monster.addName = function(builder, nameOffset) { - builder.addFieldOffset(3, nameOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} inventoryOffset - */ -MyGame.Example.Monster.addInventory = function(builder, inventoryOffset) { - builder.addFieldOffset(5, inventoryOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Monster.createInventoryVector = function(builder, data) { - builder.startVector(1, data.length, 1); - for (var i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startInventoryVector = function(builder, numElems) { - builder.startVector(1, numElems, 1); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {MyGame.Example.Color} color - */ -MyGame.Example.Monster.addColor = function(builder, color) { - builder.addFieldInt8(6, color, MyGame.Example.Color.Blue); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {MyGame.Example.Any} testType - */ -MyGame.Example.Monster.addTestType = function(builder, testType) { - builder.addFieldInt8(7, testType, MyGame.Example.Any.NONE); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testOffset - */ -MyGame.Example.Monster.addTest = function(builder, testOffset) { - builder.addFieldOffset(8, testOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} test4Offset - */ -MyGame.Example.Monster.addTest4 = function(builder, test4Offset) { - builder.addFieldOffset(9, test4Offset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startTest4Vector = function(builder, numElems) { - builder.startVector(4, numElems, 2); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofstringOffset - */ -MyGame.Example.Monster.addTestarrayofstring = function(builder, testarrayofstringOffset) { - builder.addFieldOffset(10, testarrayofstringOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Monster.createTestarrayofstringVector = function(builder, data) { - builder.startVector(4, data.length, 4); - for (var i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]); - } - return builder.endVector(); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startTestarrayofstringVector = function(builder, numElems) { - builder.startVector(4, numElems, 4); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayoftablesOffset - */ -MyGame.Example.Monster.addTestarrayoftables = function(builder, testarrayoftablesOffset) { - builder.addFieldOffset(11, testarrayoftablesOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Monster.createTestarrayoftablesVector = function(builder, data) { - builder.startVector(4, data.length, 4); - for (var i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]); - } - return builder.endVector(); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startTestarrayoftablesVector = function(builder, numElems) { - builder.startVector(4, numElems, 4); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} enemyOffset - */ -MyGame.Example.Monster.addEnemy = function(builder, enemyOffset) { - builder.addFieldOffset(12, enemyOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testnestedflatbufferOffset - */ -MyGame.Example.Monster.addTestnestedflatbuffer = function(builder, testnestedflatbufferOffset) { - builder.addFieldOffset(13, testnestedflatbufferOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Monster.createTestnestedflatbufferVector = function(builder, data) { - builder.startVector(1, data.length, 1); - for (var i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startTestnestedflatbufferVector = function(builder, numElems) { - builder.startVector(1, numElems, 1); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testemptyOffset - */ -MyGame.Example.Monster.addTestempty = function(builder, testemptyOffset) { - builder.addFieldOffset(14, testemptyOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {boolean} testbool - */ -MyGame.Example.Monster.addTestbool = function(builder, testbool) { - builder.addFieldInt8(15, +testbool, +false); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} testhashs32Fnv1 - */ -MyGame.Example.Monster.addTesthashs32Fnv1 = function(builder, testhashs32Fnv1) { - builder.addFieldInt32(16, testhashs32Fnv1, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} testhashu32Fnv1 - */ -MyGame.Example.Monster.addTesthashu32Fnv1 = function(builder, testhashu32Fnv1) { - builder.addFieldInt32(17, testhashu32Fnv1, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashs64Fnv1 - */ -MyGame.Example.Monster.addTesthashs64Fnv1 = function(builder, testhashs64Fnv1) { - builder.addFieldInt64(18, testhashs64Fnv1, builder.createLong(0, 0)); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashu64Fnv1 - */ -MyGame.Example.Monster.addTesthashu64Fnv1 = function(builder, testhashu64Fnv1) { - builder.addFieldInt64(19, testhashu64Fnv1, builder.createLong(0, 0)); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} testhashs32Fnv1a - */ -MyGame.Example.Monster.addTesthashs32Fnv1a = function(builder, testhashs32Fnv1a) { - builder.addFieldInt32(20, testhashs32Fnv1a, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} testhashu32Fnv1a - */ -MyGame.Example.Monster.addTesthashu32Fnv1a = function(builder, testhashu32Fnv1a) { - builder.addFieldInt32(21, testhashu32Fnv1a, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashs64Fnv1a - */ -MyGame.Example.Monster.addTesthashs64Fnv1a = function(builder, testhashs64Fnv1a) { - builder.addFieldInt64(22, testhashs64Fnv1a, builder.createLong(0, 0)); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashu64Fnv1a - */ -MyGame.Example.Monster.addTesthashu64Fnv1a = function(builder, testhashu64Fnv1a) { - builder.addFieldInt64(23, testhashu64Fnv1a, builder.createLong(0, 0)); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofboolsOffset - */ -MyGame.Example.Monster.addTestarrayofbools = function(builder, testarrayofboolsOffset) { - builder.addFieldOffset(24, testarrayofboolsOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Monster.createTestarrayofboolsVector = function(builder, data) { - builder.startVector(1, data.length, 1); - for (var i = data.length - 1; i >= 0; i--) { - builder.addInt8(+data[i]); - } - return builder.endVector(); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startTestarrayofboolsVector = function(builder, numElems) { - builder.startVector(1, numElems, 1); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} testf - */ -MyGame.Example.Monster.addTestf = function(builder, testf) { - builder.addFieldFloat32(25, testf, 3.14159); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} testf2 - */ -MyGame.Example.Monster.addTestf2 = function(builder, testf2) { - builder.addFieldFloat32(26, testf2, 3.0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} testf3 - */ -MyGame.Example.Monster.addTestf3 = function(builder, testf3) { - builder.addFieldFloat32(27, testf3, 0.0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofstring2Offset - */ -MyGame.Example.Monster.addTestarrayofstring2 = function(builder, testarrayofstring2Offset) { - builder.addFieldOffset(28, testarrayofstring2Offset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Monster.createTestarrayofstring2Vector = function(builder, data) { - builder.startVector(4, data.length, 4); - for (var i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]); - } - return builder.endVector(); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startTestarrayofstring2Vector = function(builder, numElems) { - builder.startVector(4, numElems, 4); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofsortedstructOffset - */ -MyGame.Example.Monster.addTestarrayofsortedstruct = function(builder, testarrayofsortedstructOffset) { - builder.addFieldOffset(29, testarrayofsortedstructOffset, 0); -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ -MyGame.Example.Monster.startTestarrayofsortedstructVector = function(builder, numElems) { - builder.startVector(8, numElems, 4); -}; - -/** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ -MyGame.Example.Monster.endMonster = function(builder) { - var offset = builder.endObject(); - builder.requiredField(offset, 10); // name - return offset; -}; - -/** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} offset - */ -MyGame.Example.Monster.finishMonsterBuffer = function(builder, offset) { - builder.finish(offset, 'MONS'); -}; - -// Exports for Node.js and RequireJS -this.MyGame = MyGame; +(function (MyGame) { + var Example; + (function (Example) { + var Monster = (function () { + function Monster() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + /** + * @type {number} + */ + this.bb_pos = 0; + } + /** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Monster} + */ + Monster.prototype.__init = function (i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + }; + ; + /** + * @param {flatbuffers.ByteBuffer} bb + * @param {Monster=} obj + * @returns {Monster} + */ + Monster.getRootAsMonster = function (bb, obj) { + return (obj || new Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); + }; + ; + /** + * @param {flatbuffers.ByteBuffer} bb + * @returns {boolean} + */ + Monster.bufferHasIdentifier = function (bb) { + return bb.__has_identifier('MONS'); + }; + ; + /** + * @param {MyGame.Example.Vec3=} obj + * @returns {MyGame.Example.Vec3} + */ + Monster.prototype.pos = function (obj) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb) : null; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.mana = function () { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 150; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_mana = function (value) { + var offset = this.bb.__offset(this.bb_pos, 6); + if (offset === 0) { + return false; + } + this.bb.writeInt16(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.hp = function () { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 100; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_hp = function (value) { + var offset = this.bb.__offset(this.bb_pos, 8); + if (offset === 0) { + return false; + } + this.bb.writeInt16(this.bb_pos + offset, value); + return true; + }; + ; + Monster.prototype.name = function (optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; + }; + ; + /** + * @param {number} index + * @returns {number} + */ + Monster.prototype.inventory = function (index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.inventoryLength = function () { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + /** + * @returns {Uint8Array} + */ + Monster.prototype.inventoryArray = function () { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; + }; + ; + /** + * @returns {MyGame.Example.Color} + */ + Monster.prototype.color = function () { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Blue; + }; + ; + /** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ + Monster.prototype.mutate_color = function (value) { + var offset = this.bb.__offset(this.bb_pos, 16); + if (offset === 0) { + return false; + } + this.bb.writeInt8(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {MyGame.Example.Any} + */ + Monster.prototype.testType = function () { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE; + }; + ; + /** + * @param {MyGame.Example.Any} value + * @returns {boolean} + */ + Monster.prototype.mutate_test_type = function (value) { + var offset = this.bb.__offset(this.bb_pos, 18); + if (offset === 0) { + return false; + } + this.bb.writeUint8(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @param {flatbuffers.Table} obj + * @returns {?flatbuffers.Table} + */ + Monster.prototype.test = function (obj) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__union(obj, this.bb_pos + offset) : null; + }; + ; + /** + * @param {number} index + * @param {MyGame.Example.Test=} obj + * @returns {MyGame.Example.Test} + */ + Monster.prototype.test4 = function (index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.test4Length = function () { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + Monster.prototype.testarrayofstring = function (index, optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testarrayofstringLength = function () { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + /** + * an example documentation comment: this will end up in the generated code + * multiline too + * + * @param {number} index + * @param {MyGame.Example.Monster=} obj + * @returns {MyGame.Example.Monster} + */ + Monster.prototype.testarrayoftables = function (index, obj) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testarrayoftablesLength = function () { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {MyGame.Example.Monster=} obj + * @returns {MyGame.Example.Monster} + */ + Monster.prototype.enemy = function (obj) { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; + }; + ; + /** + * @param {number} index + * @returns {number} + */ + Monster.prototype.testnestedflatbuffer = function (index) { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testnestedflatbufferLength = function () { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + /** + * @returns {Uint8Array} + */ + Monster.prototype.testnestedflatbufferArray = function () { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; + }; + ; + /** + * @param {MyGame.Example.Stat=} obj + * @returns {MyGame.Example.Stat} + */ + Monster.prototype.testempty = function (obj) { + var offset = this.bb.__offset(this.bb_pos, 32); + return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; + }; + ; + /** + * @returns {boolean} + */ + Monster.prototype.testbool = function () { + var offset = this.bb.__offset(this.bb_pos, 34); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; + }; + ; + /** + * @param {boolean} value + * @returns {boolean} + */ + Monster.prototype.mutate_testbool = function (value) { + var offset = this.bb.__offset(this.bb_pos, 34); + if (offset === 0) { + return false; + } + this.bb.writeInt8(this.bb_pos + offset, +value); + return true; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testhashs32Fnv1 = function () { + var offset = this.bb.__offset(this.bb_pos, 36); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashs32_fnv1 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 36); + if (offset === 0) { + return false; + } + this.bb.writeInt32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testhashu32Fnv1 = function () { + var offset = this.bb.__offset(this.bb_pos, 38); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashu32_fnv1 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 38); + if (offset === 0) { + return false; + } + this.bb.writeUint32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {flatbuffers.Long} + */ + Monster.prototype.testhashs64Fnv1 = function () { + var offset = this.bb.__offset(this.bb_pos, 40); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); + }; + ; + /** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashs64_fnv1 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 40); + if (offset === 0) { + return false; + } + this.bb.writeInt64(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {flatbuffers.Long} + */ + Monster.prototype.testhashu64Fnv1 = function () { + var offset = this.bb.__offset(this.bb_pos, 42); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); + }; + ; + /** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashu64_fnv1 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 42); + if (offset === 0) { + return false; + } + this.bb.writeUint64(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testhashs32Fnv1a = function () { + var offset = this.bb.__offset(this.bb_pos, 44); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashs32_fnv1a = function (value) { + var offset = this.bb.__offset(this.bb_pos, 44); + if (offset === 0) { + return false; + } + this.bb.writeInt32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testhashu32Fnv1a = function () { + var offset = this.bb.__offset(this.bb_pos, 46); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashu32_fnv1a = function (value) { + var offset = this.bb.__offset(this.bb_pos, 46); + if (offset === 0) { + return false; + } + this.bb.writeUint32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {flatbuffers.Long} + */ + Monster.prototype.testhashs64Fnv1a = function () { + var offset = this.bb.__offset(this.bb_pos, 48); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); + }; + ; + /** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashs64_fnv1a = function (value) { + var offset = this.bb.__offset(this.bb_pos, 48); + if (offset === 0) { + return false; + } + this.bb.writeInt64(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {flatbuffers.Long} + */ + Monster.prototype.testhashu64Fnv1a = function () { + var offset = this.bb.__offset(this.bb_pos, 50); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); + }; + ; + /** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ + Monster.prototype.mutate_testhashu64_fnv1a = function (value) { + var offset = this.bb.__offset(this.bb_pos, 50); + if (offset === 0) { + return false; + } + this.bb.writeUint64(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @param {number} index + * @returns {boolean} + */ + Monster.prototype.testarrayofbools = function (index) { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testarrayofboolsLength = function () { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + /** + * @returns {Int8Array} + */ + Monster.prototype.testarrayofboolsArray = function () { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testf = function () { + var offset = this.bb.__offset(this.bb_pos, 54); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.14159; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_testf = function (value) { + var offset = this.bb.__offset(this.bb_pos, 54); + if (offset === 0) { + return false; + } + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testf2 = function () { + var offset = this.bb.__offset(this.bb_pos, 56); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.0; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_testf2 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 56); + if (offset === 0) { + return false; + } + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testf3 = function () { + var offset = this.bb.__offset(this.bb_pos, 58); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; + }; + ; + /** + * @param {number} value + * @returns {boolean} + */ + Monster.prototype.mutate_testf3 = function (value) { + var offset = this.bb.__offset(this.bb_pos, 58); + if (offset === 0) { + return false; + } + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; + }; + ; + Monster.prototype.testarrayofstring2 = function (index, optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testarrayofstring2Length = function () { + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {number} index + * @param {MyGame.Example.Ability=} obj + * @returns {MyGame.Example.Ability} + */ + Monster.prototype.testarrayofsortedstruct = function (index, obj) { + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? (obj || new MyGame.Example.Ability).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; + }; + ; + /** + * @returns {number} + */ + Monster.prototype.testarrayofsortedstructLength = function () { + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; + }; + ; + /** + * @param {flatbuffers.Builder} builder + */ + Monster.startMonster = function (builder) { + builder.startObject(30); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} posOffset + */ + Monster.addPos = function (builder, posOffset) { + builder.addFieldStruct(0, posOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} mana + */ + Monster.addMana = function (builder, mana) { + builder.addFieldInt16(1, mana, 150); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} hp + */ + Monster.addHp = function (builder, hp) { + builder.addFieldInt16(2, hp, 100); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} nameOffset + */ + Monster.addName = function (builder, nameOffset) { + builder.addFieldOffset(3, nameOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} inventoryOffset + */ + Monster.addInventory = function (builder, inventoryOffset) { + builder.addFieldOffset(5, inventoryOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ + Monster.createInventoryVector = function (builder, data) { + if (!data) { + return null; + } + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startInventoryVector = function (builder, numElems) { + builder.startVector(1, numElems, 1); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Color} color + */ + Monster.addColor = function (builder, color) { + builder.addFieldInt8(6, color, MyGame.Example.Color.Blue); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Any} testType + */ + Monster.addTestType = function (builder, testType) { + builder.addFieldInt8(7, testType, MyGame.Example.Any.NONE); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testOffset + */ + Monster.addTest = function (builder, testOffset) { + builder.addFieldOffset(8, testOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} test4Offset + */ + Monster.addTest4 = function (builder, test4Offset) { + builder.addFieldOffset(9, test4Offset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startTest4Vector = function (builder, numElems) { + builder.startVector(4, numElems, 2); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofstringOffset + */ + Monster.addTestarrayofstring = function (builder, testarrayofstringOffset) { + builder.addFieldOffset(10, testarrayofstringOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ + Monster.createTestarrayofstringVector = function (builder, data) { + if (!data) { + return null; + } + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startTestarrayofstringVector = function (builder, numElems) { + builder.startVector(4, numElems, 4); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayoftablesOffset + */ + Monster.addTestarrayoftables = function (builder, testarrayoftablesOffset) { + builder.addFieldOffset(11, testarrayoftablesOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ + Monster.createTestarrayoftablesVector = function (builder, data) { + if (!data) { + return null; + } + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startTestarrayoftablesVector = function (builder, numElems) { + builder.startVector(4, numElems, 4); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} enemyOffset + */ + Monster.addEnemy = function (builder, enemyOffset) { + builder.addFieldOffset(12, enemyOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testnestedflatbufferOffset + */ + Monster.addTestnestedflatbuffer = function (builder, testnestedflatbufferOffset) { + builder.addFieldOffset(13, testnestedflatbufferOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ + Monster.createTestnestedflatbufferVector = function (builder, data) { + if (!data) { + return null; + } + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startTestnestedflatbufferVector = function (builder, numElems) { + builder.startVector(1, numElems, 1); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testemptyOffset + */ + Monster.addTestempty = function (builder, testemptyOffset) { + builder.addFieldOffset(14, testemptyOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {boolean} testbool + */ + Monster.addTestbool = function (builder, testbool) { + builder.addFieldInt8(15, +testbool, +false); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} testhashs32Fnv1 + */ + Monster.addTesthashs32Fnv1 = function (builder, testhashs32Fnv1) { + builder.addFieldInt32(16, testhashs32Fnv1, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} testhashu32Fnv1 + */ + Monster.addTesthashu32Fnv1 = function (builder, testhashu32Fnv1) { + builder.addFieldInt32(17, testhashu32Fnv1, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashs64Fnv1 + */ + Monster.addTesthashs64Fnv1 = function (builder, testhashs64Fnv1) { + builder.addFieldInt64(18, testhashs64Fnv1, builder.createLong(0, 0)); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashu64Fnv1 + */ + Monster.addTesthashu64Fnv1 = function (builder, testhashu64Fnv1) { + builder.addFieldInt64(19, testhashu64Fnv1, builder.createLong(0, 0)); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} testhashs32Fnv1a + */ + Monster.addTesthashs32Fnv1a = function (builder, testhashs32Fnv1a) { + builder.addFieldInt32(20, testhashs32Fnv1a, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} testhashu32Fnv1a + */ + Monster.addTesthashu32Fnv1a = function (builder, testhashu32Fnv1a) { + builder.addFieldInt32(21, testhashu32Fnv1a, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashs64Fnv1a + */ + Monster.addTesthashs64Fnv1a = function (builder, testhashs64Fnv1a) { + builder.addFieldInt64(22, testhashs64Fnv1a, builder.createLong(0, 0)); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashu64Fnv1a + */ + Monster.addTesthashu64Fnv1a = function (builder, testhashu64Fnv1a) { + builder.addFieldInt64(23, testhashu64Fnv1a, builder.createLong(0, 0)); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofboolsOffset + */ + Monster.addTestarrayofbools = function (builder, testarrayofboolsOffset) { + builder.addFieldOffset(24, testarrayofboolsOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ + Monster.createTestarrayofboolsVector = function (builder, data) { + if (!data) { + return null; + } + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(+data[i]); + } + return builder.endVector(); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startTestarrayofboolsVector = function (builder, numElems) { + builder.startVector(1, numElems, 1); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} testf + */ + Monster.addTestf = function (builder, testf) { + builder.addFieldFloat32(25, testf, 3.14159); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} testf2 + */ + Monster.addTestf2 = function (builder, testf2) { + builder.addFieldFloat32(26, testf2, 3.0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} testf3 + */ + Monster.addTestf3 = function (builder, testf3) { + builder.addFieldFloat32(27, testf3, 0.0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofstring2Offset + */ + Monster.addTestarrayofstring2 = function (builder, testarrayofstring2Offset) { + builder.addFieldOffset(28, testarrayofstring2Offset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ + Monster.createTestarrayofstring2Vector = function (builder, data) { + if (!data) { + return null; + } + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startTestarrayofstring2Vector = function (builder, numElems) { + builder.startVector(4, numElems, 4); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofsortedstructOffset + */ + Monster.addTestarrayofsortedstruct = function (builder, testarrayofsortedstructOffset) { + builder.addFieldOffset(29, testarrayofsortedstructOffset, 0); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ + Monster.startTestarrayofsortedstructVector = function (builder, numElems) { + builder.startVector(8, numElems, 4); + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ + Monster.endMonster = function (builder) { + var offset = builder.endObject(); + builder.requiredField(offset, 10); // name + return offset; + }; + ; + /** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ + Monster.finishMonsterBuffer = function (builder, offset) { + builder.finish(offset, 'MONS'); + }; + ; + return Monster; + }()); + Example.Monster = Monster; + })(Example = MyGame.Example || (MyGame.Example = {})); +})(MyGame = exports.MyGame || (exports.MyGame = {})); diff --git a/tests/monster_test_generated.ts b/tests/monster_test_generated.ts index 564334d479c..3ff1bf9266e 100644 --- a/tests/monster_test_generated.ts +++ b/tests/monster_test_generated.ts @@ -1,6 +1,5 @@ // automatically generated by the FlatBuffers compiler, do not modify -import { flatbuffers } from "./flatbuffers" /** * @enum */ @@ -943,7 +942,7 @@ mutate_testbool(value:boolean):boolean { return false; } - this.bb.writeInt8(this.bb_pos + offset, value); + this.bb.writeInt8(this.bb_pos + offset, +value); return true; }; From d9bfd6f7a014e5a021026af0750612c18a1369be Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Fri, 7 Apr 2017 20:01:09 +0200 Subject: [PATCH 16/17] Reverted generates js test file to original version --- tests/monster_test_generated.js | 3269 ++++++++++++++++--------------- 1 file changed, 1644 insertions(+), 1625 deletions(-) diff --git a/tests/monster_test_generated.js b/tests/monster_test_generated.js index 88c3d130d40..7b0165c5543 100644 --- a/tests/monster_test_generated.js +++ b/tests/monster_test_generated.js @@ -1,1655 +1,1674 @@ // automatically generated by the FlatBuffers compiler, do not modify -"use strict"; -exports.__esModule = true; + +/** + * @const + * @namespace + */ +var MyGame = MyGame || {}; + +/** + * @const + * @namespace + */ +MyGame.Example = MyGame.Example || {}; + +/** + * @const + * @namespace + */ +MyGame.Example2 = MyGame.Example2 || {}; + +/** + * @const + * @namespace + */ +MyGame.OtherNameSpace = MyGame.OtherNameSpace || {}; + /** * @enum */ -var MyGame; -(function (MyGame) { - var Example; - (function (Example) { - var Color; - (function (Color) { - Color[Color["Red"] = 1] = "Red"; - Color[Color["Green"] = 2] = "Green"; - Color[Color["Blue"] = 8] = "Blue"; - })(Color = Example.Color || (Example.Color = {})); - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); -; +MyGame.Example.Color = { + Red: 1, + Green: 2, + Blue: 8 +}; + /** * @enum */ -(function (MyGame) { - var Example; - (function (Example) { - var Any; - (function (Any) { - Any[Any["NONE"] = 0] = "NONE"; - Any[Any["Monster"] = 1] = "Monster"; - Any[Any["TestSimpleTableWithEnum"] = 2] = "TestSimpleTableWithEnum"; - Any[Any["MyGame_Example2_Monster"] = 3] = "MyGame_Example2_Monster"; - })(Any = Example.Any || (Example.Any = {})); - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); -; +MyGame.Example.Any = { + NONE: 0, + Monster: 1, + TestSimpleTableWithEnum: 2, + MyGame_Example2_Monster: 3 +}; + /** * @constructor */ -(function (MyGame) { - var Example2; - (function (Example2) { - var Monster = (function () { - function Monster() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - /** - * @type {number} - */ - this.bb_pos = 0; - } - /** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {Monster} - */ - Monster.prototype.__init = function (i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; - }; - ; - /** - * @param {flatbuffers.ByteBuffer} bb - * @param {Monster=} obj - * @returns {Monster} - */ - Monster.getRootAsMonster = function (bb, obj) { - return (obj || new Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); - }; - ; - /** - * @param {flatbuffers.Builder} builder - */ - Monster.startMonster = function (builder) { - builder.startObject(0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ - Monster.endMonster = function (builder) { - var offset = builder.endObject(); - return offset; - }; - ; - return Monster; - }()); - Example2.Monster = Monster; - })(Example2 = MyGame.Example2 || (MyGame.Example2 = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); +MyGame.Example2.Monster = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example2.Monster} + */ +MyGame.Example2.Monster.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {MyGame.Example2.Monster=} obj + * @returns {MyGame.Example2.Monster} + */ +MyGame.Example2.Monster.getRootAsMonster = function(bb, obj) { + return (obj || new MyGame.Example2.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.Builder} builder + */ +MyGame.Example2.Monster.startMonster = function(builder) { + builder.startObject(0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +MyGame.Example2.Monster.endMonster = function(builder) { + var offset = builder.endObject(); + return offset; +}; + /** * @constructor */ -(function (MyGame) { - var Example; - (function (Example) { - var Test = (function () { - function Test() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - /** - * @type {number} - */ - this.bb_pos = 0; - } - /** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {Test} - */ - Test.prototype.__init = function (i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; - }; - ; - /** - * @returns {number} - */ - Test.prototype.a = function () { - return this.bb.readInt16(this.bb_pos); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Test.prototype.mutate_a = function (value) { - var offset = this.bb.__offset(this.bb_pos, 0); - if (offset === 0) { - return false; - } - this.bb.writeInt16(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Test.prototype.b = function () { - return this.bb.readInt8(this.bb_pos + 2); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Test.prototype.mutate_b = function (value) { - var offset = this.bb.__offset(this.bb_pos, 2); - if (offset === 0) { - return false; - } - this.bb.writeInt8(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} a - * @param {number} b - * @returns {flatbuffers.Offset} - */ - Test.createTest = function (builder, a, b) { - builder.prep(2, 4); - builder.pad(1); - builder.writeInt8(b); - builder.writeInt16(a); - return builder.offset(); - }; - ; - return Test; - }()); - Example.Test = Test; - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); +MyGame.Example.Test = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example.Test} + */ +MyGame.Example.Test.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +MyGame.Example.Test.prototype.a = function() { + return this.bb.readInt16(this.bb_pos); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Test.prototype.mutate_a = function(value) { + var offset = this.bb.__offset(this.bb_pos, 0); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Test.prototype.b = function() { + return this.bb.readInt8(this.bb_pos + 2); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Test.prototype.mutate_b = function(value) { + var offset = this.bb.__offset(this.bb_pos, 2); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} a + * @param {number} b + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Test.createTest = function(builder, a, b) { + builder.prep(2, 4); + builder.pad(1); + builder.writeInt8(b); + builder.writeInt16(a); + return builder.offset(); +}; + /** * @constructor */ -(function (MyGame) { - var Example; - (function (Example) { - var TestSimpleTableWithEnum = (function () { - function TestSimpleTableWithEnum() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - /** - * @type {number} - */ - this.bb_pos = 0; - } - /** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {TestSimpleTableWithEnum} - */ - TestSimpleTableWithEnum.prototype.__init = function (i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; - }; - ; - /** - * @param {flatbuffers.ByteBuffer} bb - * @param {TestSimpleTableWithEnum=} obj - * @returns {TestSimpleTableWithEnum} - */ - TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum = function (bb, obj) { - return (obj || new TestSimpleTableWithEnum).__init(bb.readInt32(bb.position()) + bb.position(), bb); - }; - ; - /** - * @returns {MyGame.Example.Color} - */ - TestSimpleTableWithEnum.prototype.color = function () { - var offset = this.bb.__offset(this.bb_pos, 4); - return offset ? (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Green; - }; - ; - /** - * @param {MyGame.Example.Color} value - * @returns {boolean} - */ - TestSimpleTableWithEnum.prototype.mutate_color = function (value) { - var offset = this.bb.__offset(this.bb_pos, 4); - if (offset === 0) { - return false; - } - this.bb.writeInt8(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @param {flatbuffers.Builder} builder - */ - TestSimpleTableWithEnum.startTestSimpleTableWithEnum = function (builder) { - builder.startObject(1); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {MyGame.Example.Color} color - */ - TestSimpleTableWithEnum.addColor = function (builder, color) { - builder.addFieldInt8(0, color, MyGame.Example.Color.Green); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ - TestSimpleTableWithEnum.endTestSimpleTableWithEnum = function (builder) { - var offset = builder.endObject(); - return offset; - }; - ; - return TestSimpleTableWithEnum; - }()); - Example.TestSimpleTableWithEnum = TestSimpleTableWithEnum; - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); +MyGame.Example.TestSimpleTableWithEnum = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example.TestSimpleTableWithEnum} + */ +MyGame.Example.TestSimpleTableWithEnum.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {MyGame.Example.TestSimpleTableWithEnum=} obj + * @returns {MyGame.Example.TestSimpleTableWithEnum} + */ +MyGame.Example.TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum = function(bb, obj) { + return (obj || new MyGame.Example.TestSimpleTableWithEnum).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {MyGame.Example.Color} + */ +MyGame.Example.TestSimpleTableWithEnum.prototype.color = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Green; +}; + +/** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ +MyGame.Example.TestSimpleTableWithEnum.prototype.mutate_color = function(value) { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +MyGame.Example.TestSimpleTableWithEnum.startTestSimpleTableWithEnum = function(builder) { + builder.startObject(1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Color} color + */ +MyGame.Example.TestSimpleTableWithEnum.addColor = function(builder, color) { + builder.addFieldInt8(0, color, MyGame.Example.Color.Green); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +MyGame.Example.TestSimpleTableWithEnum.endTestSimpleTableWithEnum = function(builder) { + var offset = builder.endObject(); + return offset; +}; + /** * @constructor */ -(function (MyGame) { - var Example; - (function (Example) { - var Vec3 = (function () { - function Vec3() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - /** - * @type {number} - */ - this.bb_pos = 0; - } - /** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {Vec3} - */ - Vec3.prototype.__init = function (i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; - }; - ; - /** - * @returns {number} - */ - Vec3.prototype.x = function () { - return this.bb.readFloat32(this.bb_pos); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Vec3.prototype.mutate_x = function (value) { - var offset = this.bb.__offset(this.bb_pos, 0); - if (offset === 0) { - return false; - } - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Vec3.prototype.y = function () { - return this.bb.readFloat32(this.bb_pos + 4); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Vec3.prototype.mutate_y = function (value) { - var offset = this.bb.__offset(this.bb_pos, 4); - if (offset === 0) { - return false; - } - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Vec3.prototype.z = function () { - return this.bb.readFloat32(this.bb_pos + 8); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Vec3.prototype.mutate_z = function (value) { - var offset = this.bb.__offset(this.bb_pos, 8); - if (offset === 0) { - return false; - } - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Vec3.prototype.test1 = function () { - return this.bb.readFloat64(this.bb_pos + 16); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Vec3.prototype.mutate_test1 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 16); - if (offset === 0) { - return false; - } - this.bb.writeFloat64(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {MyGame.Example.Color} - */ - Vec3.prototype.test2 = function () { - return (this.bb.readInt8(this.bb_pos + 24)); - }; - ; - /** - * @param {MyGame.Example.Color} value - * @returns {boolean} - */ - Vec3.prototype.mutate_test2 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 24); - if (offset === 0) { - return false; - } - this.bb.writeInt8(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @param {MyGame.Example.Test=} obj - * @returns {MyGame.Example.Test} - */ - Vec3.prototype.test3 = function (obj) { - return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} x - * @param {number} y - * @param {number} z - * @param {number} test1 - * @param {MyGame.Example.Color} test2 - * @param {number} test3_a - * @param {number} test3_b - * @returns {flatbuffers.Offset} - */ - Vec3.createVec3 = function (builder, x, y, z, test1, test2, test3_a, test3_b) { - builder.prep(16, 32); - builder.pad(2); - builder.prep(2, 4); - builder.pad(1); - builder.writeInt8(test3_b); - builder.writeInt16(test3_a); - builder.pad(1); - builder.writeInt8(test2); - builder.writeFloat64(test1); - builder.pad(4); - builder.writeFloat32(z); - builder.writeFloat32(y); - builder.writeFloat32(x); - return builder.offset(); - }; - ; - return Vec3; - }()); - Example.Vec3 = Vec3; - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); +MyGame.Example.Vec3 = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example.Vec3} + */ +MyGame.Example.Vec3.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +MyGame.Example.Vec3.prototype.x = function() { + return this.bb.readFloat32(this.bb_pos); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Vec3.prototype.mutate_x = function(value) { + var offset = this.bb.__offset(this.bb_pos, 0); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Vec3.prototype.y = function() { + return this.bb.readFloat32(this.bb_pos + 4); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Vec3.prototype.mutate_y = function(value) { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Vec3.prototype.z = function() { + return this.bb.readFloat32(this.bb_pos + 8); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Vec3.prototype.mutate_z = function(value) { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Vec3.prototype.test1 = function() { + return this.bb.readFloat64(this.bb_pos + 16); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Vec3.prototype.mutate_test1 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 16); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {MyGame.Example.Color} + */ +MyGame.Example.Vec3.prototype.test2 = function() { + return /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + 24)); +}; + +/** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ +MyGame.Example.Vec3.prototype.mutate_test2 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 24); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {MyGame.Example.Test=} obj + * @returns {MyGame.Example.Test} + */ +MyGame.Example.Vec3.prototype.test3 = function(obj) { + return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} x + * @param {number} y + * @param {number} z + * @param {number} test1 + * @param {MyGame.Example.Color} test2 + * @param {number} test3_a + * @param {number} test3_b + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Vec3.createVec3 = function(builder, x, y, z, test1, test2, test3_a, test3_b) { + builder.prep(16, 32); + builder.pad(2); + builder.prep(2, 4); + builder.pad(1); + builder.writeInt8(test3_b); + builder.writeInt16(test3_a); + builder.pad(1); + builder.writeInt8(test2); + builder.writeFloat64(test1); + builder.pad(4); + builder.writeFloat32(z); + builder.writeFloat32(y); + builder.writeFloat32(x); + return builder.offset(); +}; + /** * @constructor */ -(function (MyGame) { - var Example; - (function (Example) { - var Ability = (function () { - function Ability() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - /** - * @type {number} - */ - this.bb_pos = 0; - } - /** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {Ability} - */ - Ability.prototype.__init = function (i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; - }; - ; - /** - * @returns {number} - */ - Ability.prototype.id = function () { - return this.bb.readUint32(this.bb_pos); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Ability.prototype.mutate_id = function (value) { - var offset = this.bb.__offset(this.bb_pos, 0); - if (offset === 0) { - return false; - } - this.bb.writeUint32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Ability.prototype.distance = function () { - return this.bb.readUint32(this.bb_pos + 4); - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Ability.prototype.mutate_distance = function (value) { - var offset = this.bb.__offset(this.bb_pos, 4); - if (offset === 0) { - return false; - } - this.bb.writeUint32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} id - * @param {number} distance - * @returns {flatbuffers.Offset} - */ - Ability.createAbility = function (builder, id, distance) { - builder.prep(4, 8); - builder.writeInt32(distance); - builder.writeInt32(id); - return builder.offset(); - }; - ; - return Ability; - }()); - Example.Ability = Ability; - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); +MyGame.Example.Ability = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example.Ability} + */ +MyGame.Example.Ability.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +MyGame.Example.Ability.prototype.id = function() { + return this.bb.readUint32(this.bb_pos); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Ability.prototype.mutate_id = function(value) { + var offset = this.bb.__offset(this.bb_pos, 0); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Ability.prototype.distance = function() { + return this.bb.readUint32(this.bb_pos + 4); +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Ability.prototype.mutate_distance = function(value) { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} id + * @param {number} distance + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Ability.createAbility = function(builder, id, distance) { + builder.prep(4, 8); + builder.writeInt32(distance); + builder.writeInt32(id); + return builder.offset(); +}; + /** * @constructor */ -(function (MyGame) { - var Example; - (function (Example) { - var Stat = (function () { - function Stat() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - /** - * @type {number} - */ - this.bb_pos = 0; - } - /** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {Stat} - */ - Stat.prototype.__init = function (i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; - }; - ; - /** - * @param {flatbuffers.ByteBuffer} bb - * @param {Stat=} obj - * @returns {Stat} - */ - Stat.getRootAsStat = function (bb, obj) { - return (obj || new Stat).__init(bb.readInt32(bb.position()) + bb.position(), bb); - }; - ; - Stat.prototype.id = function (optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 4); - return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; - }; - ; - /** - * @returns {flatbuffers.Long} - */ - Stat.prototype.val = function () { - var offset = this.bb.__offset(this.bb_pos, 6); - return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); - }; - ; - /** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ - Stat.prototype.mutate_val = function (value) { - var offset = this.bb.__offset(this.bb_pos, 6); - if (offset === 0) { - return false; - } - this.bb.writeInt64(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Stat.prototype.count = function () { - var offset = this.bb.__offset(this.bb_pos, 8); - return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Stat.prototype.mutate_count = function (value) { - var offset = this.bb.__offset(this.bb_pos, 8); - if (offset === 0) { - return false; - } - this.bb.writeUint16(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @param {flatbuffers.Builder} builder - */ - Stat.startStat = function (builder) { - builder.startObject(3); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} idOffset - */ - Stat.addId = function (builder, idOffset) { - builder.addFieldOffset(0, idOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} val - */ - Stat.addVal = function (builder, val) { - builder.addFieldInt64(1, val, builder.createLong(0, 0)); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} count - */ - Stat.addCount = function (builder, count) { - builder.addFieldInt16(2, count, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ - Stat.endStat = function (builder) { - var offset = builder.endObject(); - return offset; - }; - ; - return Stat; - }()); - Example.Stat = Stat; - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); +MyGame.Example.Stat = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example.Stat} + */ +MyGame.Example.Stat.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {MyGame.Example.Stat=} obj + * @returns {MyGame.Example.Stat} + */ +MyGame.Example.Stat.getRootAsStat = function(bb, obj) { + return (obj || new MyGame.Example.Stat).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +MyGame.Example.Stat.prototype.id = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @returns {flatbuffers.Long} + */ +MyGame.Example.Stat.prototype.val = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +MyGame.Example.Stat.prototype.mutate_val = function(value) { + var offset = this.bb.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Stat.prototype.count = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Stat.prototype.mutate_count = function(value) { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeUint16(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +MyGame.Example.Stat.startStat = function(builder) { + builder.startObject(3); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} idOffset + */ +MyGame.Example.Stat.addId = function(builder, idOffset) { + builder.addFieldOffset(0, idOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} val + */ +MyGame.Example.Stat.addVal = function(builder, val) { + builder.addFieldInt64(1, val, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} count + */ +MyGame.Example.Stat.addCount = function(builder, count) { + builder.addFieldInt16(2, count, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Stat.endStat = function(builder) { + var offset = builder.endObject(); + return offset; +}; + /** * an example documentation comment: monster object * * @constructor */ -(function (MyGame) { - var Example; - (function (Example) { - var Monster = (function () { - function Monster() { - /** - * @type {flatbuffers.ByteBuffer} - */ - this.bb = null; - /** - * @type {number} - */ - this.bb_pos = 0; - } - /** - * @param {number} i - * @param {flatbuffers.ByteBuffer} bb - * @returns {Monster} - */ - Monster.prototype.__init = function (i, bb) { - this.bb_pos = i; - this.bb = bb; - return this; - }; - ; - /** - * @param {flatbuffers.ByteBuffer} bb - * @param {Monster=} obj - * @returns {Monster} - */ - Monster.getRootAsMonster = function (bb, obj) { - return (obj || new Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); - }; - ; - /** - * @param {flatbuffers.ByteBuffer} bb - * @returns {boolean} - */ - Monster.bufferHasIdentifier = function (bb) { - return bb.__has_identifier('MONS'); - }; - ; - /** - * @param {MyGame.Example.Vec3=} obj - * @returns {MyGame.Example.Vec3} - */ - Monster.prototype.pos = function (obj) { - var offset = this.bb.__offset(this.bb_pos, 4); - return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb) : null; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.mana = function () { - var offset = this.bb.__offset(this.bb_pos, 6); - return offset ? this.bb.readInt16(this.bb_pos + offset) : 150; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_mana = function (value) { - var offset = this.bb.__offset(this.bb_pos, 6); - if (offset === 0) { - return false; - } - this.bb.writeInt16(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.hp = function () { - var offset = this.bb.__offset(this.bb_pos, 8); - return offset ? this.bb.readInt16(this.bb_pos + offset) : 100; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_hp = function (value) { - var offset = this.bb.__offset(this.bb_pos, 8); - if (offset === 0) { - return false; - } - this.bb.writeInt16(this.bb_pos + offset, value); - return true; - }; - ; - Monster.prototype.name = function (optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 10); - return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; - }; - ; - /** - * @param {number} index - * @returns {number} - */ - Monster.prototype.inventory = function (index) { - var offset = this.bb.__offset(this.bb_pos, 14); - return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.inventoryLength = function () { - var offset = this.bb.__offset(this.bb_pos, 14); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - /** - * @returns {Uint8Array} - */ - Monster.prototype.inventoryArray = function () { - var offset = this.bb.__offset(this.bb_pos, 14); - return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; - }; - ; - /** - * @returns {MyGame.Example.Color} - */ - Monster.prototype.color = function () { - var offset = this.bb.__offset(this.bb_pos, 16); - return offset ? (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Blue; - }; - ; - /** - * @param {MyGame.Example.Color} value - * @returns {boolean} - */ - Monster.prototype.mutate_color = function (value) { - var offset = this.bb.__offset(this.bb_pos, 16); - if (offset === 0) { - return false; - } - this.bb.writeInt8(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {MyGame.Example.Any} - */ - Monster.prototype.testType = function () { - var offset = this.bb.__offset(this.bb_pos, 18); - return offset ? (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE; - }; - ; - /** - * @param {MyGame.Example.Any} value - * @returns {boolean} - */ - Monster.prototype.mutate_test_type = function (value) { - var offset = this.bb.__offset(this.bb_pos, 18); - if (offset === 0) { - return false; - } - this.bb.writeUint8(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @param {flatbuffers.Table} obj - * @returns {?flatbuffers.Table} - */ - Monster.prototype.test = function (obj) { - var offset = this.bb.__offset(this.bb_pos, 20); - return offset ? this.bb.__union(obj, this.bb_pos + offset) : null; - }; - ; - /** - * @param {number} index - * @param {MyGame.Example.Test=} obj - * @returns {MyGame.Example.Test} - */ - Monster.prototype.test4 = function (index, obj) { - var offset = this.bb.__offset(this.bb_pos, 22); - return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.test4Length = function () { - var offset = this.bb.__offset(this.bb_pos, 22); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - Monster.prototype.testarrayofstring = function (index, optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 24); - return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testarrayofstringLength = function () { - var offset = this.bb.__offset(this.bb_pos, 24); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - /** - * an example documentation comment: this will end up in the generated code - * multiline too - * - * @param {number} index - * @param {MyGame.Example.Monster=} obj - * @returns {MyGame.Example.Monster} - */ - Monster.prototype.testarrayoftables = function (index, obj) { - var offset = this.bb.__offset(this.bb_pos, 26); - return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testarrayoftablesLength = function () { - var offset = this.bb.__offset(this.bb_pos, 26); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {MyGame.Example.Monster=} obj - * @returns {MyGame.Example.Monster} - */ - Monster.prototype.enemy = function (obj) { - var offset = this.bb.__offset(this.bb_pos, 28); - return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; - }; - ; - /** - * @param {number} index - * @returns {number} - */ - Monster.prototype.testnestedflatbuffer = function (index) { - var offset = this.bb.__offset(this.bb_pos, 30); - return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testnestedflatbufferLength = function () { - var offset = this.bb.__offset(this.bb_pos, 30); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - /** - * @returns {Uint8Array} - */ - Monster.prototype.testnestedflatbufferArray = function () { - var offset = this.bb.__offset(this.bb_pos, 30); - return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; - }; - ; - /** - * @param {MyGame.Example.Stat=} obj - * @returns {MyGame.Example.Stat} - */ - Monster.prototype.testempty = function (obj) { - var offset = this.bb.__offset(this.bb_pos, 32); - return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; - }; - ; - /** - * @returns {boolean} - */ - Monster.prototype.testbool = function () { - var offset = this.bb.__offset(this.bb_pos, 34); - return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; - }; - ; - /** - * @param {boolean} value - * @returns {boolean} - */ - Monster.prototype.mutate_testbool = function (value) { - var offset = this.bb.__offset(this.bb_pos, 34); - if (offset === 0) { - return false; - } - this.bb.writeInt8(this.bb_pos + offset, +value); - return true; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testhashs32Fnv1 = function () { - var offset = this.bb.__offset(this.bb_pos, 36); - return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashs32_fnv1 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 36); - if (offset === 0) { - return false; - } - this.bb.writeInt32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testhashu32Fnv1 = function () { - var offset = this.bb.__offset(this.bb_pos, 38); - return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashu32_fnv1 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 38); - if (offset === 0) { - return false; - } - this.bb.writeUint32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {flatbuffers.Long} - */ - Monster.prototype.testhashs64Fnv1 = function () { - var offset = this.bb.__offset(this.bb_pos, 40); - return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); - }; - ; - /** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashs64_fnv1 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 40); - if (offset === 0) { - return false; - } - this.bb.writeInt64(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {flatbuffers.Long} - */ - Monster.prototype.testhashu64Fnv1 = function () { - var offset = this.bb.__offset(this.bb_pos, 42); - return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); - }; - ; - /** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashu64_fnv1 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 42); - if (offset === 0) { - return false; - } - this.bb.writeUint64(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testhashs32Fnv1a = function () { - var offset = this.bb.__offset(this.bb_pos, 44); - return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashs32_fnv1a = function (value) { - var offset = this.bb.__offset(this.bb_pos, 44); - if (offset === 0) { - return false; - } - this.bb.writeInt32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testhashu32Fnv1a = function () { - var offset = this.bb.__offset(this.bb_pos, 46); - return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashu32_fnv1a = function (value) { - var offset = this.bb.__offset(this.bb_pos, 46); - if (offset === 0) { - return false; - } - this.bb.writeUint32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {flatbuffers.Long} - */ - Monster.prototype.testhashs64Fnv1a = function () { - var offset = this.bb.__offset(this.bb_pos, 48); - return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); - }; - ; - /** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashs64_fnv1a = function (value) { - var offset = this.bb.__offset(this.bb_pos, 48); - if (offset === 0) { - return false; - } - this.bb.writeInt64(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {flatbuffers.Long} - */ - Monster.prototype.testhashu64Fnv1a = function () { - var offset = this.bb.__offset(this.bb_pos, 50); - return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); - }; - ; - /** - * @param {flatbuffers.Long} value - * @returns {boolean} - */ - Monster.prototype.mutate_testhashu64_fnv1a = function (value) { - var offset = this.bb.__offset(this.bb_pos, 50); - if (offset === 0) { - return false; - } - this.bb.writeUint64(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @param {number} index - * @returns {boolean} - */ - Monster.prototype.testarrayofbools = function (index) { - var offset = this.bb.__offset(this.bb_pos, 52); - return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testarrayofboolsLength = function () { - var offset = this.bb.__offset(this.bb_pos, 52); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - /** - * @returns {Int8Array} - */ - Monster.prototype.testarrayofboolsArray = function () { - var offset = this.bb.__offset(this.bb_pos, 52); - return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testf = function () { - var offset = this.bb.__offset(this.bb_pos, 54); - return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.14159; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_testf = function (value) { - var offset = this.bb.__offset(this.bb_pos, 54); - if (offset === 0) { - return false; - } - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testf2 = function () { - var offset = this.bb.__offset(this.bb_pos, 56); - return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.0; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_testf2 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 56); - if (offset === 0) { - return false; - } - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testf3 = function () { - var offset = this.bb.__offset(this.bb_pos, 58); - return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; - }; - ; - /** - * @param {number} value - * @returns {boolean} - */ - Monster.prototype.mutate_testf3 = function (value) { - var offset = this.bb.__offset(this.bb_pos, 58); - if (offset === 0) { - return false; - } - this.bb.writeFloat32(this.bb_pos + offset, value); - return true; - }; - ; - Monster.prototype.testarrayofstring2 = function (index, optionalEncoding) { - var offset = this.bb.__offset(this.bb_pos, 60); - return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testarrayofstring2Length = function () { - var offset = this.bb.__offset(this.bb_pos, 60); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {number} index - * @param {MyGame.Example.Ability=} obj - * @returns {MyGame.Example.Ability} - */ - Monster.prototype.testarrayofsortedstruct = function (index, obj) { - var offset = this.bb.__offset(this.bb_pos, 62); - return offset ? (obj || new MyGame.Example.Ability).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; - }; - ; - /** - * @returns {number} - */ - Monster.prototype.testarrayofsortedstructLength = function () { - var offset = this.bb.__offset(this.bb_pos, 62); - return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; - }; - ; - /** - * @param {flatbuffers.Builder} builder - */ - Monster.startMonster = function (builder) { - builder.startObject(30); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} posOffset - */ - Monster.addPos = function (builder, posOffset) { - builder.addFieldStruct(0, posOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} mana - */ - Monster.addMana = function (builder, mana) { - builder.addFieldInt16(1, mana, 150); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} hp - */ - Monster.addHp = function (builder, hp) { - builder.addFieldInt16(2, hp, 100); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} nameOffset - */ - Monster.addName = function (builder, nameOffset) { - builder.addFieldOffset(3, nameOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} inventoryOffset - */ - Monster.addInventory = function (builder, inventoryOffset) { - builder.addFieldOffset(5, inventoryOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ - Monster.createInventoryVector = function (builder, data) { - if (!data) { - return null; - } - builder.startVector(1, data.length, 1); - for (var i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startInventoryVector = function (builder, numElems) { - builder.startVector(1, numElems, 1); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {MyGame.Example.Color} color - */ - Monster.addColor = function (builder, color) { - builder.addFieldInt8(6, color, MyGame.Example.Color.Blue); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {MyGame.Example.Any} testType - */ - Monster.addTestType = function (builder, testType) { - builder.addFieldInt8(7, testType, MyGame.Example.Any.NONE); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testOffset - */ - Monster.addTest = function (builder, testOffset) { - builder.addFieldOffset(8, testOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} test4Offset - */ - Monster.addTest4 = function (builder, test4Offset) { - builder.addFieldOffset(9, test4Offset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startTest4Vector = function (builder, numElems) { - builder.startVector(4, numElems, 2); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofstringOffset - */ - Monster.addTestarrayofstring = function (builder, testarrayofstringOffset) { - builder.addFieldOffset(10, testarrayofstringOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ - Monster.createTestarrayofstringVector = function (builder, data) { - if (!data) { - return null; - } - builder.startVector(4, data.length, 4); - for (var i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]); - } - return builder.endVector(); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startTestarrayofstringVector = function (builder, numElems) { - builder.startVector(4, numElems, 4); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayoftablesOffset - */ - Monster.addTestarrayoftables = function (builder, testarrayoftablesOffset) { - builder.addFieldOffset(11, testarrayoftablesOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ - Monster.createTestarrayoftablesVector = function (builder, data) { - if (!data) { - return null; - } - builder.startVector(4, data.length, 4); - for (var i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]); - } - return builder.endVector(); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startTestarrayoftablesVector = function (builder, numElems) { - builder.startVector(4, numElems, 4); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} enemyOffset - */ - Monster.addEnemy = function (builder, enemyOffset) { - builder.addFieldOffset(12, enemyOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testnestedflatbufferOffset - */ - Monster.addTestnestedflatbuffer = function (builder, testnestedflatbufferOffset) { - builder.addFieldOffset(13, testnestedflatbufferOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ - Monster.createTestnestedflatbufferVector = function (builder, data) { - if (!data) { - return null; - } - builder.startVector(1, data.length, 1); - for (var i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]); - } - return builder.endVector(); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startTestnestedflatbufferVector = function (builder, numElems) { - builder.startVector(1, numElems, 1); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testemptyOffset - */ - Monster.addTestempty = function (builder, testemptyOffset) { - builder.addFieldOffset(14, testemptyOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {boolean} testbool - */ - Monster.addTestbool = function (builder, testbool) { - builder.addFieldInt8(15, +testbool, +false); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} testhashs32Fnv1 - */ - Monster.addTesthashs32Fnv1 = function (builder, testhashs32Fnv1) { - builder.addFieldInt32(16, testhashs32Fnv1, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} testhashu32Fnv1 - */ - Monster.addTesthashu32Fnv1 = function (builder, testhashu32Fnv1) { - builder.addFieldInt32(17, testhashu32Fnv1, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashs64Fnv1 - */ - Monster.addTesthashs64Fnv1 = function (builder, testhashs64Fnv1) { - builder.addFieldInt64(18, testhashs64Fnv1, builder.createLong(0, 0)); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashu64Fnv1 - */ - Monster.addTesthashu64Fnv1 = function (builder, testhashu64Fnv1) { - builder.addFieldInt64(19, testhashu64Fnv1, builder.createLong(0, 0)); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} testhashs32Fnv1a - */ - Monster.addTesthashs32Fnv1a = function (builder, testhashs32Fnv1a) { - builder.addFieldInt32(20, testhashs32Fnv1a, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} testhashu32Fnv1a - */ - Monster.addTesthashu32Fnv1a = function (builder, testhashu32Fnv1a) { - builder.addFieldInt32(21, testhashu32Fnv1a, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashs64Fnv1a - */ - Monster.addTesthashs64Fnv1a = function (builder, testhashs64Fnv1a) { - builder.addFieldInt64(22, testhashs64Fnv1a, builder.createLong(0, 0)); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Long} testhashu64Fnv1a - */ - Monster.addTesthashu64Fnv1a = function (builder, testhashu64Fnv1a) { - builder.addFieldInt64(23, testhashu64Fnv1a, builder.createLong(0, 0)); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofboolsOffset - */ - Monster.addTestarrayofbools = function (builder, testarrayofboolsOffset) { - builder.addFieldOffset(24, testarrayofboolsOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ - Monster.createTestarrayofboolsVector = function (builder, data) { - if (!data) { - return null; - } - builder.startVector(1, data.length, 1); - for (var i = data.length - 1; i >= 0; i--) { - builder.addInt8(+data[i]); - } - return builder.endVector(); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startTestarrayofboolsVector = function (builder, numElems) { - builder.startVector(1, numElems, 1); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} testf - */ - Monster.addTestf = function (builder, testf) { - builder.addFieldFloat32(25, testf, 3.14159); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} testf2 - */ - Monster.addTestf2 = function (builder, testf2) { - builder.addFieldFloat32(26, testf2, 3.0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} testf3 - */ - Monster.addTestf3 = function (builder, testf3) { - builder.addFieldFloat32(27, testf3, 0.0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofstring2Offset - */ - Monster.addTestarrayofstring2 = function (builder, testarrayofstring2Offset) { - builder.addFieldOffset(28, testarrayofstring2Offset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {Array.} data - * @returns {flatbuffers.Offset} - */ - Monster.createTestarrayofstring2Vector = function (builder, data) { - if (!data) { - return null; - } - builder.startVector(4, data.length, 4); - for (var i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]); - } - return builder.endVector(); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startTestarrayofstring2Vector = function (builder, numElems) { - builder.startVector(4, numElems, 4); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} testarrayofsortedstructOffset - */ - Monster.addTestarrayofsortedstruct = function (builder, testarrayofsortedstructOffset) { - builder.addFieldOffset(29, testarrayofsortedstructOffset, 0); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {number} numElems - */ - Monster.startTestarrayofsortedstructVector = function (builder, numElems) { - builder.startVector(8, numElems, 4); - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @returns {flatbuffers.Offset} - */ - Monster.endMonster = function (builder) { - var offset = builder.endObject(); - builder.requiredField(offset, 10); // name - return offset; - }; - ; - /** - * @param {flatbuffers.Builder} builder - * @param {flatbuffers.Offset} offset - */ - Monster.finishMonsterBuffer = function (builder, offset) { - builder.finish(offset, 'MONS'); - }; - ; - return Monster; - }()); - Example.Monster = Monster; - })(Example = MyGame.Example || (MyGame.Example = {})); -})(MyGame = exports.MyGame || (exports.MyGame = {})); +MyGame.Example.Monster = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example.Monster} + */ +MyGame.Example.Monster.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {MyGame.Example.Monster=} obj + * @returns {MyGame.Example.Monster} + */ +MyGame.Example.Monster.getRootAsMonster = function(bb, obj) { + return (obj || new MyGame.Example.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @returns {boolean} + */ +MyGame.Example.Monster.bufferHasIdentifier = function(bb) { + return bb.__has_identifier('MONS'); +}; + +/** + * @param {MyGame.Example.Vec3=} obj + * @returns {MyGame.Example.Vec3} + */ +MyGame.Example.Monster.prototype.pos = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb) : null; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.mana = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 150; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_mana = function(value) { + var offset = this.bb.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.hp = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 100; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_hp = function(value) { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +MyGame.Example.Monster.prototype.name = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +MyGame.Example.Monster.prototype.inventory = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.inventoryLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +MyGame.Example.Monster.prototype.inventoryArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {MyGame.Example.Color} + */ +MyGame.Example.Monster.prototype.color = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Blue; +}; + +/** + * @param {MyGame.Example.Color} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_color = function(value) { + var offset = this.bb.__offset(this.bb_pos, 16); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {MyGame.Example.Any} + */ +MyGame.Example.Monster.prototype.testType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? /** @type {MyGame.Example.Any} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE; +}; + +/** + * @param {MyGame.Example.Any} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_test_type = function(value) { + var offset = this.bb.__offset(this.bb_pos, 18); + + if (offset === 0) { + return false; + } + + this.bb.writeUint8(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {flatbuffers.Table} obj + * @returns {?flatbuffers.Table} + */ +MyGame.Example.Monster.prototype.test = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__union(obj, this.bb_pos + offset) : null; +}; + +/** + * @param {number} index + * @param {MyGame.Example.Test=} obj + * @returns {MyGame.Example.Test} + */ +MyGame.Example.Monster.prototype.test4 = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.test4Length = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +MyGame.Example.Monster.prototype.testarrayofstring = function(index, optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testarrayofstringLength = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * an example documentation comment: this will end up in the generated code + * multiline too + * + * @param {number} index + * @param {MyGame.Example.Monster=} obj + * @returns {MyGame.Example.Monster} + */ +MyGame.Example.Monster.prototype.testarrayoftables = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testarrayoftablesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {MyGame.Example.Monster=} obj + * @returns {MyGame.Example.Monster} + */ +MyGame.Example.Monster.prototype.enemy = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +MyGame.Example.Monster.prototype.testnestedflatbuffer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testnestedflatbufferLength = function() { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +MyGame.Example.Monster.prototype.testnestedflatbufferArray = function() { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {MyGame.Example.Stat=} obj + * @returns {MyGame.Example.Stat} + */ +MyGame.Example.Monster.prototype.testempty = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 32); + return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.testbool = function() { + var offset = this.bb.__offset(this.bb_pos, 34); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; +}; + +/** + * @param {boolean} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testbool = function(value) { + var offset = this.bb.__offset(this.bb_pos, 34); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testhashs32Fnv1 = function() { + var offset = this.bb.__offset(this.bb_pos, 36); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashs32_fnv1 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 36); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testhashu32Fnv1 = function() { + var offset = this.bb.__offset(this.bb_pos, 38); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashu32_fnv1 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 38); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +MyGame.Example.Monster.prototype.testhashs64Fnv1 = function() { + var offset = this.bb.__offset(this.bb_pos, 40); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashs64_fnv1 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 40); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +MyGame.Example.Monster.prototype.testhashu64Fnv1 = function() { + var offset = this.bb.__offset(this.bb_pos, 42); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashu64_fnv1 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 42); + + if (offset === 0) { + return false; + } + + this.bb.writeUint64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testhashs32Fnv1a = function() { + var offset = this.bb.__offset(this.bb_pos, 44); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashs32_fnv1a = function(value) { + var offset = this.bb.__offset(this.bb_pos, 44); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testhashu32Fnv1a = function() { + var offset = this.bb.__offset(this.bb_pos, 46); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashu32_fnv1a = function(value) { + var offset = this.bb.__offset(this.bb_pos, 46); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +MyGame.Example.Monster.prototype.testhashs64Fnv1a = function() { + var offset = this.bb.__offset(this.bb_pos, 48); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashs64_fnv1a = function(value) { + var offset = this.bb.__offset(this.bb_pos, 48); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +MyGame.Example.Monster.prototype.testhashu64Fnv1a = function() { + var offset = this.bb.__offset(this.bb_pos, 50); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testhashu64_fnv1a = function(value) { + var offset = this.bb.__offset(this.bb_pos, 50); + + if (offset === 0) { + return false; + } + + this.bb.writeUint64(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {number} index + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.testarrayofbools = function(index) { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testarrayofboolsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Int8Array} + */ +MyGame.Example.Monster.prototype.testarrayofboolsArray = function() { + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testf = function() { + var offset = this.bb.__offset(this.bb_pos, 54); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.14159; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testf = function(value) { + var offset = this.bb.__offset(this.bb_pos, 54); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testf2 = function() { + var offset = this.bb.__offset(this.bb_pos, 56); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testf2 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 56); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testf3 = function() { + var offset = this.bb.__offset(this.bb_pos, 58); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.Monster.prototype.mutate_testf3 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 58); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {number} index + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +MyGame.Example.Monster.prototype.testarrayofstring2 = function(index, optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testarrayofstring2Length = function() { + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {MyGame.Example.Ability=} obj + * @returns {MyGame.Example.Ability} + */ +MyGame.Example.Monster.prototype.testarrayofsortedstruct = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? (obj || new MyGame.Example.Ability).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; +}; + +/** + * @returns {number} + */ +MyGame.Example.Monster.prototype.testarrayofsortedstructLength = function() { + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +MyGame.Example.Monster.startMonster = function(builder) { + builder.startObject(30); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} posOffset + */ +MyGame.Example.Monster.addPos = function(builder, posOffset) { + builder.addFieldStruct(0, posOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} mana + */ +MyGame.Example.Monster.addMana = function(builder, mana) { + builder.addFieldInt16(1, mana, 150); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} hp + */ +MyGame.Example.Monster.addHp = function(builder, hp) { + builder.addFieldInt16(2, hp, 100); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} nameOffset + */ +MyGame.Example.Monster.addName = function(builder, nameOffset) { + builder.addFieldOffset(3, nameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} inventoryOffset + */ +MyGame.Example.Monster.addInventory = function(builder, inventoryOffset) { + builder.addFieldOffset(5, inventoryOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Monster.createInventoryVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startInventoryVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Color} color + */ +MyGame.Example.Monster.addColor = function(builder, color) { + builder.addFieldInt8(6, color, MyGame.Example.Color.Blue); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {MyGame.Example.Any} testType + */ +MyGame.Example.Monster.addTestType = function(builder, testType) { + builder.addFieldInt8(7, testType, MyGame.Example.Any.NONE); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testOffset + */ +MyGame.Example.Monster.addTest = function(builder, testOffset) { + builder.addFieldOffset(8, testOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} test4Offset + */ +MyGame.Example.Monster.addTest4 = function(builder, test4Offset) { + builder.addFieldOffset(9, test4Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startTest4Vector = function(builder, numElems) { + builder.startVector(4, numElems, 2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofstringOffset + */ +MyGame.Example.Monster.addTestarrayofstring = function(builder, testarrayofstringOffset) { + builder.addFieldOffset(10, testarrayofstringOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Monster.createTestarrayofstringVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startTestarrayofstringVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayoftablesOffset + */ +MyGame.Example.Monster.addTestarrayoftables = function(builder, testarrayoftablesOffset) { + builder.addFieldOffset(11, testarrayoftablesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Monster.createTestarrayoftablesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startTestarrayoftablesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} enemyOffset + */ +MyGame.Example.Monster.addEnemy = function(builder, enemyOffset) { + builder.addFieldOffset(12, enemyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testnestedflatbufferOffset + */ +MyGame.Example.Monster.addTestnestedflatbuffer = function(builder, testnestedflatbufferOffset) { + builder.addFieldOffset(13, testnestedflatbufferOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Monster.createTestnestedflatbufferVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startTestnestedflatbufferVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testemptyOffset + */ +MyGame.Example.Monster.addTestempty = function(builder, testemptyOffset) { + builder.addFieldOffset(14, testemptyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} testbool + */ +MyGame.Example.Monster.addTestbool = function(builder, testbool) { + builder.addFieldInt8(15, +testbool, +false); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashs32Fnv1 + */ +MyGame.Example.Monster.addTesthashs32Fnv1 = function(builder, testhashs32Fnv1) { + builder.addFieldInt32(16, testhashs32Fnv1, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashu32Fnv1 + */ +MyGame.Example.Monster.addTesthashu32Fnv1 = function(builder, testhashu32Fnv1) { + builder.addFieldInt32(17, testhashu32Fnv1, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashs64Fnv1 + */ +MyGame.Example.Monster.addTesthashs64Fnv1 = function(builder, testhashs64Fnv1) { + builder.addFieldInt64(18, testhashs64Fnv1, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashu64Fnv1 + */ +MyGame.Example.Monster.addTesthashu64Fnv1 = function(builder, testhashu64Fnv1) { + builder.addFieldInt64(19, testhashu64Fnv1, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashs32Fnv1a + */ +MyGame.Example.Monster.addTesthashs32Fnv1a = function(builder, testhashs32Fnv1a) { + builder.addFieldInt32(20, testhashs32Fnv1a, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testhashu32Fnv1a + */ +MyGame.Example.Monster.addTesthashu32Fnv1a = function(builder, testhashu32Fnv1a) { + builder.addFieldInt32(21, testhashu32Fnv1a, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashs64Fnv1a + */ +MyGame.Example.Monster.addTesthashs64Fnv1a = function(builder, testhashs64Fnv1a) { + builder.addFieldInt64(22, testhashs64Fnv1a, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} testhashu64Fnv1a + */ +MyGame.Example.Monster.addTesthashu64Fnv1a = function(builder, testhashu64Fnv1a) { + builder.addFieldInt64(23, testhashu64Fnv1a, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofboolsOffset + */ +MyGame.Example.Monster.addTestarrayofbools = function(builder, testarrayofboolsOffset) { + builder.addFieldOffset(24, testarrayofboolsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Monster.createTestarrayofboolsVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(+data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startTestarrayofboolsVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testf + */ +MyGame.Example.Monster.addTestf = function(builder, testf) { + builder.addFieldFloat32(25, testf, 3.14159); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testf2 + */ +MyGame.Example.Monster.addTestf2 = function(builder, testf2) { + builder.addFieldFloat32(26, testf2, 3.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} testf3 + */ +MyGame.Example.Monster.addTestf3 = function(builder, testf3) { + builder.addFieldFloat32(27, testf3, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofstring2Offset + */ +MyGame.Example.Monster.addTestarrayofstring2 = function(builder, testarrayofstring2Offset) { + builder.addFieldOffset(28, testarrayofstring2Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Monster.createTestarrayofstring2Vector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startTestarrayofstring2Vector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} testarrayofsortedstructOffset + */ +MyGame.Example.Monster.addTestarrayofsortedstruct = function(builder, testarrayofsortedstructOffset) { + builder.addFieldOffset(29, testarrayofsortedstructOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.Monster.startTestarrayofsortedstructVector = function(builder, numElems) { + builder.startVector(8, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +MyGame.Example.Monster.endMonster = function(builder) { + var offset = builder.endObject(); + builder.requiredField(offset, 10); // name + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +MyGame.Example.Monster.finishMonsterBuffer = function(builder, offset) { + builder.finish(offset, 'MONS'); +}; + +// Exports for Node.js and RequireJS +this.MyGame = MyGame; From a9c306c263678cc4ba7dfefd4be651d18afcaaa2 Mon Sep 17 00:00:00 2001 From: Kamil Rojewski Date: Fri, 7 Apr 2017 20:48:02 +0200 Subject: [PATCH 17/17] Backing up js tests and properly generating test data --- tests/TypeScriptTest.sh | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/TypeScriptTest.sh b/tests/TypeScriptTest.sh index 8576c7312ba..4e37451c670 100755 --- a/tests/TypeScriptTest.sh +++ b/tests/TypeScriptTest.sh @@ -15,8 +15,11 @@ # limitations under the License. pushd "$(dirname $0)" >/dev/null -../flatc --ts --no-fb-import --gen-mutable monster_test.fbs unicode_test.json +../flatc --ts --no-fb-import --gen-mutable monster_test.fbs +../flatc -b monster_test.fbs unicode_test.json npm install @types/flatbuffers +mv monster_test_generated.js monster_test_generated.js.bak tsc monster_test_generated.ts npm uninstall @types/flatbuffers node JavaScriptTest +mv monster_test_generated.js.bak monster_test_generated.js