From 9bb88a026aa3423c2c97c5e74c60f404e62cc688 Mon Sep 17 00:00:00 2001 From: Tobias Oberstein Date: Fri, 27 Apr 2018 22:31:18 +0200 Subject: [PATCH] Include services in reflection data (fixes #4639) (#4713) * include service in reflection data (fixes #4639) * changes from review * regenerated test data --- .gitignore | 1 + include/flatbuffers/idl.h | 16 +- include/flatbuffers/reflection_generated.h | 258 +++++++++++++++++- reflection/generate_code.sh | 0 reflection/reflection.fbs | 21 +- src/flatc.cpp | 3 + src/idl_gen_grpc.cpp | 2 +- src/idl_parser.cpp | 98 +++++-- tests/monster_test.bfbs | Bin 6104 -> 6352 bytes .../namespace_test2_generated.ts | 20 +- 10 files changed, 367 insertions(+), 52 deletions(-) mode change 100644 => 100755 reflection/generate_code.sh diff --git a/.gitignore b/.gitignore index c1011c388..f5ff92c2a 100644 --- a/.gitignore +++ b/.gitignore @@ -93,3 +93,4 @@ js/flatbuffers.mjs .ninja_log build.ninja rules.ninja +.vscode diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 4c4bcc3b4..ca24ef445 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -306,7 +306,7 @@ inline size_t InlineAlignment(const Type &type) { struct EnumVal { EnumVal(const std::string &_name, int64_t _val) : name(_name), value(_val) {} - Offset Serialize(FlatBufferBuilder *builder) const; + Offset Serialize(FlatBufferBuilder *builder, const Parser &parser) const; std::string name; std::vector doc_comment; @@ -326,8 +326,7 @@ struct EnumDef : public Definition { return nullptr; } - Offset Serialize(FlatBufferBuilder *builder, - const Parser &parser) const; + Offset Serialize(FlatBufferBuilder *builder, const Parser &parser) const; SymbolTable vals; bool is_union; @@ -342,14 +341,15 @@ inline bool EqualByName(const Type &a, const Type &b) { (a.enum_def == b.enum_def || a.enum_def->name == b.enum_def->name); } -struct RPCCall { - std::string name; - SymbolTable attributes; +struct RPCCall : public Definition { + Offset Serialize(FlatBufferBuilder *builder, const Parser &parser) const; + StructDef *request, *response; - std::vector rpc_comment; }; struct ServiceDef : public Definition { + Offset Serialize(FlatBufferBuilder *builder, const Parser &parser) const; + SymbolTable calls; }; @@ -382,6 +382,7 @@ struct IDLOptions { std::string include_prefix; bool keep_include_path; bool binary_schema_comments; + bool binary_schema_builtins; bool skip_flatbuffers_import; std::string go_import; std::string go_namespace; @@ -440,6 +441,7 @@ struct IDLOptions { allow_non_utf8(false), keep_include_path(false), binary_schema_comments(false), + binary_schema_builtins(false), skip_flatbuffers_import(false), reexport_ts_modules(true), protobuf_ascii_alike(false), diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h index 2cc21bb38..5362fefe5 100644 --- a/include/flatbuffers/reflection_generated.h +++ b/include/flatbuffers/reflection_generated.h @@ -20,6 +20,10 @@ struct Field; struct Object; +struct RPCCall; + +struct Service; + struct Schema; enum BaseType { @@ -228,7 +232,8 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_NAME = 4, VT_VALUE = 6, VT_OBJECT = 8, - VT_UNION_TYPE = 10 + VT_UNION_TYPE = 10, + VT_DOCUMENTATION = 12 }; const flatbuffers::String *name() const { return GetPointer(VT_NAME); @@ -255,6 +260,9 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const Type *union_type() const { return GetPointer(VT_UNION_TYPE); } + const flatbuffers::Vector> *documentation() const { + return GetPointer> *>(VT_DOCUMENTATION); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_NAME) && @@ -264,6 +272,9 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyTable(object()) && VerifyOffset(verifier, VT_UNION_TYPE) && verifier.VerifyTable(union_type()) && + VerifyOffset(verifier, VT_DOCUMENTATION) && + verifier.Verify(documentation()) && + verifier.VerifyVectorOfStrings(documentation()) && verifier.EndTable(); } }; @@ -283,6 +294,9 @@ struct EnumValBuilder { void add_union_type(flatbuffers::Offset union_type) { fbb_.AddOffset(EnumVal::VT_UNION_TYPE, union_type); } + void add_documentation(flatbuffers::Offset>> documentation) { + fbb_.AddOffset(EnumVal::VT_DOCUMENTATION, documentation); + } explicit EnumValBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -301,9 +315,11 @@ inline flatbuffers::Offset CreateEnumVal( flatbuffers::Offset name = 0, int64_t value = 0, flatbuffers::Offset object = 0, - flatbuffers::Offset union_type = 0) { + flatbuffers::Offset union_type = 0, + flatbuffers::Offset>> documentation = 0) { EnumValBuilder builder_(_fbb); builder_.add_value(value); + builder_.add_documentation(documentation); builder_.add_union_type(union_type); builder_.add_object(object); builder_.add_name(name); @@ -315,13 +331,15 @@ inline flatbuffers::Offset CreateEnumValDirect( const char *name = nullptr, int64_t value = 0, flatbuffers::Offset object = 0, - flatbuffers::Offset union_type = 0) { + flatbuffers::Offset union_type = 0, + const std::vector> *documentation = nullptr) { return reflection::CreateEnumVal( _fbb, name ? _fbb.CreateString(name) : 0, value, object, - union_type); + union_type, + documentation ? _fbb.CreateVector>(*documentation) : 0); } struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -766,13 +784,224 @@ inline flatbuffers::Offset CreateObjectDirect( documentation ? _fbb.CreateVector>(*documentation) : 0); } +struct RPCCall FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum { + VT_NAME = 4, + VT_REQUEST = 6, + VT_RESPONSE = 8, + VT_ATTRIBUTES = 10, + VT_DOCUMENTATION = 12 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const RPCCall *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *val) const { + return strcmp(name()->c_str(), val); + } + const Object *request() const { + return GetPointer(VT_REQUEST); + } + const Object *response() const { + return GetPointer(VT_RESPONSE); + } + const flatbuffers::Vector> *attributes() const { + return GetPointer> *>(VT_ATTRIBUTES); + } + const flatbuffers::Vector> *documentation() const { + return GetPointer> *>(VT_DOCUMENTATION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.Verify(name()) && + VerifyOffsetRequired(verifier, VT_REQUEST) && + verifier.VerifyTable(request()) && + VerifyOffsetRequired(verifier, VT_RESPONSE) && + verifier.VerifyTable(response()) && + VerifyOffset(verifier, VT_ATTRIBUTES) && + verifier.Verify(attributes()) && + verifier.VerifyVectorOfTables(attributes()) && + VerifyOffset(verifier, VT_DOCUMENTATION) && + verifier.Verify(documentation()) && + verifier.VerifyVectorOfStrings(documentation()) && + verifier.EndTable(); + } +}; + +struct RPCCallBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(RPCCall::VT_NAME, name); + } + void add_request(flatbuffers::Offset request) { + fbb_.AddOffset(RPCCall::VT_REQUEST, request); + } + void add_response(flatbuffers::Offset response) { + fbb_.AddOffset(RPCCall::VT_RESPONSE, response); + } + void add_attributes(flatbuffers::Offset>> attributes) { + fbb_.AddOffset(RPCCall::VT_ATTRIBUTES, attributes); + } + void add_documentation(flatbuffers::Offset>> documentation) { + fbb_.AddOffset(RPCCall::VT_DOCUMENTATION, documentation); + } + explicit RPCCallBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RPCCallBuilder &operator=(const RPCCallBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, RPCCall::VT_NAME); + fbb_.Required(o, RPCCall::VT_REQUEST); + fbb_.Required(o, RPCCall::VT_RESPONSE); + return o; + } +}; + +inline flatbuffers::Offset CreateRPCCall( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + flatbuffers::Offset request = 0, + flatbuffers::Offset response = 0, + flatbuffers::Offset>> attributes = 0, + flatbuffers::Offset>> documentation = 0) { + RPCCallBuilder builder_(_fbb); + builder_.add_documentation(documentation); + builder_.add_attributes(attributes); + builder_.add_response(response); + builder_.add_request(request); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateRPCCallDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + flatbuffers::Offset request = 0, + flatbuffers::Offset response = 0, + const std::vector> *attributes = nullptr, + const std::vector> *documentation = nullptr) { + return reflection::CreateRPCCall( + _fbb, + name ? _fbb.CreateString(name) : 0, + request, + response, + attributes ? _fbb.CreateVector>(*attributes) : 0, + documentation ? _fbb.CreateVector>(*documentation) : 0); +} + +struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum { + VT_NAME = 4, + VT_CALLS = 6, + VT_ATTRIBUTES = 8, + VT_DOCUMENTATION = 10 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Service *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *val) const { + return strcmp(name()->c_str(), val); + } + const flatbuffers::Vector> *calls() const { + return GetPointer> *>(VT_CALLS); + } + const flatbuffers::Vector> *attributes() const { + return GetPointer> *>(VT_ATTRIBUTES); + } + const flatbuffers::Vector> *documentation() const { + return GetPointer> *>(VT_DOCUMENTATION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.Verify(name()) && + VerifyOffset(verifier, VT_CALLS) && + verifier.Verify(calls()) && + verifier.VerifyVectorOfTables(calls()) && + VerifyOffset(verifier, VT_ATTRIBUTES) && + verifier.Verify(attributes()) && + verifier.VerifyVectorOfTables(attributes()) && + VerifyOffset(verifier, VT_DOCUMENTATION) && + verifier.Verify(documentation()) && + verifier.VerifyVectorOfStrings(documentation()) && + verifier.EndTable(); + } +}; + +struct ServiceBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(Service::VT_NAME, name); + } + void add_calls(flatbuffers::Offset>> calls) { + fbb_.AddOffset(Service::VT_CALLS, calls); + } + void add_attributes(flatbuffers::Offset>> attributes) { + fbb_.AddOffset(Service::VT_ATTRIBUTES, attributes); + } + void add_documentation(flatbuffers::Offset>> documentation) { + fbb_.AddOffset(Service::VT_DOCUMENTATION, documentation); + } + explicit ServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ServiceBuilder &operator=(const ServiceBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Service::VT_NAME); + return o; + } +}; + +inline flatbuffers::Offset CreateService( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + flatbuffers::Offset>> calls = 0, + flatbuffers::Offset>> attributes = 0, + flatbuffers::Offset>> documentation = 0) { + ServiceBuilder builder_(_fbb); + builder_.add_documentation(documentation); + builder_.add_attributes(attributes); + builder_.add_calls(calls); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateServiceDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const std::vector> *calls = nullptr, + const std::vector> *attributes = nullptr, + const std::vector> *documentation = nullptr) { + return reflection::CreateService( + _fbb, + name ? _fbb.CreateString(name) : 0, + calls ? _fbb.CreateVector>(*calls) : 0, + attributes ? _fbb.CreateVector>(*attributes) : 0, + documentation ? _fbb.CreateVector>(*documentation) : 0); +} + struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { enum { VT_OBJECTS = 4, VT_ENUMS = 6, VT_FILE_IDENT = 8, VT_FILE_EXT = 10, - VT_ROOT_TABLE = 12 + VT_ROOT_TABLE = 12, + VT_SERVICES = 14 }; const flatbuffers::Vector> *objects() const { return GetPointer> *>(VT_OBJECTS); @@ -789,6 +1018,9 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const Object *root_table() const { return GetPointer(VT_ROOT_TABLE); } + const flatbuffers::Vector> *services() const { + return GetPointer> *>(VT_SERVICES); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_OBJECTS) && @@ -803,6 +1035,9 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.Verify(file_ext()) && VerifyOffset(verifier, VT_ROOT_TABLE) && verifier.VerifyTable(root_table()) && + VerifyOffset(verifier, VT_SERVICES) && + verifier.Verify(services()) && + verifier.VerifyVectorOfTables(services()) && verifier.EndTable(); } }; @@ -825,6 +1060,9 @@ struct SchemaBuilder { void add_root_table(flatbuffers::Offset root_table) { fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table); } + void add_services(flatbuffers::Offset>> services) { + fbb_.AddOffset(Schema::VT_SERVICES, services); + } explicit SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -845,8 +1083,10 @@ inline flatbuffers::Offset CreateSchema( flatbuffers::Offset>> enums = 0, flatbuffers::Offset file_ident = 0, flatbuffers::Offset file_ext = 0, - flatbuffers::Offset root_table = 0) { + flatbuffers::Offset root_table = 0, + flatbuffers::Offset>> services = 0) { SchemaBuilder builder_(_fbb); + builder_.add_services(services); builder_.add_root_table(root_table); builder_.add_file_ext(file_ext); builder_.add_file_ident(file_ident); @@ -861,14 +1101,16 @@ inline flatbuffers::Offset CreateSchemaDirect( const std::vector> *enums = nullptr, const char *file_ident = nullptr, const char *file_ext = nullptr, - flatbuffers::Offset root_table = 0) { + flatbuffers::Offset root_table = 0, + const std::vector> *services = nullptr) { return reflection::CreateSchema( _fbb, objects ? _fbb.CreateVector>(*objects) : 0, enums ? _fbb.CreateVector>(*enums) : 0, file_ident ? _fbb.CreateString(file_ident) : 0, file_ext ? _fbb.CreateString(file_ext) : 0, - root_table); + root_table, + services ? _fbb.CreateVector>(*services) : 0); } inline const reflection::Schema *GetSchema(const void *buf) { diff --git a/reflection/generate_code.sh b/reflection/generate_code.sh old mode 100644 new mode 100755 diff --git a/reflection/reflection.fbs b/reflection/reflection.fbs index ea41891c3..a344d7b86 100644 --- a/reflection/reflection.fbs +++ b/reflection/reflection.fbs @@ -44,6 +44,7 @@ table EnumVal { value:long (key); object:Object; // Will be deprecated in favor of union_type in the future. union_type:Type; + documentation:[string]; } table Enum { @@ -79,12 +80,28 @@ table Object { // Used for both tables and structs. documentation:[string]; } +table RPCCall { + name:string (required, key); + request:Object (required); // must be a table (not a struct) + response:Object (required); // must be a table (not a struct) + attributes:[KeyValue]; + documentation:[string]; +} + +table Service { + name:string (required, key); + calls:[RPCCall]; + attributes:[KeyValue]; + documentation:[string]; +} + table Schema { - objects:[Object] (required); // Sorted. - enums:[Enum] (required); // Sorted. + objects:[Object] (required); // Sorted. + enums:[Enum] (required); // Sorted. file_ident:string; file_ext:string; root_table:Object; + services:[Service]; // Sorted. } root_type Schema; diff --git a/src/flatc.cpp b/src/flatc.cpp index 8e4906f82..60fabd50b 100644 --- a/src/flatc.cpp +++ b/src/flatc.cpp @@ -106,6 +106,7 @@ std::string FlatCompiler::GetUsageString(const char *program_name) const { " --grpc Generate GRPC interfaces for the specified languages\n" " --schema Serialize schemas instead of JSON (use with -b)\n" " --bfbs-comments Add doc comments to the binary schema files.\n" + " --bfbs-builtins Add builtin attributes to the binary schema files.\n" " --conform FILE Specify a schema the following schemas should be\n" " an evolution of. Gives errors if not.\n" " --conform-includes Include path for the schema given with --conform\n" @@ -253,6 +254,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 == "--bfbs-builtins") { + opts.binary_schema_builtins = true; } else if (arg == "--no-fb-import") { opts.skip_flatbuffers_import = true; } else if (arg == "--no-ts-reexport") { diff --git a/src/idl_gen_grpc.cpp b/src/idl_gen_grpc.cpp index 02994bda0..b01593417 100644 --- a/src/idl_gen_grpc.cpp +++ b/src/idl_gen_grpc.cpp @@ -50,7 +50,7 @@ class FlatBufMethod : public grpc_generator::Method { grpc::string GetLeadingComments(const grpc::string) const { return ""; } grpc::string GetTrailingComments(const grpc::string) const { return ""; } std::vector GetAllComments() const { - return method_->rpc_comment; + return method_->doc_comment; } std::string name() const { return method_->name; } diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index c0fe5335f..3102cd61f 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -1724,7 +1724,7 @@ CheckedError Parser::ParseService() { ECHECK(ParseMetaData(&service_def.attributes)); EXPECT('{'); do { - std::vector rpc_comment = doc_comment_; + std::vector doc_comment = doc_comment_; auto rpc_name = attribute_; EXPECT(kTokenIdentifier); EXPECT('('); @@ -1740,7 +1740,7 @@ CheckedError Parser::ParseService() { rpc.name = rpc_name; rpc.request = reqtype.struct_def; rpc.response = resptype.struct_def; - rpc.rpc_comment = rpc_comment; + rpc.doc_comment = doc_comment; if (service_def.calls.Add(rpc_name, &rpc)) return Error("rpc already exists: " + rpc_name); ECHECK(ParseMetaData(&rpc.attributes)); @@ -2527,12 +2527,20 @@ void Parser::Serialize() { enum_offsets.push_back(offset); (*it)->serialized_location = offset.o; } + std::vector> service_offsets; + for (auto it = services_.vec.begin(); it != services_.vec.end(); ++it) { + auto offset = (*it)->Serialize(&builder_, *this); + service_offsets.push_back(offset); + (*it)->serialized_location = offset.o; + } auto schema_offset = reflection::CreateSchema( - builder_, builder_.CreateVectorOfSortedTables(&object_offsets), + builder_, + builder_.CreateVectorOfSortedTables(&object_offsets), builder_.CreateVectorOfSortedTables(&enum_offsets), builder_.CreateString(file_identifier_), builder_.CreateString(file_extension_), - root_struct_def_ ? root_struct_def_->serialized_location : 0); + (root_struct_def_ ? root_struct_def_->serialized_location : 0), + builder_.CreateVectorOfSortedTables(&service_offsets)); if (opts.size_prefixed) { builder_.FinishSizePrefixed(schema_offset, reflection::SchemaIdentifier()); } else { @@ -2549,9 +2557,12 @@ Offset StructDef::Serialize(FlatBufferBuilder *builder, } auto qualified_name = defined_namespace->GetFullyQualifiedName(name); return reflection::CreateObject( - *builder, builder->CreateString(qualified_name), - builder->CreateVectorOfSortedTables(&field_offsets), fixed, - static_cast(minalign), static_cast(bytesize), + *builder, + builder->CreateString(qualified_name), + builder->CreateVectorOfSortedTables(&field_offsets), + fixed, + static_cast(minalign), + static_cast(bytesize), SerializeAttributes(builder, parser), parser.opts.binary_schema_comments ? builder->CreateVectorOfStrings(doc_comment) @@ -2575,33 +2586,72 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, // space by sharing it. Same for common values of value.type. } -Offset EnumDef::Serialize(FlatBufferBuilder *builder, - const Parser &parser) const { - std::vector> enumval_offsets; - for (auto it = vals.vec.begin(); it != vals.vec.end(); ++it) { - enumval_offsets.push_back((*it)->Serialize(builder)); - } - auto qualified_name = defined_namespace->GetFullyQualifiedName(name); - return reflection::CreateEnum( - *builder, builder->CreateString(qualified_name), - builder->CreateVector(enumval_offsets), is_union, - underlying_type.Serialize(builder), SerializeAttributes(builder, parser), +Offset RPCCall::Serialize(FlatBufferBuilder *builder, + const Parser &parser) const { + return reflection::CreateRPCCall( + *builder, + builder->CreateString(name), + request->serialized_location, + response->serialized_location, + SerializeAttributes(builder, parser), parser.opts.binary_schema_comments ? builder->CreateVectorOfStrings(doc_comment) : 0); } -Offset EnumVal::Serialize( - FlatBufferBuilder *builder) const { +Offset ServiceDef::Serialize(FlatBufferBuilder *builder, + const Parser &parser) const { + std::vector> servicecall_offsets; + for (auto it = calls.vec.begin(); it != calls.vec.end(); ++it) { + servicecall_offsets.push_back((*it)->Serialize(builder, parser)); + } + auto qualified_name = defined_namespace->GetFullyQualifiedName(name); + return reflection::CreateService( + *builder, + builder->CreateString(qualified_name), + builder->CreateVector(servicecall_offsets), + SerializeAttributes(builder, parser), + parser.opts.binary_schema_comments + ? builder->CreateVectorOfStrings(doc_comment) + : 0); +} + +Offset EnumDef::Serialize(FlatBufferBuilder *builder, + const Parser &parser) const { + std::vector> enumval_offsets; + for (auto it = vals.vec.begin(); it != vals.vec.end(); ++it) { + enumval_offsets.push_back((*it)->Serialize(builder, parser)); + } + auto qualified_name = defined_namespace->GetFullyQualifiedName(name); + return reflection::CreateEnum( + *builder, + builder->CreateString(qualified_name), + builder->CreateVector(enumval_offsets), + is_union, + underlying_type.Serialize(builder), + SerializeAttributes(builder, parser), + parser.opts.binary_schema_comments + ? builder->CreateVectorOfStrings(doc_comment) + : 0); +} + +Offset EnumVal::Serialize(FlatBufferBuilder *builder, + const Parser &parser) const { return reflection::CreateEnumVal( - *builder, builder->CreateString(name), value, + *builder, + builder->CreateString(name), + value, union_type.struct_def ? union_type.struct_def->serialized_location : 0, - union_type.Serialize(builder)); + union_type.Serialize(builder), + parser.opts.binary_schema_comments + ? builder->CreateVectorOfStrings(doc_comment) + : 0); } Offset Type::Serialize(FlatBufferBuilder *builder) const { return reflection::CreateType( - *builder, static_cast(base_type), + *builder, + static_cast(base_type), static_cast(element), struct_def ? struct_def->index : (enum_def ? enum_def->index : -1)); } @@ -2614,7 +2664,7 @@ Definition::SerializeAttributes(FlatBufferBuilder *builder, for (auto kv = attributes.dict.begin(); kv != attributes.dict.end(); ++kv) { auto it = parser.known_attributes_.find(kv->first); FLATBUFFERS_ASSERT(it != parser.known_attributes_.end()); - if (!it->second) { // Custom attribute. + if (parser.opts.binary_schema_builtins || !it->second) { attrs.push_back(reflection::CreateKeyValue( *builder, builder->CreateString(kv->first), builder->CreateString(kv->second->constant))); diff --git a/tests/monster_test.bfbs b/tests/monster_test.bfbs index 422c36feebb3a4ddfa30d75cd90b474b889ed2ca..a6b87d4a471054fbd03553e5736dccdacdba2bbc 100644 GIT binary patch delta 816 zcmY*XF-sgl6#n)$7ZuLc=y^%-1VKX@#T-}!6C@m(H1RwX!BXKC379)M&y=o}NIF>v z2K)gwsS;9IS|3)yB3*2ZS6EtQ@_n;Ahy&leH~Z$j_q}iSV(PpU6#X>%_CrI0O$+>(?rJyE*Lv00KbX7$G|uX^y15ZE@rpMVwbPp-k*vVJ zQ$Bqu5mx=zR8p@wPPpb>^cNcS?N-=C;jiV@=VH76jFG6~Ea)LBiZA|>f zD@DijR|(zwoYe7Mop#E6lrh0gMAz0VZ|+##I%!Q%V*O_lRw6q7qdW_GNVhceyJi?i zne3Yh_DQ}6ocDgdcu51n@zT$<6xL8n^WqY5Pi8jA%W9eKGXwKT(HnU#E6w$2&bk9QKF@dkOPY#BG`!$Y%P>+EyPZ+ z(?Uf5f>>HuTKLgerV!URdmb*ld$+SQZ{Ez)-1BU|1fa3hSR?U_z=wl0TzDw*27ZAi zu}*9dTSLGwIn49U|8Ec2&jAA_)`@`yyz=d46nG6;FE3E)rejSXfe+LPLFb` znF<%a7``RCL_i$8YfWNed|YG9GuB*&#Fj((Y4wnrDnG{A*)*f~T5F#i7Jw?5eE^lQ zCTH>=Ml(y-9I(Xp|9Vm(eq{xWbwYd8%5jXknb)x;TXkq v*^m^-a+1cf^G?*o4wKcny;=zvxcD@i$Rw&ROQn0_PF(q_>`YwOos;4(wE0zl diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index 1034ef2bc..18f1d6e87 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -import * as NS11563891686210618450 from "./namespace_test1_generated"; +import * as NS9459827973991502386 from "./namespace_test1_generated"; /** * @constructor */ @@ -39,24 +39,24 @@ static getRootAsTableInFirstNS(bb:flatbuffers.ByteBuffer, obj?:TableInFirstNS):T * @param {NamespaceA.NamespaceB.TableInNestedNS=} obj * @returns {NamespaceA.NamespaceB.TableInNestedNS|null} */ -fooTable(obj?:NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS):NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS|null { +fooTable(obj?:NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS|null { var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; }; /** * @returns {NamespaceA.NamespaceB.EnumInNestedNS} */ -fooEnum():NS11563891686210618450.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)) : NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS.A; + 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:NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS):boolean { +mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS):boolean { var offset = this.bb!.__offset(this.bb_pos, 6); if (offset === 0) { @@ -71,9 +71,9 @@ mutate_foo_enum(value:NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedN * @param {NamespaceA.NamespaceB.StructInNestedNS=} obj * @returns {NamespaceA.NamespaceB.StructInNestedNS|null} */ -fooStruct(obj?:NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS):NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS|null { +fooStruct(obj?:NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS|null { var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? (obj || new NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb!) : null; + return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb!) : null; }; /** @@ -95,8 +95,8 @@ static addFooTable(builder:flatbuffers.Builder, fooTableOffset:flatbuffers.Offse * @param {flatbuffers.Builder} builder * @param {NamespaceA.NamespaceB.EnumInNestedNS} fooEnum */ -static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS) { - builder.addFieldInt8(1, fooEnum, NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS.A); +static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS) { + builder.addFieldInt8(1, fooEnum, NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A); }; /**