From 7b94eab2b14be37b2134cdb6cb51a2c30cee89eb Mon Sep 17 00:00:00 2001 From: Wouter van Oortmerssen Date: Fri, 13 Jan 2017 17:44:42 -0800 Subject: [PATCH] Add CodeWriter utility class. Helps simplify code generation code. Instead of this: code += "inline const " + cpp_qualified_name + " *Get"; code += name; code += "(const void *buf) {\n return flatbuffers::GetRoot<"; code += cpp_qualified_name + ">(buf);\n}\n\n"; You do this: code.SetValue("NAME", struct_def.name); code.SetValue("CPP_NAME", cpp_qualified_name); code += "inline const {{CPP_NAME}} *Get{{NAME}}(const void *buf) {"; code += " return flatbuffers::GetRoot<{{CPP_NAME}}>(buf);"; code += "}"; code += ""; Updated the CPP code generator to use the CodeWriter class. Most of the changes in the generated code are white-space changes, esp. around new lines (since the code generator class automatically appends new lines when appending a string). Actual code changes include: * Renamed "rehasher" to "_rehasher" for consistency with other args in Pack function. * Renamed "union_obj" to "obj: in UnPack function. * Always do "(void)_o;" to prevent unused variable warning in Create function (instead of only doing it if there are no fields) in order to avoid two-passes. * Renamed padding variables from __paddingX to paddingX__. "Each name that contains a double underscore (_ _) [...] is reserved to the implementation for any use." C++ standards 17.4.3.1.2. * Add braces around switch cases. * Calculate index as a separate statement in EnumName function, eg. const size_t index = ...; return EnumNamesX()[index]; vs. return EnumNamesX()[...]; * Stored end table offset in variable in Finish() functions, eg. const auto end = fbb_.EndTable(start_, ...); auto o = flatbuffers::Offset(end); vs. auto o = flatbuffers::Offset(fbb_.EndTable(start, ...)); * Separate reinterpret_cast calls from function calls in Union functions, eg. auto ptr = reinterpret_cast(obj); return ptr->UnPack(resolver); vs. return reinterpret_cast(obj)->UnPack(resolver); * Removed unecessary (void)(padding__X) no-ops from constructors, eg. Test(int16_t a, int8_t b) : ... { (void)__padding0; // <-- Removed this line. } In the idl_gen_cpp.cpp file itself, I refactored some code generation into new functions: GenParam, GenNativeTable, GenVerifyCall, GenBuilders, GenUnpackFieldStatement, and GenCreateParam. Change-Id: I727b1bd8719d05b7ce33cbce00eb58fda817b25d --- CMakeLists.txt | 10 +- include/flatbuffers/code_generators.h | 121 +- include/flatbuffers/idl.h | 7 - include/flatbuffers/reflection_generated.h | 386 +++- samples/monster_generated.h | 313 ++- src/code_generators.cpp | 158 ++ src/idl_gen_cpp.cpp | 1794 ++++++++++------- src/idl_gen_fbs.cpp | 1 + src/idl_gen_general.cpp | 33 +- tests/monster_test_generated.h | 771 +++++-- .../namespace_test1_generated.h | 61 +- .../namespace_test2_generated.h | 82 +- 12 files changed, 2431 insertions(+), 1306 deletions(-) create mode 100644 src/code_generators.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 7834f7a1c..6ac39960e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -30,6 +30,7 @@ set(FlatBuffers_Library_SRCS include/flatbuffers/util.h include/flatbuffers/reflection.h include/flatbuffers/reflection_generated.h + src/code_generators.cpp src/idl_parser.cpp src/idl_gen_text.cpp src/reflection.cpp @@ -62,7 +63,6 @@ set(FlatHash_SRCS set(FlatBuffers_Tests_SRCS ${FlatBuffers_Library_SRCS} src/idl_gen_fbs.cpp - src/idl_gen_general.cpp tests/test.cpp # file generate by running compiler on tests/monster_test.fbs ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h @@ -76,13 +76,7 @@ set(FlatBuffers_Sample_Binary_SRCS ) set(FlatBuffers_Sample_Text_SRCS - include/flatbuffers/flatbuffers.h - include/flatbuffers/hash.h - include/flatbuffers/idl.h - include/flatbuffers/util.h - src/idl_parser.cpp - src/idl_gen_text.cpp - src/util.cpp + ${FlatBuffers_Library_SRCS} samples/sample_text.cpp # file generated by running compiler on samples/monster.fbs ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h diff --git a/include/flatbuffers/code_generators.h b/include/flatbuffers/code_generators.h index 5bd2219f1..16e368ea1 100644 --- a/include/flatbuffers/code_generators.h +++ b/include/flatbuffers/code_generators.h @@ -17,25 +17,63 @@ #ifndef FLATBUFFERS_CODE_GENERATORS_H_ #define FLATBUFFERS_CODE_GENERATORS_H_ +#include +#include +#include "flatbuffers/idl.h" + namespace flatbuffers { +// Utility class to assist in generating code through use of text templates. +// +// Example code: +// CodeWriter code; +// code.SetValue("NAME", "Foo"); +// code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }"; +// code.SetValue("NAME", "Bar"); +// code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }"; +// std::cout << code.ToString() << std::endl; +// +// Output: +// void Foo() { printf("%s", "Foo"); } +// void Bar() { printf("%s", "Bar"); } +class CodeWriter { + public: + CodeWriter() {} + + // Clears the current "written" code. + void Clear() { + stream_.str(""); + stream_.clear(); + } + + // Associates a key with a value. All subsequent calls to operator+=, where + // the specified key is contained in {{ and }} delimiters will be replaced by + // the given value. + void SetValue(const std::string& key, const std::string& value) { + value_map_[key] = value; + } + + // Appends the given text to the generated code as well as a newline + // character. Any text within {{ and }} delimeters is replaced by values + // previously stored in the CodeWriter by calling SetValue above. The newline + // will be suppressed if the text ends with the \\ character. + void operator+=(std::string text); + + // Returns the current contents of the CodeWriter as a std::string. + std::string ToString() const { return stream_.str(); } + + private: + std::map value_map_; + std::stringstream stream_; +}; + class BaseGenerator { public: virtual bool generate() = 0; static std::string NamespaceDir(const Parser &parser, const std::string &path, - const Namespace &ns) { - EnsureDirExists(path.c_str()); - if (parser.opts.one_file) return path; - std::string namespace_dir = path; // Either empty or ends in separator. - auto &namespaces = ns.components; - for (auto it = namespaces.begin(); it != namespaces.end(); ++it) { - namespace_dir += *it + kPathSeparator; - EnsureDirExists(namespace_dir.c_str()); - } - return namespace_dir; - } + const Namespace &ns); protected: BaseGenerator(const Parser &parser, const std::string &path, @@ -53,43 +91,15 @@ class BaseGenerator { BaseGenerator &operator=(const BaseGenerator &); BaseGenerator(const BaseGenerator &); - std::string NamespaceDir(const Namespace &ns) const { - return BaseGenerator::NamespaceDir(parser_, path_, ns); - } + std::string NamespaceDir(const Namespace &ns) const; - const char *FlatBuffersGeneratedWarning() { - return "automatically generated by the FlatBuffers compiler," - " do not modify\n\n"; - } + static const char *FlatBuffersGeneratedWarning(); - bool IsEverythingGenerated() const { - for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); - ++it) { - if (!(*it)->generated) return false; - } - for (auto it = parser_.structs_.vec.begin(); - it != parser_.structs_.vec.end(); ++it) { - if (!(*it)->generated) return false; - } - return true; - } + bool IsEverythingGenerated() const; - static std::string FullNamespace(const char *separator, const Namespace &ns) { - std::string namespace_name; - auto &namespaces = ns.components; - for (auto it = namespaces.begin(); it != namespaces.end(); ++it) { - if (namespace_name.length()) namespace_name += separator; - namespace_name += *it; - } - return namespace_name; - } + static std::string FullNamespace(const char *separator, const Namespace &ns); - static std::string LastNamespacePart(const Namespace &ns) { - if (!ns.components.empty()) - return ns.components.back(); - else - return std::string(""); - } + static std::string LastNamespacePart(const Namespace &ns); // tracks the current namespace for early exit in WrapInNameSpace // c++, java and csharp returns a different namespace from @@ -100,17 +110,9 @@ class BaseGenerator { // Ensure that a type is prefixed with its namespace whenever it is used // outside of its namespace. std::string WrapInNameSpace(const Namespace *ns, - const std::string &name) const { - if (CurrentNameSpace() == ns) return name; - std::string qualified_name = qualifying_start_; - for (auto it = ns->components.begin(); it != ns->components.end(); ++it) - qualified_name += *it + qualifying_separator_; - return qualified_name + name; - } + const std::string &name) const; - std::string WrapInNameSpace(const Definition &def) const { - return WrapInNameSpace(def.defined_namespace, def.name); - } + std::string WrapInNameSpace(const Definition &def) const; const Parser &parser_; const std::string &path_; @@ -119,6 +121,17 @@ class BaseGenerator { const std::string qualifying_separator_; }; +struct CommentConfig { + const char *first_line; + const char *content_line_prefix; + const char *last_line; +}; + +extern void GenComment(const std::vector &dc, + std::string *code_ptr, + const CommentConfig *config, + const char *prefix = ""); + } // namespace flatbuffers #endif // FLATBUFFERS_CODE_GENERATORS_H_ diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 7fe3379b0..330137702 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -592,13 +592,6 @@ private: extern std::string MakeCamel(const std::string &in, bool first = true); -struct CommentConfig; - -extern void GenComment(const std::vector &dc, - std::string *code_ptr, - const CommentConfig *config, - const char *prefix = ""); - // Generate text (JSON) from a given FlatBuffer, and a given Parser // object that has been populated with the corresponding schema. // If ident_step is 0, no indentation will be generated. Additionally, diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h index 5a810b701..7dfc30ab2 100644 --- a/include/flatbuffers/reflection_generated.h +++ b/include/flatbuffers/reflection_generated.h @@ -1,5 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify + #ifndef FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_ #define FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_ @@ -42,11 +43,33 @@ enum BaseType { }; inline const char **EnumNamesBaseType() { - static const char *names[] = { "None", "UType", "Bool", "Byte", "UByte", "Short", "UShort", "Int", "UInt", "Long", "ULong", "Float", "Double", "String", "Vector", "Obj", "Union", nullptr }; + static const char *names[] = { + "None", + "UType", + "Bool", + "Byte", + "UByte", + "Short", + "UShort", + "Int", + "UInt", + "Long", + "ULong", + "Float", + "Double", + "String", + "Vector", + "Obj", + "Union", + nullptr + }; return names; } -inline const char *EnumNameBaseType(BaseType e) { return EnumNamesBaseType()[static_cast(e)]; } +inline const char *EnumNameBaseType(BaseType e) { + const size_t index = static_cast(e); + return EnumNamesBaseType()[index]; +} struct Type FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { enum { @@ -54,9 +77,15 @@ struct Type FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_ELEMENT = 6, VT_INDEX = 8 }; - BaseType base_type() const { return static_cast(GetField(VT_BASE_TYPE, 0)); } - BaseType element() const { return static_cast(GetField(VT_ELEMENT, 0)); } - int32_t index() const { return GetField(VT_INDEX, -1); } + BaseType base_type() const { + return static_cast(GetField(VT_BASE_TYPE, 0)); + } + BaseType element() const { + return static_cast(GetField(VT_ELEMENT, 0)); + } + int32_t index() const { + return GetField(VT_INDEX, -1); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BASE_TYPE) && @@ -78,15 +107,20 @@ struct TypeBuilder { void add_index(int32_t index) { fbb_.AddElement(Type::VT_INDEX, index, -1); } - TypeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + TypeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } TypeBuilder &operator=(const TypeBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 3)); + const auto end = fbb_.EndTable(start_, 3); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateType(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateType( + flatbuffers::FlatBufferBuilder &_fbb, BaseType base_type = None, BaseType element = None, int32_t index = -1) { @@ -102,10 +136,18 @@ struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_KEY = 4, VT_VALUE = 6 }; - const flatbuffers::String *key() const { return GetPointer(VT_KEY); } - bool KeyCompareLessThan(const KeyValue *o) const { return *key() < *o->key(); } - int KeyCompareWithValue(const char *val) const { return strcmp(key()->c_str(), val); } - const flatbuffers::String *value() const { return GetPointer(VT_VALUE); } + const flatbuffers::String *key() const { + return GetPointer(VT_KEY); + } + bool KeyCompareLessThan(const KeyValue *o) const { + return *key() < *o->key(); + } + int KeyCompareWithValue(const char *val) const { + return strcmp(key()->c_str(), val); + } + const flatbuffers::String *value() const { + return GetPointer(VT_VALUE); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyFieldRequired(verifier, VT_KEY) && @@ -125,16 +167,21 @@ struct KeyValueBuilder { void add_value(flatbuffers::Offset value) { fbb_.AddOffset(KeyValue::VT_VALUE, value); } - KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } KeyValueBuilder &operator=(const KeyValueBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 2)); - fbb_.Required(o, KeyValue::VT_KEY); // key + const auto end = fbb_.EndTable(start_, 2); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, KeyValue::VT_KEY); return o; } }; -inline flatbuffers::Offset CreateKeyValue(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateKeyValue( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset key = 0, flatbuffers::Offset value = 0) { KeyValueBuilder builder_(_fbb); @@ -143,10 +190,14 @@ inline flatbuffers::Offset CreateKeyValue(flatbuffers::FlatBufferBuild return builder_.Finish(); } -inline flatbuffers::Offset CreateKeyValueDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateKeyValueDirect( + flatbuffers::FlatBufferBuilder &_fbb, const char *key = nullptr, const char *value = nullptr) { - return CreateKeyValue(_fbb, key ? _fbb.CreateString(key) : 0, value ? _fbb.CreateString(value) : 0); + return CreateKeyValue( + _fbb, + key ? _fbb.CreateString(key) : 0, + value ? _fbb.CreateString(value) : 0); } struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -155,11 +206,28 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_VALUE = 6, VT_OBJECT = 8 }; - const flatbuffers::String *name() const { return GetPointer(VT_NAME); } - int64_t value() const { return GetField(VT_VALUE, 0); } - bool KeyCompareLessThan(const EnumVal *o) const { return value() < o->value(); } - int KeyCompareWithValue(int64_t val) const { return value() < val ? -1 : value() > val; } - const Object *object() const { return GetPointer(VT_OBJECT); } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + int64_t value() const { + return GetField(VT_VALUE, 0); + } + bool KeyCompareLessThan(const EnumVal *o) const { + return value() < o->value(); + } + int KeyCompareWithValue(int64_t val) const { + const auto key = value(); + if (key < val) { + return -1; + } else if (key > val) { + return 1; + } else { + return 0; + } + } + const Object *object() const { + return GetPointer(VT_OBJECT); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyFieldRequired(verifier, VT_NAME) && @@ -183,16 +251,21 @@ struct EnumValBuilder { void add_object(flatbuffers::Offset object) { fbb_.AddOffset(EnumVal::VT_OBJECT, object); } - EnumValBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + EnumValBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } EnumValBuilder &operator=(const EnumValBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 3)); - fbb_.Required(o, EnumVal::VT_NAME); // name + const auto end = fbb_.EndTable(start_, 3); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, EnumVal::VT_NAME); return o; } }; -inline flatbuffers::Offset CreateEnumVal(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateEnumVal( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset name = 0, int64_t value = 0, flatbuffers::Offset object = 0) { @@ -203,11 +276,16 @@ inline flatbuffers::Offset CreateEnumVal(flatbuffers::FlatBufferBuilder return builder_.Finish(); } -inline flatbuffers::Offset CreateEnumValDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateEnumValDirect( + flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, int64_t value = 0, flatbuffers::Offset object = 0) { - return CreateEnumVal(_fbb, name ? _fbb.CreateString(name) : 0, value, object); + return CreateEnumVal( + _fbb, + name ? _fbb.CreateString(name) : 0, + value, + object); } struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -218,13 +296,27 @@ struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_UNDERLYING_TYPE = 10, VT_ATTRIBUTES = 12 }; - const flatbuffers::String *name() const { return GetPointer(VT_NAME); } - bool KeyCompareLessThan(const Enum *o) const { return *name() < *o->name(); } - int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); } - const flatbuffers::Vector> *values() const { return GetPointer> *>(VT_VALUES); } - bool is_union() const { return GetField(VT_IS_UNION, 0) != 0; } - const Type *underlying_type() const { return GetPointer(VT_UNDERLYING_TYPE); } - const flatbuffers::Vector> *attributes() const { return GetPointer> *>(VT_ATTRIBUTES); } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Enum *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *val) const { + return strcmp(name()->c_str(), val); + } + const flatbuffers::Vector> *values() const { + return GetPointer> *>(VT_VALUES); + } + bool is_union() const { + return GetField(VT_IS_UNION, 0) != 0; + } + const Type *underlying_type() const { + return GetPointer(VT_UNDERLYING_TYPE); + } + const flatbuffers::Vector> *attributes() const { + return GetPointer> *>(VT_ATTRIBUTES); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyFieldRequired(verifier, VT_NAME) && @@ -260,18 +352,23 @@ struct EnumBuilder { void add_attributes(flatbuffers::Offset>> attributes) { fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes); } - EnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + EnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } EnumBuilder &operator=(const EnumBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 5)); - fbb_.Required(o, Enum::VT_NAME); // name - fbb_.Required(o, Enum::VT_VALUES); // values - fbb_.Required(o, Enum::VT_UNDERLYING_TYPE); // underlying_type + const auto end = fbb_.EndTable(start_, 5); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Enum::VT_NAME); + fbb_.Required(o, Enum::VT_VALUES); + fbb_.Required(o, Enum::VT_UNDERLYING_TYPE); return o; } }; -inline flatbuffers::Offset CreateEnum(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateEnum( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset name = 0, flatbuffers::Offset>> values = 0, bool is_union = false, @@ -286,13 +383,20 @@ inline flatbuffers::Offset CreateEnum(flatbuffers::FlatBufferBuilder &_fbb return builder_.Finish(); } -inline flatbuffers::Offset CreateEnumDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateEnumDirect( + flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, const std::vector> *values = nullptr, bool is_union = false, flatbuffers::Offset underlying_type = 0, const std::vector> *attributes = nullptr) { - return CreateEnum(_fbb, name ? _fbb.CreateString(name) : 0, values ? _fbb.CreateVector>(*values) : 0, is_union, underlying_type, attributes ? _fbb.CreateVector>(*attributes) : 0); + return CreateEnum( + _fbb, + name ? _fbb.CreateString(name) : 0, + values ? _fbb.CreateVector>(*values) : 0, + is_union, + underlying_type, + attributes ? _fbb.CreateVector>(*attributes) : 0); } struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -308,18 +412,42 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_KEY = 20, VT_ATTRIBUTES = 22 }; - const flatbuffers::String *name() const { return GetPointer(VT_NAME); } - bool KeyCompareLessThan(const Field *o) const { return *name() < *o->name(); } - int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); } - const Type *type() const { return GetPointer(VT_TYPE); } - uint16_t id() const { return GetField(VT_ID, 0); } - uint16_t offset() const { return GetField(VT_OFFSET, 0); } - int64_t default_integer() const { return GetField(VT_DEFAULT_INTEGER, 0); } - double default_real() const { return GetField(VT_DEFAULT_REAL, 0.0); } - bool deprecated() const { return GetField(VT_DEPRECATED, 0) != 0; } - bool required() const { return GetField(VT_REQUIRED, 0) != 0; } - bool key() const { return GetField(VT_KEY, 0) != 0; } - const flatbuffers::Vector> *attributes() const { return GetPointer> *>(VT_ATTRIBUTES); } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Field *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *val) const { + return strcmp(name()->c_str(), val); + } + const Type *type() const { + return GetPointer(VT_TYPE); + } + uint16_t id() const { + return GetField(VT_ID, 0); + } + uint16_t offset() const { + return GetField(VT_OFFSET, 0); + } + int64_t default_integer() const { + return GetField(VT_DEFAULT_INTEGER, 0); + } + double default_real() const { + return GetField(VT_DEFAULT_REAL, 0.0); + } + bool deprecated() const { + return GetField(VT_DEPRECATED, 0) != 0; + } + bool required() const { + return GetField(VT_REQUIRED, 0) != 0; + } + bool key() const { + return GetField(VT_KEY, 0) != 0; + } + const flatbuffers::Vector> *attributes() const { + return GetPointer> *>(VT_ATTRIBUTES); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyFieldRequired(verifier, VT_NAME) && @@ -373,17 +501,22 @@ struct FieldBuilder { void add_attributes(flatbuffers::Offset>> attributes) { fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes); } - FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } FieldBuilder &operator=(const FieldBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 10)); - fbb_.Required(o, Field::VT_NAME); // name - fbb_.Required(o, Field::VT_TYPE); // type + const auto end = fbb_.EndTable(start_, 10); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Field::VT_NAME); + fbb_.Required(o, Field::VT_TYPE); return o; } }; -inline flatbuffers::Offset CreateField(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateField( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset name = 0, flatbuffers::Offset type = 0, uint16_t id = 0, @@ -408,7 +541,8 @@ inline flatbuffers::Offset CreateField(flatbuffers::FlatBufferBuilder &_f return builder_.Finish(); } -inline flatbuffers::Offset CreateFieldDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateFieldDirect( + flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, flatbuffers::Offset type = 0, uint16_t id = 0, @@ -419,7 +553,18 @@ inline flatbuffers::Offset CreateFieldDirect(flatbuffers::FlatBufferBuild bool required = false, bool key = false, const std::vector> *attributes = nullptr) { - return CreateField(_fbb, name ? _fbb.CreateString(name) : 0, type, id, offset, default_integer, default_real, deprecated, required, key, attributes ? _fbb.CreateVector>(*attributes) : 0); + return CreateField( + _fbb, + name ? _fbb.CreateString(name) : 0, + type, + id, + offset, + default_integer, + default_real, + deprecated, + required, + key, + attributes ? _fbb.CreateVector>(*attributes) : 0); } struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -431,14 +576,30 @@ struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_BYTESIZE = 12, VT_ATTRIBUTES = 14 }; - const flatbuffers::String *name() const { return GetPointer(VT_NAME); } - bool KeyCompareLessThan(const Object *o) const { return *name() < *o->name(); } - int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); } - const flatbuffers::Vector> *fields() const { return GetPointer> *>(VT_FIELDS); } - bool is_struct() const { return GetField(VT_IS_STRUCT, 0) != 0; } - int32_t minalign() const { return GetField(VT_MINALIGN, 0); } - int32_t bytesize() const { return GetField(VT_BYTESIZE, 0); } - const flatbuffers::Vector> *attributes() const { return GetPointer> *>(VT_ATTRIBUTES); } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Object *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *val) const { + return strcmp(name()->c_str(), val); + } + const flatbuffers::Vector> *fields() const { + return GetPointer> *>(VT_FIELDS); + } + bool is_struct() const { + return GetField(VT_IS_STRUCT, 0) != 0; + } + int32_t minalign() const { + return GetField(VT_MINALIGN, 0); + } + int32_t bytesize() const { + return GetField(VT_BYTESIZE, 0); + } + const flatbuffers::Vector> *attributes() const { + return GetPointer> *>(VT_ATTRIBUTES); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyFieldRequired(verifier, VT_NAME) && @@ -477,17 +638,22 @@ struct ObjectBuilder { void add_attributes(flatbuffers::Offset>> attributes) { fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes); } - ObjectBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + ObjectBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } ObjectBuilder &operator=(const ObjectBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 6)); - fbb_.Required(o, Object::VT_NAME); // name - fbb_.Required(o, Object::VT_FIELDS); // fields + const auto end = fbb_.EndTable(start_, 6); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Object::VT_NAME); + fbb_.Required(o, Object::VT_FIELDS); return o; } }; -inline flatbuffers::Offset CreateObject(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateObject( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset name = 0, flatbuffers::Offset>> fields = 0, bool is_struct = false, @@ -504,14 +670,22 @@ inline flatbuffers::Offset CreateObject(flatbuffers::FlatBufferBuilder & return builder_.Finish(); } -inline flatbuffers::Offset CreateObjectDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateObjectDirect( + flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, const std::vector> *fields = nullptr, bool is_struct = false, int32_t minalign = 0, int32_t bytesize = 0, const std::vector> *attributes = nullptr) { - return CreateObject(_fbb, name ? _fbb.CreateString(name) : 0, fields ? _fbb.CreateVector>(*fields) : 0, is_struct, minalign, bytesize, attributes ? _fbb.CreateVector>(*attributes) : 0); + return CreateObject( + _fbb, + name ? _fbb.CreateString(name) : 0, + fields ? _fbb.CreateVector>(*fields) : 0, + is_struct, + minalign, + bytesize, + attributes ? _fbb.CreateVector>(*attributes) : 0); } struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -522,11 +696,21 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_FILE_EXT = 10, VT_ROOT_TABLE = 12 }; - const flatbuffers::Vector> *objects() const { return GetPointer> *>(VT_OBJECTS); } - const flatbuffers::Vector> *enums() const { return GetPointer> *>(VT_ENUMS); } - const flatbuffers::String *file_ident() const { return GetPointer(VT_FILE_IDENT); } - const flatbuffers::String *file_ext() const { return GetPointer(VT_FILE_EXT); } - const Object *root_table() const { return GetPointer(VT_ROOT_TABLE); } + const flatbuffers::Vector> *objects() const { + return GetPointer> *>(VT_OBJECTS); + } + const flatbuffers::Vector> *enums() const { + return GetPointer> *>(VT_ENUMS); + } + const flatbuffers::String *file_ident() const { + return GetPointer(VT_FILE_IDENT); + } + const flatbuffers::String *file_ext() const { + return GetPointer(VT_FILE_EXT); + } + const Object *root_table() const { + return GetPointer(VT_ROOT_TABLE); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyFieldRequired(verifier, VT_OBJECTS) && @@ -563,17 +747,22 @@ struct SchemaBuilder { void add_root_table(flatbuffers::Offset root_table) { fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table); } - SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } SchemaBuilder &operator=(const SchemaBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 5)); - fbb_.Required(o, Schema::VT_OBJECTS); // objects - fbb_.Required(o, Schema::VT_ENUMS); // enums + const auto end = fbb_.EndTable(start_, 5); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Schema::VT_OBJECTS); + fbb_.Required(o, Schema::VT_ENUMS); return o; } }; -inline flatbuffers::Offset CreateSchema(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateSchema( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset>> objects = 0, flatbuffers::Offset>> enums = 0, flatbuffers::Offset file_ident = 0, @@ -588,13 +777,20 @@ inline flatbuffers::Offset CreateSchema(flatbuffers::FlatBufferBuilder & return builder_.Finish(); } -inline flatbuffers::Offset CreateSchemaDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateSchemaDirect( + flatbuffers::FlatBufferBuilder &_fbb, const std::vector> *objects = nullptr, const std::vector> *enums = nullptr, const char *file_ident = nullptr, const char *file_ext = nullptr, flatbuffers::Offset root_table = 0) { - return 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); + return 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); } inline const reflection::Schema *GetSchema(const void *buf) { @@ -606,10 +802,12 @@ inline const char *SchemaIdentifier() { } inline bool SchemaBufferHasIdentifier(const void *buf) { - return flatbuffers::BufferHasIdentifier(buf, SchemaIdentifier()); + return flatbuffers::BufferHasIdentifier( + buf, SchemaIdentifier()); } -inline bool VerifySchemaBuffer(flatbuffers::Verifier &verifier) { +inline bool VerifySchemaBuffer( + flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer(SchemaIdentifier()); } @@ -617,7 +815,9 @@ inline const char *SchemaExtension() { return "bfbs"; } -inline void FinishSchemaBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset root) { +inline void FinishSchemaBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { fbb.Finish(root, SchemaIdentifier()); } diff --git a/samples/monster_generated.h b/samples/monster_generated.h index 11ab5eaf1..cc5faf6ce 100644 --- a/samples/monster_generated.h +++ b/samples/monster_generated.h @@ -1,5 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify + #ifndef FLATBUFFERS_GENERATED_MONSTER_MYGAME_SAMPLE_H_ #define FLATBUFFERS_GENERATED_MONSTER_MYGAME_SAMPLE_H_ @@ -25,11 +26,19 @@ enum Color { }; inline const char **EnumNamesColor() { - static const char *names[] = { "Red", "Green", "Blue", nullptr }; + static const char *names[] = { + "Red", + "Green", + "Blue", + nullptr + }; return names; } -inline const char *EnumNameColor(Color e) { return EnumNamesColor()[static_cast(e)]; } +inline const char *EnumNameColor(Color e) { + const size_t index = static_cast(e); + return EnumNamesColor()[index]; +} enum Equipment { Equipment_NONE = 0, @@ -39,11 +48,18 @@ enum Equipment { }; inline const char **EnumNamesEquipment() { - static const char *names[] = { "NONE", "Weapon", nullptr }; + static const char *names[] = { + "NONE", + "Weapon", + nullptr + }; return names; } -inline const char *EnumNameEquipment(Equipment e) { return EnumNamesEquipment()[static_cast(e)]; } +inline const char *EnumNameEquipment(Equipment e) { + const size_t index = static_cast(e); + return EnumNamesEquipment()[index]; +} template struct EquipmentTraits { static const Equipment enum_value = Equipment_NONE; @@ -55,12 +71,13 @@ template<> struct EquipmentTraits { struct EquipmentUnion { Equipment type; - flatbuffers::NativeTable *table; + EquipmentUnion() : type(Equipment_NONE), table(nullptr) {} EquipmentUnion(const EquipmentUnion &); EquipmentUnion &operator=(const EquipmentUnion &); ~EquipmentUnion() { Reset(); } + void Reset(); template @@ -72,13 +89,16 @@ struct EquipmentUnion { } } - static flatbuffers::NativeTable *UnPack(const void *union_obj, Equipment type, const flatbuffers::resolver_function_t *resolver); - flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *rehasher = nullptr) const; + static flatbuffers::NativeTable *UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; - WeaponT *AsWeapon() { return type == Equipment_Weapon ? reinterpret_cast(table) : nullptr; } + WeaponT *AsWeapon() { + return type == Equipment_Weapon ? + reinterpret_cast(table) : nullptr; + } }; -inline bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *union_obj, Equipment type); +bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type); MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS { private: @@ -87,17 +107,35 @@ MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS { float z_; public: - Vec3() { memset(this, 0, sizeof(Vec3)); } - Vec3(const Vec3 &_o) { memcpy(this, &_o, sizeof(Vec3)); } + Vec3() { + memset(this, 0, sizeof(Vec3)); + } + Vec3(const Vec3 &_o) { + memcpy(this, &_o, sizeof(Vec3)); + } Vec3(float _x, float _y, float _z) - : x_(flatbuffers::EndianScalar(_x)), y_(flatbuffers::EndianScalar(_y)), z_(flatbuffers::EndianScalar(_z)) { } - - float x() const { return flatbuffers::EndianScalar(x_); } - void mutate_x(float _x) { flatbuffers::WriteScalar(&x_, _x); } - float y() const { return flatbuffers::EndianScalar(y_); } - void mutate_y(float _y) { flatbuffers::WriteScalar(&y_, _y); } - float z() const { return flatbuffers::EndianScalar(z_); } - void mutate_z(float _z) { flatbuffers::WriteScalar(&z_, _z); } + : x_(flatbuffers::EndianScalar(_x)), + y_(flatbuffers::EndianScalar(_y)), + z_(flatbuffers::EndianScalar(_z)) { + } + float x() const { + return flatbuffers::EndianScalar(x_); + } + void mutate_x(float _x) { + flatbuffers::WriteScalar(&x_, _x); + } + float y() const { + return flatbuffers::EndianScalar(y_); + } + void mutate_y(float _y) { + flatbuffers::WriteScalar(&y_, _y); + } + float z() const { + return flatbuffers::EndianScalar(z_); + } + void mutate_z(float _z) { + flatbuffers::WriteScalar(&z_, _z); + } }; STRUCT_END(Vec3, 12); @@ -112,9 +150,10 @@ struct MonsterT : public flatbuffers::NativeTable { std::vector> weapons; EquipmentUnion equipped; MonsterT() - : mana(150), - hp(100), - color(Color_Blue) {} + : mana(150), + hp(100), + color(Color_Blue) { + } }; struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -130,24 +169,60 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_EQUIPPED_TYPE = 20, VT_EQUIPPED = 22 }; - const Vec3 *pos() const { return GetStruct(VT_POS); } - Vec3 *mutable_pos() { return GetStruct(VT_POS); } - int16_t mana() const { return GetField(VT_MANA, 150); } - bool mutate_mana(int16_t _mana) { return SetField(VT_MANA, _mana); } - int16_t hp() const { return GetField(VT_HP, 100); } - bool mutate_hp(int16_t _hp) { return SetField(VT_HP, _hp); } - const flatbuffers::String *name() const { return GetPointer(VT_NAME); } - flatbuffers::String *mutable_name() { return GetPointer(VT_NAME); } - const flatbuffers::Vector *inventory() const { return GetPointer *>(VT_INVENTORY); } - flatbuffers::Vector *mutable_inventory() { return GetPointer *>(VT_INVENTORY); } - Color color() const { return static_cast(GetField(VT_COLOR, 2)); } - bool mutate_color(Color _color) { return SetField(VT_COLOR, static_cast(_color)); } - const flatbuffers::Vector> *weapons() const { return GetPointer> *>(VT_WEAPONS); } - flatbuffers::Vector> *mutable_weapons() { return GetPointer> *>(VT_WEAPONS); } - Equipment equipped_type() const { return static_cast(GetField(VT_EQUIPPED_TYPE, 0)); } - bool mutate_equipped_type(Equipment _equipped_type) { return SetField(VT_EQUIPPED_TYPE, static_cast(_equipped_type)); } - const void *equipped() const { return GetPointer(VT_EQUIPPED); } - void *mutable_equipped() { return GetPointer(VT_EQUIPPED); } + const Vec3 *pos() const { + return GetStruct(VT_POS); + } + Vec3 *mutable_pos() { + return GetStruct(VT_POS); + } + int16_t mana() const { + return GetField(VT_MANA, 150); + } + bool mutate_mana(int16_t _mana) { + return SetField(VT_MANA, _mana); + } + int16_t hp() const { + return GetField(VT_HP, 100); + } + bool mutate_hp(int16_t _hp) { + return SetField(VT_HP, _hp); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + flatbuffers::String *mutable_name() { + return GetPointer(VT_NAME); + } + const flatbuffers::Vector *inventory() const { + return GetPointer *>(VT_INVENTORY); + } + flatbuffers::Vector *mutable_inventory() { + return GetPointer *>(VT_INVENTORY); + } + Color color() const { + return static_cast(GetField(VT_COLOR, 2)); + } + bool mutate_color(Color _color) { + return SetField(VT_COLOR, static_cast(_color)); + } + const flatbuffers::Vector> *weapons() const { + return GetPointer> *>(VT_WEAPONS); + } + flatbuffers::Vector> *mutable_weapons() { + return GetPointer> *>(VT_WEAPONS); + } + Equipment equipped_type() const { + return static_cast(GetField(VT_EQUIPPED_TYPE, 0)); + } + bool mutate_equipped_type(Equipment _equipped_type) { + return SetField(VT_EQUIPPED_TYPE, static_cast(_equipped_type)); + } + const void *equipped() const { + return GetPointer(VT_EQUIPPED); + } + void *mutable_equipped() { + return GetPointer(VT_EQUIPPED); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_POS) && @@ -200,15 +275,20 @@ struct MonsterBuilder { void add_equipped(flatbuffers::Offset equipped) { fbb_.AddOffset(Monster::VT_EQUIPPED, equipped); } - MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } MonsterBuilder &operator=(const MonsterBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 10)); + const auto end = fbb_.EndTable(start_, 10); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb, const Vec3 *pos = 0, int16_t mana = 150, int16_t hp = 100, @@ -231,7 +311,8 @@ inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder return builder_.Finish(); } -inline flatbuffers::Offset CreateMonsterDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateMonsterDirect( + flatbuffers::FlatBufferBuilder &_fbb, const Vec3 *pos = 0, int16_t mana = 150, int16_t hp = 100, @@ -241,17 +322,28 @@ inline flatbuffers::Offset CreateMonsterDirect(flatbuffers::FlatBufferB const std::vector> *weapons = nullptr, Equipment equipped_type = Equipment_NONE, flatbuffers::Offset equipped = 0) { - return CreateMonster(_fbb, pos, mana, hp, name ? _fbb.CreateString(name) : 0, inventory ? _fbb.CreateVector(*inventory) : 0, color, weapons ? _fbb.CreateVector>(*weapons) : 0, equipped_type, equipped); + return CreateMonster( + _fbb, + pos, + mana, + hp, + name ? _fbb.CreateString(name) : 0, + inventory ? _fbb.CreateVector(*inventory) : 0, + color, + weapons ? _fbb.CreateVector>(*weapons) : 0, + equipped_type, + equipped); } -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *rehasher = nullptr); +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); struct WeaponT : public flatbuffers::NativeTable { typedef Weapon TableType; std::string name; int16_t damage; WeaponT() - : damage(0) {} + : damage(0) { + } }; struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -260,10 +352,18 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_NAME = 4, VT_DAMAGE = 6 }; - const flatbuffers::String *name() const { return GetPointer(VT_NAME); } - flatbuffers::String *mutable_name() { return GetPointer(VT_NAME); } - int16_t damage() const { return GetField(VT_DAMAGE, 0); } - bool mutate_damage(int16_t _damage) { return SetField(VT_DAMAGE, _damage); } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + flatbuffers::String *mutable_name() { + return GetPointer(VT_NAME); + } + int16_t damage() const { + return GetField(VT_DAMAGE, 0); + } + bool mutate_damage(int16_t _damage) { + return SetField(VT_DAMAGE, _damage); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_NAME) && @@ -284,15 +384,20 @@ struct WeaponBuilder { void add_damage(int16_t damage) { fbb_.AddElement(Weapon::VT_DAMAGE, damage, 0); } - WeaponBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + WeaponBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } WeaponBuilder &operator=(const WeaponBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 2)); + const auto end = fbb_.EndTable(start_, 2); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateWeapon( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset name = 0, int16_t damage = 0) { WeaponBuilder builder_(_fbb); @@ -301,13 +406,17 @@ inline flatbuffers::Offset CreateWeapon(flatbuffers::FlatBufferBuilder & return builder_.Finish(); } -inline flatbuffers::Offset CreateWeaponDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateWeaponDirect( + flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, int16_t damage = 0) { - return CreateWeapon(_fbb, name ? _fbb.CreateString(name) : 0, damage); + return CreateWeapon( + _fbb, + name ? _fbb.CreateString(name) : 0, + damage); } -inline flatbuffers::Offset CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *rehasher = nullptr); +flatbuffers::Offset CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *resolver) const { (void)resolver; @@ -316,11 +425,11 @@ inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *resolve { auto _e = mana(); _o->mana = _e; }; { auto _e = hp(); _o->hp = _e; }; { auto _e = name(); if (_e) _o->name = _e->str(); }; - { auto _e = inventory(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory.push_back(_e->Get(_i)); } } }; + { auto _e = inventory(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory.push_back(_e->Get(_i)); } }; { auto _e = color(); _o->color = _e; }; - { auto _e = weapons(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->weapons.push_back(std::unique_ptr(_e->Get(_i)->UnPack(resolver))); } } }; + { auto _e = weapons(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->weapons.push_back(std::unique_ptr(_e->Get(_i)->UnPack(resolver))); } }; { auto _e = equipped_type(); _o->equipped.type = _e; }; - { auto _e = equipped(); if (_e) _o->equipped.table = EquipmentUnion::UnPack(_e, equipped_type(), resolver); }; + { auto _e = equipped(); if (_e) _o->equipped.table = EquipmentUnion::UnPack(_e, equipped_type(),resolver); }; return _o; } @@ -328,18 +437,20 @@ inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder return CreateMonster(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *rehasher) { - (void)rehasher; - return CreateMonster(_fbb, - _o->pos ? _o->pos.get() : 0, - _o->mana, - _o->hp, - _o->name.size() ? _fbb.CreateString(_o->name) : 0, - _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0, - _o->color, - _o->weapons.size() ? _fbb.CreateVector>(_o->weapons.size(), [&](size_t i) { return CreateWeapon(_fbb, _o->weapons[i].get(), rehasher); }) : 0, - _o->equipped.type, - _o->equipped.Pack(_fbb)); +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + return CreateMonster( + _fbb, + _o->pos ? _o->pos.get() : 0, + _o->mana, + _o->hp, + _o->name.size() ? _fbb.CreateString(_o->name) : 0, + _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0, + _o->color, + _o->weapons.size() ? _fbb.CreateVector>(_o->weapons.size(), [&](size_t i) { return CreateWeapon(_fbb, _o->weapons[i].get(), _rehasher); }) : 0, + _o->equipped.type, + _o->equipped.Pack(_fbb)); } inline WeaponT *Weapon::UnPack(const flatbuffers::resolver_function_t *resolver) const { @@ -354,40 +465,55 @@ inline flatbuffers::Offset Weapon::Pack(flatbuffers::FlatBufferBuilder & return CreateWeapon(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *rehasher) { - (void)rehasher; - return CreateWeapon(_fbb, - _o->name.size() ? _fbb.CreateString(_o->name) : 0, - _o->damage); +inline flatbuffers::Offset CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + return CreateWeapon( + _fbb, + _o->name.size() ? _fbb.CreateString(_o->name) : 0, + _o->damage); } -inline bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *union_obj, Equipment type) { +inline bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type) { switch (type) { - case Equipment_NONE: return true; - case Equipment_Weapon: return verifier.VerifyTable(reinterpret_cast(union_obj)); + case Equipment_NONE: { + return true; + } + case Equipment_Weapon: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return false; } } -inline flatbuffers::NativeTable *EquipmentUnion::UnPack(const void *union_obj, Equipment type, const flatbuffers::resolver_function_t *resolver) { +inline flatbuffers::NativeTable *EquipmentUnion::UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver) { switch (type) { - case Equipment_NONE: return nullptr; - case Equipment_Weapon: return reinterpret_cast(union_obj)->UnPack(resolver); + case Equipment_Weapon: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } default: return nullptr; } } -inline flatbuffers::Offset EquipmentUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *rehasher) const { +inline flatbuffers::Offset EquipmentUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { switch (type) { - case Equipment_NONE: return 0; - case Equipment_Weapon: return CreateWeapon(_fbb, reinterpret_cast(table), rehasher).Union(); + case Equipment_Weapon: { + auto ptr = reinterpret_cast(table); + return CreateWeapon(_fbb, ptr, _rehasher).Union(); + } default: return 0; } } inline void EquipmentUnion::Reset() { switch (type) { - case Equipment_Weapon: delete reinterpret_cast(table); break; + case Equipment_Weapon: { + auto ptr = reinterpret_cast(table); + delete ptr; + break; + } default: break; } table = nullptr; @@ -402,16 +528,21 @@ inline Monster *GetMutableMonster(void *buf) { return flatbuffers::GetMutableRoot(buf); } -inline bool VerifyMonsterBuffer(flatbuffers::Verifier &verifier) { +inline bool VerifyMonsterBuffer( + flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer(nullptr); } -inline void FinishMonsterBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset root) { +inline void FinishMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { fbb.Finish(root); } -inline std::unique_ptr UnPackMonster(const void *buf, const flatbuffers::resolver_function_t *resolver = nullptr) { - return std::unique_ptr(GetMonster(buf)->UnPack(resolver)); +inline std::unique_ptr UnPackMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return std::unique_ptr(GetMonster(buf)->UnPack(res)); } } // namespace Sample diff --git a/src/code_generators.cpp b/src/code_generators.cpp new file mode 100644 index 000000000..871063536 --- /dev/null +++ b/src/code_generators.cpp @@ -0,0 +1,158 @@ +/* + * 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. + */ + +#include "flatbuffers/code_generators.h" +#include +#include "flatbuffers/util.h" + +namespace flatbuffers { + +void CodeWriter::operator+=(std::string text) { + + while (true) { + auto begin = text.find("{{"); + if (begin == std::string::npos) { + break; + } + + auto end = text.find("}}"); + if (end == std::string::npos || end < begin) { + break; + } + + // Write all the text before the first {{ into the stream. + stream_.write(text.c_str(), begin); + + // The key is between the {{ and }}. + const std::string key = text.substr(begin + 2, end - begin - 2); + + // Find the value associated with the key. If it exists, write the + // value into the stream, otherwise write the key itself into the stream. + auto iter = value_map_.find(key); + if (iter != value_map_.end()) { + const std::string &value = iter->second; + stream_ << value; + } else { + assert(false && "could not find key"); + stream_ << key; + } + + // Update the text to everything after the }}. + text = text.substr(end + 2); + } + if (!text.empty() && text.back() == '\\') { + text.pop_back(); + stream_ << text; + } else { + stream_ << text << std::endl; + } +} + +const char *BaseGenerator::FlatBuffersGeneratedWarning() { + return "automatically generated by the FlatBuffers compiler," + " do not modify\n\n"; +} + +std::string BaseGenerator::NamespaceDir(const Parser &parser, + const std::string &path, + const Namespace &ns) { + EnsureDirExists(path.c_str()); + if (parser.opts.one_file) return path; + std::string namespace_dir = path; // Either empty or ends in separator. + auto &namespaces = ns.components; + for (auto it = namespaces.begin(); it != namespaces.end(); ++it) { + namespace_dir += *it + kPathSeparator; + EnsureDirExists(namespace_dir.c_str()); + } + return namespace_dir; +} + +std::string BaseGenerator::NamespaceDir(const Namespace &ns) const { + return BaseGenerator::NamespaceDir(parser_, path_, ns); +} + +bool BaseGenerator::IsEverythingGenerated() const { + for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); + ++it) { + if (!(*it)->generated) return false; + } + for (auto it = parser_.structs_.vec.begin(); + it != parser_.structs_.vec.end(); ++it) { + if (!(*it)->generated) return false; + } + return true; + } + +std::string BaseGenerator::FullNamespace(const char *separator, + const Namespace &ns) { + std::string namespace_name; + auto &namespaces = ns.components; + for (auto it = namespaces.begin(); it != namespaces.end(); ++it) { + if (namespace_name.length()) namespace_name += separator; + namespace_name += *it; + } + return namespace_name; +} + +std::string BaseGenerator::LastNamespacePart(const Namespace &ns) { + if (!ns.components.empty()) + return ns.components.back(); + else + return std::string(""); +} + +// Ensure that a type is prefixed with its namespace whenever it is used +// outside of its namespace. +std::string BaseGenerator::WrapInNameSpace(const Namespace *ns, + const std::string &name) const { + if (CurrentNameSpace() == ns) return name; + std::string qualified_name = qualifying_start_; + for (auto it = ns->components.begin(); it != ns->components.end(); ++it) + qualified_name += *it + qualifying_separator_; + return qualified_name + name; +} + + +std::string BaseGenerator::WrapInNameSpace(const Definition &def) const { + return WrapInNameSpace(def.defined_namespace, def.name); +} + +// Generate a documentation comment, if available. +void GenComment(const std::vector &dc, std::string *code_ptr, + const CommentConfig *config, const char *prefix) { + if (dc.begin() == dc.end()) { + // Don't output empty comment blocks with 0 lines of comment content. + return; + } + + std::string &code = *code_ptr; + if (config != nullptr && config->first_line != nullptr) { + code += std::string(prefix) + std::string(config->first_line) + "\n"; + } + std::string line_prefix = std::string(prefix) + + ((config != nullptr && config->content_line_prefix != nullptr) ? + config->content_line_prefix : "///"); + for (auto it = dc.begin(); + it != dc.end(); + ++it) { + code += line_prefix + *it + "\n"; + } + if (config != nullptr && config->last_line != nullptr) { + code += std::string(prefix) + std::string(config->last_line) + "\n"; + } +} + +} // namespace flatbuffers diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp index 41a8da1da..e6b6209be 100644 --- a/src/idl_gen_cpp.cpp +++ b/src/idl_gen_cpp.cpp @@ -58,20 +58,18 @@ class CppGenerator : public BaseGenerator { return guard; } - void GenIncludeDependencies(std::string* code_ptr) const { - std::string& code = *code_ptr; - + void GenIncludeDependencies() { int num_includes = 0; for (auto it = parser_.included_files_.begin(); it != parser_.included_files_.end(); ++it) { - const std::string basename = + const auto basename = flatbuffers::StripPath(flatbuffers::StripExtension(it->first)); if (basename != file_name_) { - code += "#include \"" + basename + "_generated.h\"\n"; + code_ += "#include \"" + basename + "_generated.h\""; num_includes++; } } - if (num_includes) code += "\n"; + if (num_includes) code_ += ""; } // Iterate through all definitions we haven't generate code for (enums, @@ -79,17 +77,19 @@ class CppGenerator : public BaseGenerator { bool generate() { if (IsEverythingGenerated()) return true; - std::string code; - code = code + "// " + FlatBuffersGeneratedWarning(); + code_.Clear(); + code_ += "// " + std::string(FlatBuffersGeneratedWarning()); - const std::string include_guard = GenIncludeGuard(); - code += "#ifndef " + include_guard + "\n"; - code += "#define " + include_guard + "\n\n"; + const auto include_guard = GenIncludeGuard(); + code_ += "#ifndef " + include_guard; + code_ += "#define " + include_guard; + code_ += ""; - code += "#include \"flatbuffers/flatbuffers.h\"\n\n"; + code_ += "#include \"flatbuffers/flatbuffers.h\""; + code_ += ""; if (parser_.opts.include_dependence_headers) { - GenIncludeDependencies(&code); + GenIncludeDependencies(); } assert(!cur_name_space_); @@ -100,12 +100,12 @@ class CppGenerator : public BaseGenerator { it != parser_.structs_.vec.end(); ++it) { const auto &struct_def = **it; if (!struct_def.generated) { - SetNameSpace(struct_def.defined_namespace, &code); - code += "struct " + struct_def.name + ";\n"; + SetNameSpace(struct_def.defined_namespace); + code_ += "struct " + struct_def.name + ";"; if (parser_.opts.generate_object_based_api && !struct_def.fixed) { - code += "struct " + NativeName(struct_def.name) + ";\n"; + code_ += "struct " + NativeName(struct_def.name) + ";"; } - code += "\n"; + code_ += ""; } } @@ -114,8 +114,8 @@ class CppGenerator : public BaseGenerator { ++it) { const auto &enum_def = **it; if (!enum_def.generated) { - SetNameSpace(enum_def.defined_namespace, &code); - GenEnum(enum_def, &code); + SetNameSpace(enum_def.defined_namespace); + GenEnum(enum_def); } } @@ -124,24 +124,24 @@ class CppGenerator : public BaseGenerator { it != parser_.structs_.vec.end(); ++it) { const auto &struct_def = **it; if (struct_def.fixed && !struct_def.generated) { - SetNameSpace(struct_def.defined_namespace, &code); - GenStruct(struct_def, &code); + SetNameSpace(struct_def.defined_namespace); + GenStruct(struct_def); } } for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end(); ++it) { const auto &struct_def = **it; if (!struct_def.fixed && !struct_def.generated) { - SetNameSpace(struct_def.defined_namespace, &code); - GenTable(struct_def, &code); + SetNameSpace(struct_def.defined_namespace); + GenTable(struct_def); } } for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end(); ++it) { const auto &struct_def = **it; if (!struct_def.fixed && !struct_def.generated) { - SetNameSpace(struct_def.defined_namespace, &code); - GenTablePost(struct_def, &code); + SetNameSpace(struct_def.defined_namespace); + GenTablePost(struct_def); } } @@ -150,98 +150,119 @@ class CppGenerator : public BaseGenerator { ++it) { const auto &enum_def = **it; if (enum_def.is_union && !enum_def.generated) { - SetNameSpace(enum_def.defined_namespace, &code); - GenUnionPost(enum_def, &code); + SetNameSpace(enum_def.defined_namespace); + GenUnionPost(enum_def); } } // Generate convenient global helper functions: if (parser_.root_struct_def_) { - SetNameSpace((*parser_.root_struct_def_).defined_namespace, &code); - const std::string &name = parser_.root_struct_def_->name; - const std::string qualified_name = + auto &struct_def = *parser_.root_struct_def_; + SetNameSpace(struct_def.defined_namespace); + const auto &name = struct_def.name; + const auto qualified_name = parser_.namespaces_.back()->GetFullyQualifiedName(name); - const std::string cpp_name = TranslateNameSpace(qualified_name); + const auto cpp_name = TranslateNameSpace(qualified_name); + + code_.SetValue("STRUCT_NAME", name); + code_.SetValue("CPP_NAME", cpp_name); // The root datatype accessor: - code += "inline "; - code += "const " + cpp_name + " *Get" + name + "(const void *buf) {\n"; - code += " return flatbuffers::GetRoot<" + cpp_name + ">(buf);\n"; - code += "}\n\n"; + code_ += "inline \\"; + code_ += "const {{CPP_NAME}} *Get{{STRUCT_NAME}}(const void *buf) {"; + code_ += " return flatbuffers::GetRoot<{{CPP_NAME}}>(buf);"; + code_ += "}"; + code_ += ""; if (parser_.opts.mutable_buffer) { - code += "inline " + name + " *GetMutable" + name + "(void *buf) {\n"; - code += " return flatbuffers::GetMutableRoot<" + name + ">(buf);\n"; - code += "}\n\n"; + code_ += "inline \\"; + code_ += "{{STRUCT_NAME}} *GetMutable{{STRUCT_NAME}}(void *buf) {"; + code_ += " return flatbuffers::GetMutableRoot<{{STRUCT_NAME}}>(buf);"; + code_ += "}"; + code_ += ""; } if (parser_.file_identifier_.length()) { // Return the identifier - code += "inline const char *" + name + "Identifier() {\n"; - code += " return \"" + parser_.file_identifier_ + "\";\n"; - code += "}\n\n"; + code_ += "inline const char *{{STRUCT_NAME}}Identifier() {"; + code_ += " return \"" + parser_.file_identifier_ + "\";"; + code_ += "}"; + code_ += ""; // Check if a buffer has the identifier. - code += "inline "; - code += "bool " + name + "BufferHasIdentifier(const void *buf) {\n"; - code += " return flatbuffers::BufferHasIdentifier(buf, "; - code += name + "Identifier());\n"; - code += "}\n\n"; + code_ += "inline \\"; + code_ += "bool {{STRUCT_NAME}}BufferHasIdentifier(const void *buf) {"; + code_ += " return flatbuffers::BufferHasIdentifier("; + code_ += " buf, {{STRUCT_NAME}}Identifier());"; + code_ += "}"; + code_ += ""; } // The root verifier. - code += "inline bool Verify" + name + "Buffer("; - code += "flatbuffers::Verifier &verifier) {\n"; - code += " return verifier.VerifyBuffer<" + cpp_name + ">("; - if (parser_.file_identifier_.length()) - code += name + "Identifier()"; - else - code += "nullptr"; - code += ");\n"; - code += "}\n\n"; + if (parser_.file_identifier_.length()) { + code_.SetValue("ID", name + "Identifier()"); + } else { + code_.SetValue("ID", "nullptr"); + } + + code_ += "inline bool Verify{{STRUCT_NAME}}Buffer("; + code_ += " flatbuffers::Verifier &verifier) {"; + code_ += " return verifier.VerifyBuffer<{{CPP_NAME}}>({{ID}});"; + code_ += "}"; + code_ += ""; if (parser_.file_extension_.length()) { // Return the extension - code += "inline const char *" + name + "Extension() {\n"; - code += " return \"" + parser_.file_extension_ + "\";\n"; - code += "}\n\n"; + code_ += "inline const char *{{STRUCT_NAME}}Extension() {"; + code_ += " return \"" + parser_.file_extension_ + "\";"; + code_ += "}"; + code_ += ""; } // Finish a buffer with a given root object: - code += "inline void Finish" + name + "Buffer"; - code += "(flatbuffers::FlatBufferBuilder &fbb, "; - code += "flatbuffers::Offset<" + cpp_name + "> root) {\n"; + code_ += "inline void Finish{{STRUCT_NAME}}Buffer("; + code_ += " flatbuffers::FlatBufferBuilder &fbb,"; + code_ += " flatbuffers::Offset<{{CPP_NAME}}> root) {"; if (parser_.file_identifier_.length()) - code += " fbb.Finish(root, " + name + "Identifier());\n"; + code_ += " fbb.Finish(root, {{STRUCT_NAME}}Identifier());"; else - code += " fbb.Finish(root);\n"; - code += "}\n\n"; + code_ += " fbb.Finish(root);"; + code_ += "}"; + code_ += ""; if (parser_.opts.generate_object_based_api) { // A convenient root unpack function. auto native_name = - NativeName(WrapInNameSpace(*parser_.root_struct_def_)); - code += "inline " + GenTypeNativePtr(native_name, nullptr, false); - code += " UnPack" + name; - code += "(const void *buf, const flatbuffers::resolver_function_t *"; - code += "resolver = nullptr) {\n"; - code += " return "; - code += GenTypeNativePtr(native_name, nullptr, true); - code += "(Get" + name + "(buf)->UnPack(resolver));\n"; - code += "}\n\n"; + NativeName(WrapInNameSpace(struct_def)); + code_.SetValue("UNPACK_RETURN", + GenTypeNativePtr(native_name, nullptr, false)); + code_.SetValue("UNPACK_TYPE", + GenTypeNativePtr(native_name, nullptr, true)); + + code_ += "inline {{UNPACK_RETURN}} UnPack{{STRUCT_NAME}}("; + code_ += " const void *buf,"; + code_ += " const flatbuffers::resolver_function_t *res = nullptr) {"; + code_ += " return {{UNPACK_TYPE}}\\"; + code_ += "(Get{{STRUCT_NAME}}(buf)->UnPack(res));"; + code_ += "}"; + code_ += ""; } } assert(cur_name_space_); - SetNameSpace(nullptr, &code); + SetNameSpace(nullptr); // Close the include guard. - code += "#endif // " + include_guard + "\n"; + code_ += "#endif // " + include_guard; - return SaveFile(GeneratedFileName(path_, file_name_).c_str(), code, false); + const auto file_path = GeneratedFileName(path_, file_name_); + const auto final_code = code_.ToString(); + return SaveFile(file_path.c_str(), final_code, false); } private: + CodeWriter code_; + // This tracks the current namespace so we can insert namespace declarations. const Namespace *cur_name_space_; @@ -259,6 +280,12 @@ class CppGenerator : public BaseGenerator { return cpp_qualified_name; } + void GenComment(const std::vector &dc, const char *prefix = "") { + std::string text; + ::flatbuffers::GenComment(dc, &text, nullptr, prefix); + code_ += text + "\\"; + } + // Return a C++ type from the table in idl.h std::string GenTypeBasic(const Type &type, bool user_facing_type) const { static const char *ctypename[] = { @@ -413,8 +440,8 @@ class CppGenerator : public BaseGenerator { } static std::string UnionVerifySignature(const EnumDef &enum_def) { - return "inline bool Verify" + enum_def.name + - "(flatbuffers::Verifier &verifier, const void *union_obj, " + + return "bool Verify" + enum_def.name + + "(flatbuffers::Verifier &verifier, const void *obj, " + enum_def.name + " type)"; } @@ -423,7 +450,7 @@ class CppGenerator : public BaseGenerator { return (inclass ? "static " : "") + std::string("flatbuffers::NativeTable *") + (inclass ? "" : enum_def.name + "Union::") + - "UnPack(const void *union_obj, " + enum_def.name + + "UnPack(const void *obj, " + enum_def.name + " type, const flatbuffers::resolver_function_t *resolver)"; } @@ -431,17 +458,17 @@ class CppGenerator : public BaseGenerator { return "flatbuffers::Offset " + (inclass ? "" : enum_def.name + "Union::") + "Pack(flatbuffers::FlatBufferBuilder &_fbb, " + - "const flatbuffers::rehasher_function_t *rehasher" + + "const flatbuffers::rehasher_function_t *_rehasher" + (inclass ? " = nullptr" : "") + ") const"; } static std::string TableCreateSignature(const StructDef &struct_def, bool predecl) { - return "inline flatbuffers::Offset<" + struct_def.name + "> Create" + + return "flatbuffers::Offset<" + struct_def.name + "> Create" + struct_def.name + "(flatbuffers::FlatBufferBuilder &_fbb, const " + NativeName(struct_def.name) + - " *_o, const flatbuffers::rehasher_function_t *rehasher" + + " *_o, const flatbuffers::rehasher_function_t *_rehasher" + (predecl ? " = nullptr" : "") + ")"; } @@ -465,51 +492,66 @@ class CppGenerator : public BaseGenerator { } // Generate an enum declaration and an enum string lookup table. - void GenEnum(const EnumDef &enum_def, std::string *code_ptr) { - std::string &code = *code_ptr; - GenComment(enum_def.doc_comment, code_ptr, nullptr); - code += GenEnumDecl(enum_def); + void GenEnum(const EnumDef &enum_def) { + code_.SetValue("ENUM_NAME", enum_def.name); + code_.SetValue("BASE_TYPE", GenTypeBasic(enum_def.underlying_type, false)); + code_.SetValue("SEP", ""); + + GenComment(enum_def.doc_comment); + code_ += GenEnumDecl(enum_def) + "\\"; if (parser_.opts.scoped_enums) - code += " : " + GenTypeBasic(enum_def.underlying_type, false); - code += " {\n"; + code_ += " : {{BASE_TYPE}}\\"; + code_ += " {"; + int64_t anyv = 0; const EnumVal *minv = nullptr, *maxv = nullptr; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - GenComment(ev.doc_comment, code_ptr, nullptr, " "); - code += " " + GenEnumValDecl(enum_def, ev.name) + " = "; - code += NumToString(ev.value); - if (it != enum_def.vals.vec.end() - 1) code += ",\n"; + + GenComment(ev.doc_comment, " "); + code_.SetValue("KEY", GenEnumValDecl(enum_def, ev.name)); + code_.SetValue("VALUE", NumToString(ev.value)); + code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; + code_.SetValue("SEP", ",\n"); + minv = !minv || minv->value > ev.value ? &ev : minv; maxv = !maxv || maxv->value < ev.value ? &ev : maxv; anyv |= ev.value; } + if (parser_.opts.scoped_enums || parser_.opts.prefixed_enums) { assert(minv && maxv); + + code_.SetValue("SEP", ",\n"); if (enum_def.attributes.Lookup("bit_flags")) { - if (minv->value != 0) // If the user didn't defined NONE value - code += ",\n"; - code += " " + GenEnumValDecl(enum_def, "NONE") + " = 0"; - if (maxv->value != anyv) // If the user didn't defined ANY value - code += ",\n"; - code += " " + GenEnumValDecl(enum_def, "ANY") + " = " + - NumToString(anyv); + if (minv->value != 0) { // If the user didn't defined NONE value + code_.SetValue("KEY", GenEnumValDecl(enum_def, "NONE")); + code_.SetValue("VALUE", "0"); + code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; + } + if (maxv->value != anyv) { // If the user didn't defined ANY value + code_.SetValue("KEY", GenEnumValDecl(enum_def, "ANY")); + code_.SetValue("VALUE", NumToString(anyv)); + code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; + } } else { // MIN & MAX are useless for bit_flags - code += ",\n"; - code += " " + GenEnumValDecl(enum_def, "MIN") + " = "; - code += GenEnumValDecl(enum_def, minv->name); - code += ",\n"; - code += " " + GenEnumValDecl(enum_def, "MAX") + " = "; - code += GenEnumValDecl(enum_def, maxv->name); + code_.SetValue("KEY",GenEnumValDecl(enum_def, "MIN")); + code_.SetValue("VALUE", GenEnumValDecl(enum_def, minv->name)); + code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; + + code_.SetValue("KEY",GenEnumValDecl(enum_def, "MAX")); + code_.SetValue("VALUE", GenEnumValDecl(enum_def, maxv->name)); + code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; } } - code += "\n"; - code += "};\n"; - if (parser_.opts.scoped_enums && enum_def.attributes.Lookup("bit_flags")) - code += "DEFINE_BITMASK_OPERATORS(" + enum_def.name + ", " + - GenTypeBasic(enum_def.underlying_type, false) + ")\n"; - code += "\n"; + code_ += ""; + code_ += "};"; + + if (parser_.opts.scoped_enums && enum_def.attributes.Lookup("bit_flags")) { + code_ += "DEFINE_BITMASK_OPERATORS({{ENUM_NAME}}, {{BASE_TYPE}})"; + } + code_ += ""; // Generate a generate string table for enum values. // Problem is, if values are very sparse that could generate really big @@ -522,179 +564,222 @@ class CppGenerator : public BaseGenerator { static const int kMaxSparseness = 5; if (range / static_cast(enum_def.vals.vec.size()) < kMaxSparseness) { - code += "inline const char **EnumNames" + enum_def.name + "() {\n"; - code += " static const char *names[] = { "; + code_ += "inline const char **EnumNames{{ENUM_NAME}}() {"; + code_ += " static const char *names[] = {"; + auto val = enum_def.vals.vec.front()->value; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - while (val++ != ev.value) code += "\"\", "; - code += "\"" + ev.name + "\", "; + while (val++ != ev.value) { + code_ += " \"\","; + } + code_ += " \"" + ev.name + "\","; } - code += "nullptr };\n"; - code += " return names;\n"; - code += "}\n\n"; - code += "inline const char *EnumName" + enum_def.name; - code += "(" + enum_def.name + " e) { return EnumNames" + enum_def.name; - code += "()[static_cast(e)"; + code_ += " nullptr"; + code_ += " };"; + + code_ += " return names;"; + code_ += "}"; + code_ += ""; + + code_ += "inline const char *EnumName{{ENUM_NAME}}({{ENUM_NAME}} e) {"; + + code_ += " const size_t index = static_cast(e)\\"; if (enum_def.vals.vec.front()->value) { - code += " - static_cast("; - code += GetEnumValUse(enum_def, *enum_def.vals.vec.front()) + ")"; + auto vals = GetEnumValUse(enum_def, *enum_def.vals.vec.front()); + code_ += " - static_cast(" + vals + ")\\"; } - code += "]; }\n\n"; + code_ += ";"; + + code_ += " return EnumNames{{ENUM_NAME}}()[index];"; + code_ += "}"; + code_ += ""; } // Generate type traits for unions to map from a type to union enum value. if (enum_def.is_union) { - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; + if (it == enum_def.vals.vec.begin()) { - code += "template struct " + enum_def.name + "Traits {\n"; + code_ += "template struct {{ENUM_NAME}}Traits {"; } else { - code += "template<> struct " + enum_def.name + "Traits<" + - WrapInNameSpace(*ev.struct_def) + "> {\n"; + auto name = WrapInNameSpace(*ev.struct_def); + code_ += "template<> struct {{ENUM_NAME}}Traits<" + name + "> {"; } - code += " static const " + enum_def.name + " enum_value = " + - GetEnumValUse(enum_def, ev) + ";\n"; - code += "};\n\n"; + + auto value = GetEnumValUse(enum_def, ev); + code_ += " static const {{ENUM_NAME}} enum_value = " + value + ";"; + code_ += "};"; + code_ += ""; } } if (parser_.opts.generate_object_based_api && enum_def.is_union) { // Generate a union type - code += "struct " + enum_def.name + "Union {\n"; - code += " " + enum_def.name + " type;\n\n"; - code += " flatbuffers::NativeTable *table;\n"; - code += " " + enum_def.name + "Union() : type("; - code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE")); - code += "), table(nullptr) {}\n"; - code += " " + enum_def.name + "Union(const "; - code += enum_def.name + "Union &);\n"; - code += " " + enum_def.name + "Union &operator=(const "; - code += enum_def.name + "Union &);\n"; - code += " ~" + enum_def.name + "Union() { Reset(); }\n"; - code += " void Reset();\n\n"; + code_.SetValue("NAME", enum_def.name); + code_.SetValue("NONE", + GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"))); + + code_ += "struct {{NAME}}Union {"; + code_ += " {{NAME}} type;"; + code_ += " flatbuffers::NativeTable *table;"; + code_ += ""; + code_ += " {{NAME}}Union() : type({{NONE}}), table(nullptr) {}"; + code_ += " {{NAME}}Union(const {{NAME}}Union &);"; + code_ += " {{NAME}}Union &operator=(const {{NAME}}Union &);"; + code_ += " ~{{NAME}}Union() { Reset(); }"; + code_ += ""; + code_ += " void Reset();"; + code_ += ""; + code_ += " template "; + code_ += " void Set(T&& value) {"; + code_ += " Reset();"; + code_ += " type = {{NAME}}Traits::enum_value;"; + code_ += " if (type != {{NONE}}) {"; + code_ += " table = new T(std::forward(value));"; + code_ += " }"; + code_ += " }"; + code_ += ""; + code_ += " " + UnionUnPackSignature(enum_def, true) + ";"; + code_ += " " + UnionPackSignature(enum_def, true) + ";"; + code_ += ""; - code += " template \n"; - code += " void Set(T&& value) {\n"; - code += " Reset();\n"; - code += " type = " + enum_def.name; - code += "Traits::enum_value;\n"; - code += " if (type != "; - code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE")); - code += ") {\n"; - code += " table = new T(std::forward(value));\n"; - code += " }\n"; - code += " }\n\n"; - code += " " + UnionUnPackSignature(enum_def, true) + ";\n"; - code += " " + UnionPackSignature(enum_def, true) + ";\n\n"; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - if (ev.value) { - auto native_name = NativeName(WrapInNameSpace(*ev.struct_def)); - code += " " + native_name + " *As"; - code += ev.name + "() { return type == "; - code += GetEnumValUse(enum_def, ev); - code += " ? reinterpret_cast<" + native_name; - code += " *>(table) : nullptr; }\n"; + if (!ev.value) { + continue; } + + const auto native_type = NativeName(WrapInNameSpace(*ev.struct_def)); + code_.SetValue("NATIVE_TYPE", native_type); + code_.SetValue("NATIVE_NAME", ev.name); + code_.SetValue("NATIVE_ID", GetEnumValUse(enum_def, ev)); + + code_ += " {{NATIVE_TYPE}} *As{{NATIVE_NAME}}() {"; + code_ += " return type == {{NATIVE_ID}} ?"; + code_ += " reinterpret_cast<{{NATIVE_TYPE}} *>(table) : nullptr;"; + code_ += " }"; } - code += "};\n\n"; + code_ += "};"; + code_ += ""; } if (enum_def.is_union) { - code += UnionVerifySignature(enum_def) + ";\n\n"; + code_ += UnionVerifySignature(enum_def) + ";"; + code_ += ""; } } - void GenUnionPost(const EnumDef &enum_def, std::string *code_ptr) { + void GenUnionPost(const EnumDef &enum_def) { // Generate a verifier function for this union that can be called by the // table verifier functions. It uses a switch case to select a specific // verifier function to call, this should be safe even if the union type // has been corrupted, since the verifiers will simply fail when called // on the wrong type. - std::string &code = *code_ptr; - code += UnionVerifySignature(enum_def) + " {\n"; - code += " switch (type) {\n"; + code_.SetValue("ENUM_NAME", enum_def.name); + + code_ += "inline " + UnionVerifySignature(enum_def) + " {"; + code_ += " switch (type) {"; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - code += " case " + GetEnumValUse(enum_def, ev); - if (!ev.value) { - code += ": return true;\n"; // "NONE" enum value. + code_.SetValue("LABEL", GetEnumValUse(enum_def, ev)); + + if (ev.value) { + code_.SetValue("TYPE", WrapInNameSpace(*ev.struct_def)); + code_ += " case {{LABEL}}: {"; + code_ += " auto ptr = reinterpret_cast(obj);"; + code_ += " return verifier.VerifyTable(ptr);"; + code_ += " }"; } else { - code += ": return verifier.VerifyTable(reinterpret_castname; - code += "(_fbb, reinterpret_castname); + code_ += " case {{LABEL}}: {"; + code_ += " auto ptr = reinterpret_cast(table);"; + code_ += " return Create{{NAME}}(_fbb, ptr, _rehasher).Union();"; + code_ += " }"; + } + code_ += " default: return 0;"; + code_ += " }"; + code_ += "}"; + code_ += ""; + + // Union Reset() function. + code_.SetValue("NONE", + GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"))); + + code_ += "inline void {{ENUM_NAME}}Union::Reset() {"; + code_ += " switch (type) {"; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - if (ev.value) { - code += " case " + GetEnumValUse(enum_def, ev); - code += ": delete reinterpret_cast<"; - code += NativeName(WrapInNameSpace(*ev.struct_def)); - code += " *>(table); break;\n"; + if (!ev.value) { + continue; } + + code_.SetValue("LABEL", GetEnumValUse(enum_def, ev)); + code_.SetValue("TYPE", NativeName(WrapInNameSpace(*ev.struct_def))); + + code_ += " case {{LABEL}}: {"; + code_ += " auto ptr = reinterpret_cast<{{TYPE}} *>(table);"; + code_ += " delete ptr;"; + code_ += " break;"; + code_ += " }"; } - code += " default: break;\n"; - code += " }\n"; - code += " table = nullptr;\n"; - code += " type = "; - code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE")); - code += ";\n"; - code += "}\n\n"; + code_ += " default: break;"; + code_ += " }"; + code_ += " table = nullptr;"; + code_ += " type = {{NONE}};"; + code_ += "}"; + code_ += ""; } } @@ -722,17 +807,18 @@ class CppGenerator : public BaseGenerator { return "VT_" + uname; } - void GenFullyQualifiedNameGetter(const std::string &name, - std::string *code_ptr) { - std::string &code = *code_ptr; - if (parser_.opts.generate_name_strings) { - code += - " static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() " - "{\n"; - code += " return \"" + - parser_.namespaces_.back()->GetFullyQualifiedName(name) + "\";\n"; - code += " }\n"; + void GenFullyQualifiedNameGetter(const std::string &name) { + if (!parser_.opts.generate_name_strings) { + return; } + + auto fullname = parser_.namespaces_.back()->GetFullyQualifiedName(name); + code_.SetValue("NAME", fullname); + code_.SetValue("CONSTEXPR", "FLATBUFFERS_CONSTEXPR"); + + code_ += " static {{CONSTEXPR}} const char *GetFullyQualifiedName() {"; + code_ += " return \"{{NAME}}\";"; + code_ += " }"; } std::string GenDefaultConstant(const FieldDef &field) { @@ -759,31 +845,39 @@ class CppGenerator : public BaseGenerator { } } - void GenSimpleParam(const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; - code += ",\n"; - code += " " + GenTypeWire(field.value.type, " ", true); - code += field.name + " = " + GetDefaultScalarValue(field); + void GenParam(const FieldDef &field, bool direct, const char *prefix) { + code_.SetValue("PRE", prefix); + code_.SetValue("PARAM_NAME", field.name); + if (direct && field.value.type.base_type == BASE_TYPE_STRING) { + code_.SetValue("PARAM_TYPE", "const char *"); + code_.SetValue("PARAM_VALUE", "nullptr"); + } else if (direct && field.value.type.base_type == BASE_TYPE_VECTOR) { + auto type = GenTypeWire(field.value.type.VectorType(), "", false); + code_.SetValue("PARAM_TYPE", "const std::vector<" + type + "> *"); + code_.SetValue("PARAM_VALUE", "nullptr"); + } else { + code_.SetValue("PARAM_TYPE", GenTypeWire(field.value.type, " ", true)); + code_.SetValue("PARAM_VALUE", GetDefaultScalarValue(field)); + } + code_ += "{{PRE}}{{PARAM_TYPE}}{{PARAM_NAME}} = {{PARAM_VALUE}}\\"; } // Generate a member, including a default value for scalars and raw pointers. - void GenMember(const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; + void GenMember(const FieldDef &field) { if (!field.deprecated && // Deprecated fields won't be accessible. field.value.type.base_type != BASE_TYPE_UTYPE) { auto type = GenTypeNative(field.value.type, false, field); auto cpp_type = field.attributes.Lookup("cpp_type"); - code += " " + (cpp_type ? cpp_type->constant + " *" : type+ " ") + - field.name + ";\n"; + auto full_type = (cpp_type ? cpp_type->constant + " *" : type + " "); + code_.SetValue("FIELD_TYPE", full_type); + code_.SetValue("FIELD_NAME", field.name); + code_ += " {{FIELD_TYPE}}{{FIELD_NAME}};"; } } // Generate the default constructor for this struct. Properly initialize all // scalar members with default values. - void GenDefaultConstructor(const StructDef& struct_def, - std::string *code_ptr) { - std::string &code = *code_ptr; - code += " " + NativeName(struct_def.name) + "()"; + void GenDefaultConstructor(const StructDef& struct_def) { std::string initializer_list; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { @@ -794,301 +888,394 @@ class CppGenerator : public BaseGenerator { // Scalar types get parsed defaults, raw pointers get nullptrs. if (IsScalar(field.value.type.base_type)) { if (!initializer_list.empty()) { - initializer_list += ",\n "; + initializer_list += ",\n "; } initializer_list += field.name; initializer_list += "(" + GetDefaultScalarValue(field) + ")"; } else if (cpp_type) { if (!initializer_list.empty()) { - code += ",\n"; - code += " "; + initializer_list += ",\n "; } initializer_list += field.name + "(0)"; } } } if (!initializer_list.empty()) { - code += "\n"; - code += " : " + initializer_list; + initializer_list = "\n : " + initializer_list; + } + + code_.SetValue("NATIVE_NAME", NativeName(struct_def.name)); + code_.SetValue("INIT_LIST", initializer_list); + + code_ += " {{NATIVE_NAME}}(){{INIT_LIST}} {"; + code_ += " }"; + } + + void GenNativeTable(const StructDef &struct_def) { + const auto native_name = NativeName(struct_def.name); + code_.SetValue("STRUCT_NAME", struct_def.name); + code_.SetValue("NATIVE_NAME", native_name); + + // Generate a C++ object that can hold an unpacked version of this table. + code_ += "struct {{NATIVE_NAME}} : public flatbuffers::NativeTable {"; + code_ += " typedef {{STRUCT_NAME}} TableType;"; + GenFullyQualifiedNameGetter(native_name); + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + GenMember(**it); + } + GenDefaultConstructor(struct_def); + code_ += "};"; + code_ += ""; + } + + // Generate the code to call the appropriate Verify function(s) for a field. + void GenVerifyCall(const FieldDef &field, const char* prefix) { + code_.SetValue("PRE", prefix); + code_.SetValue("NAME", field.name); + code_.SetValue("REQUIRED", field.required ? "Required" : ""); + code_.SetValue("SIZE", GenTypeSize(field.value.type)); + code_.SetValue("OFFSET", GenFieldOffsetName(field)); + code_ += "{{PRE}}VerifyField{{REQUIRED}}<{{SIZE}}>(verifier, {{OFFSET}})\\"; + + switch (field.value.type.base_type) { + case BASE_TYPE_UNION: { + code_.SetValue("ENUM_NAME", field.value.type.enum_def->name); + code_.SetValue("SUFFIX", UnionTypeFieldSuffix()); + code_ += "{{PRE}}Verify{{ENUM_NAME}}(verifier, {{NAME}}(), " + "{{NAME}}{{SUFFIX}}())\\"; + break; + } + case BASE_TYPE_STRUCT: { + if (!field.value.type.struct_def->fixed) { + code_ += "{{PRE}}verifier.VerifyTable({{NAME}}())\\"; + } + break; + } + case BASE_TYPE_STRING: { + code_ += "{{PRE}}verifier.Verify({{NAME}}())\\"; + break; + } + case BASE_TYPE_VECTOR: { + code_ += "{{PRE}}verifier.Verify({{NAME}}())\\"; + + switch (field.value.type.element) { + case BASE_TYPE_STRING: { + code_ += "{{PRE}}verifier.VerifyVectorOfStrings({{NAME}}())\\"; + break; + } + case BASE_TYPE_STRUCT: { + if (!field.value.type.struct_def->fixed) { + code_ += "{{PRE}}verifier.VerifyVectorOfTables({{NAME}}())\\"; + } + break; + } + default: + break; + } + break; + } + default: { + break; + } } - code += " {}\n"; } // Generate an accessor struct, builder structs & function for a table. - void GenTable(const StructDef &struct_def, std::string *code_ptr) { - std::string &code = *code_ptr; - + void GenTable(const StructDef &struct_def) { if (parser_.opts.generate_object_based_api) { - // Generate a C++ object that can hold an unpacked version of this - // table. - code += "struct " + NativeName(struct_def.name); - code += " : public flatbuffers::NativeTable {\n"; - code += " typedef " + struct_def.name + " TableType;\n"; - // Generate GetFullyQualifiedName - GenFullyQualifiedNameGetter(NativeName(struct_def.name), &code); - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - const auto &field = **it; - GenMember(field, &code); - } - GenDefaultConstructor(struct_def, &code); - code += "};\n\n"; + GenNativeTable(struct_def); } // Generate an accessor struct, with methods of the form: // type name() const { return GetField(offset, defaultval); } - GenComment(struct_def.doc_comment, code_ptr, nullptr); - code += "struct " + struct_def.name; - code += " FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table"; - code += " {\n"; + GenComment(struct_def.doc_comment); + + code_.SetValue("STRUCT_NAME", struct_def.name); + code_ += "struct {{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS" + " : private flatbuffers::Table {"; if (parser_.opts.generate_object_based_api) { - code += " typedef " + NativeName(struct_def.name) + - " NativeTableType;\n"; + code_ += " typedef {{NATIVE_NAME}} NativeTableType;"; } - // Generate GetFullyQualifiedName - GenFullyQualifiedNameGetter(struct_def.name, &code); + + GenFullyQualifiedNameGetter(struct_def.name); + // Generate field id constants. if (struct_def.fields.vec.size() > 0) { - code += " enum {\n"; - bool is_first_field = - true; // track the first field that's not deprecated + // We need to add a trailing comma to all elements except the last one as + // older versions of gcc complain about this. + code_.SetValue("SEP", ""); + code_ += " enum {"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (!field.deprecated) { // Deprecated fields won't be accessible. - if (!is_first_field) { - // Add trailing comma and newline to previous element. Don't add - // trailing comma to - // last element since older versions of gcc complain about this. - code += ",\n"; - } else { - is_first_field = false; - } - code += " " + GenFieldOffsetName(field) + " = "; - code += NumToString(field.value.offset); + if (field.deprecated) { + // Deprecated fields won't be accessible. + continue; } + + code_.SetValue("OFFSET_NAME", GenFieldOffsetName(field)); + code_.SetValue("OFFSET_VALUE", NumToString(field.value.offset)); + code_ += "{{SEP}} {{OFFSET_NAME}} = {{OFFSET_VALUE}}\\"; + code_.SetValue("SEP", ",\n"); } - code += "\n"; - code += " };\n"; + code_ += ""; + code_ += " };"; } + // Generate the accessors. for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (!field.deprecated) { // Deprecated fields won't be accessible. - auto is_scalar = IsScalar(field.value.type.base_type); - GenComment(field.doc_comment, code_ptr, nullptr, " "); - code += " " + GenTypeGet(field.value.type, " ", "const ", " *", true); - code += field.name + "() const { return "; - // Call a different accessor for pointers, that indirects. - auto accessor = - is_scalar - ? "GetField<" - : (IsStruct(field.value.type) ? "GetStruct<" : "GetPointer<"); - auto offsetstr = GenFieldOffsetName(field); - auto call = accessor + - GenTypeGet(field.value.type, "", "const ", " *", false) + - ">(" + offsetstr; - // Default value as second arg for non-pointer types. - if (IsScalar(field.value.type.base_type)) - call += ", " + GenDefaultConstant(field); - call += ")"; - code += GenUnderlyingCast(field, true, call); - code += "; }\n"; - if (parser_.opts.mutable_buffer) { - if (is_scalar) { - code += " bool mutate_" + field.name + "("; - code += GenTypeBasic(field.value.type, true); - code += - " _" + field.name + ") { return SetField(" + offsetstr + ", "; - code += GenUnderlyingCast(field, false, "_" + field.name); - code += "); }\n"; - } else { - auto type = GenTypeGet(field.value.type, " ", "", " *", true); - code += " " + type + "mutable_" + field.name + "() { return "; - code += GenUnderlyingCast(field, true, - accessor + type + ">(" + offsetstr + ")"); - code += "; }\n"; - } - } - auto nested = field.attributes.Lookup("nested_flatbuffer"); - if (nested) { - std::string qualified_name = - parser_.namespaces_.back()->GetFullyQualifiedName( - nested->constant); - auto nested_root = parser_.structs_.Lookup(qualified_name); - assert(nested_root); // Guaranteed to exist by parser. - (void)nested_root; - std::string cpp_qualified_name = TranslateNameSpace(qualified_name); + if (field.deprecated) { + // Deprecated fields won't be accessible. + continue; + } - code += " const " + cpp_qualified_name + " *" + field.name; - code += "_nested_root() const { return flatbuffers::GetRoot<"; - code += cpp_qualified_name + ">(" + field.name + "()->Data()); }\n"; + const bool is_struct = IsStruct(field.value.type); + const bool is_scalar = IsScalar(field.value.type.base_type); + code_.SetValue("FIELD_NAME", field.name); + + // Call a different accessor for pointers, that indirects. + std::string accessor = ""; + if (is_scalar) { + accessor = "GetField<"; + } else if (is_struct) { + accessor = "GetStruct<"; + } else { + accessor = "GetPointer<"; + } + auto offset_str = GenFieldOffsetName(field); + auto offset_type = + GenTypeGet(field.value.type, "", "const ", " *", false); + + auto call = accessor + offset_type + ">(" + offset_str; + // Default value as second arg for non-pointer types. + if (is_scalar) { + call += ", " + GenDefaultConstant(field); + } + call += ")"; + + GenComment(field.doc_comment, " "); + code_.SetValue("FIELD_TYPE", + GenTypeGet(field.value.type, " ", "const ", " *", true)); + code_.SetValue("FIELD_VALUE", GenUnderlyingCast(field, true, call)); + + code_ += " {{FIELD_TYPE}}{{FIELD_NAME}}() const {"; + code_ += " return {{FIELD_VALUE}};"; + code_ += " }"; + + if (parser_.opts.mutable_buffer) { + if (is_scalar) { + code_.SetValue("OFFSET_NAME", offset_str); + code_.SetValue("FIELD_TYPE", GenTypeBasic(field.value.type, true)); + code_.SetValue("FIELD_VALUE", + GenUnderlyingCast(field, false, "_" + field.name)); + + code_ += " bool mutate_{{FIELD_NAME}}({{FIELD_TYPE}} " + "_{{FIELD_NAME}}) {"; + code_ += " return SetField({{OFFSET_NAME}}, {{FIELD_VALUE}});"; + code_ += " }"; + } else { + auto type = GenTypeGet(field.value.type, " ", "", " *", true); + auto underlying = accessor + type + ">(" + offset_str + ")"; + code_.SetValue("FIELD_TYPE", type); + code_.SetValue("FIELD_VALUE", + GenUnderlyingCast(field, true, underlying)); + + code_ += " {{FIELD_TYPE}}mutable_{{FIELD_NAME}}() {"; + code_ += " return {{FIELD_VALUE}};"; + code_ += " }"; } - // Generate a comparison function for this field if it is a key. - if (field.key) { - code += " bool KeyCompareLessThan(const " + struct_def.name; - code += " *o) const { return "; - if (field.value.type.base_type == BASE_TYPE_STRING) code += "*"; - code += field.name + "() < "; - if (field.value.type.base_type == BASE_TYPE_STRING) code += "*"; - code += "o->" + field.name + "(); }\n"; - code += " int KeyCompareWithValue("; - if (field.value.type.base_type == BASE_TYPE_STRING) { - code += "const char *val) const { return strcmp(" + field.name; - code += "()->c_str(), val); }\n"; - } else { - if (parser_.opts.scoped_enums && field.value.type.enum_def && - IsScalar(field.value.type.base_type)) { - code += GenTypeGet(field.value.type, " ", "const ", " *", true); - } else { - code += GenTypeBasic(field.value.type, false); - } - code += " val) const { return " + field.name + "() < val ? -1 : "; - code += field.name + "() > val; }\n"; + } + + auto nested = field.attributes.Lookup("nested_flatbuffer"); + if (nested) { + std::string qualified_name = + parser_.namespaces_.back()->GetFullyQualifiedName( + nested->constant); + auto nested_root = parser_.structs_.Lookup(qualified_name); + assert(nested_root); // Guaranteed to exist by parser. + (void)nested_root; + code_.SetValue("CPP_NAME", TranslateNameSpace(qualified_name)); + + code_ += " const {{CPP_NAME}} *{{FIELD_NAME}}_nested_root() const {"; + code_ += " const uint8_t* data = {{FIELD_NAME}}()->Data();"; + code_ += " return flatbuffers::GetRoot<{{CPP_NAME}}>(data);"; + code_ += " }"; + } + + // Generate a comparison function for this field if it is a key. + if (field.key) { + const bool is_string = (field.value.type.base_type == BASE_TYPE_STRING); + + code_ += " bool KeyCompareLessThan(const {{STRUCT_NAME}} *o) const {"; + if (is_string) { + code_ += " return *{{FIELD_NAME}}() < *o->{{FIELD_NAME}}();"; + } else { + code_ += " return {{FIELD_NAME}}() < o->{{FIELD_NAME}}();"; + } + code_ += " }"; + + if (is_string) { + code_ += " int KeyCompareWithValue(const char *val) const {"; + code_ += " return strcmp({{FIELD_NAME}}()->c_str(), val);"; + code_ += " }"; + } else { + auto type = GenTypeBasic(field.value.type, false); + if (parser_.opts.scoped_enums && field.value.type.enum_def && + IsScalar(field.value.type.base_type)) { + type = GenTypeGet(field.value.type, " ", "const ", " *", true); } + + code_.SetValue("KEY_TYPE", type); + code_ += " int KeyCompareWithValue({{KEY_TYPE}} val) const {"; + code_ += " const auto key = {{FIELD_NAME}}();"; + code_ += " if (key < val) {"; + code_ += " return -1;"; + code_ += " } else if (key > val) {"; + code_ += " return 1;"; + code_ += " } else {"; + code_ += " return 0;"; + code_ += " }"; + code_ += " }"; } } } + // Generate a verifier function that can check a buffer from an untrusted // source will never cause reads outside the buffer. - code += " bool Verify(flatbuffers::Verifier &verifier) const {\n"; - code += " return VerifyTableStart(verifier)"; - std::string prefix = " &&\n "; + code_ += " bool Verify(flatbuffers::Verifier &verifier) const {"; + code_ += " return VerifyTableStart(verifier)\\"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (!field.deprecated) { - code += prefix + "VerifyField"; - if (field.required) code += "Required"; - code += "<" + GenTypeSize(field.value.type); - code += ">(verifier, " + GenFieldOffsetName(field) + ")"; - switch (field.value.type.base_type) { - case BASE_TYPE_UNION: - code += prefix + "Verify" + field.value.type.enum_def->name; - code += "(verifier, " + field.name + "(), " + field.name + - UnionTypeFieldSuffix() + "())"; - break; - case BASE_TYPE_STRUCT: - if (!field.value.type.struct_def->fixed) { - code += prefix + "verifier.VerifyTable(" + field.name; - code += "())"; - } - break; - case BASE_TYPE_STRING: - code += prefix + "verifier.Verify(" + field.name + "())"; - break; - case BASE_TYPE_VECTOR: - code += prefix + "verifier.Verify(" + field.name + "())"; - switch (field.value.type.element) { - case BASE_TYPE_STRING: { - code += prefix + "verifier.VerifyVectorOfStrings(" + field.name; - code += "())"; - break; - } - case BASE_TYPE_STRUCT: { - if (!field.value.type.struct_def->fixed) { - code += - prefix + "verifier.VerifyVectorOfTables(" + field.name; - code += "())"; - } - break; - } - default: - break; - } - break; - default: - break; - } + if (field.deprecated) { + continue; } + GenVerifyCall(field, " &&\n "); } - code += prefix + "verifier.EndTable()"; - code += ";\n"; - code += " }\n"; + + code_ += " &&\n verifier.EndTable();"; + code_ += " }"; if (parser_.opts.generate_object_based_api) { // Generate the UnPack() pre declaration. - code += " " + TableUnPackSignature(struct_def, true) + ";\n"; - code += " " + TablePackSignature(struct_def, true) + ";\n"; + code_ += " " + TableUnPackSignature(struct_def, true) + ";"; + code_ += " " + TablePackSignature(struct_def, true) + ";"; } - code += "};\n\n"; // End of table. + code_ += "};"; // End of table. + code_ += ""; - // Generate a builder struct, with methods of the form: - // void add_name(type name) { - // fbb_.AddElement(offset, name, default); - // } - code += "struct " + struct_def.name + "Builder {\n"; - code += " flatbuffers::FlatBufferBuilder &fbb_;\n"; - code += " flatbuffers::uoffset_t start_;\n"; + GenBuilders(struct_def); + + if (parser_.opts.generate_object_based_api) { + // Generate a pre-declaration for a CreateX method that works with an + // unpacked C++ object. + code_ += TableCreateSignature(struct_def, true) + ";"; + code_ += ""; + } + } + + void GenBuilders(const StructDef &struct_def) { + code_.SetValue("STRUCT_NAME", struct_def.name); + + // Generate a builder struct: + code_ += "struct {{STRUCT_NAME}}Builder {"; + code_ += " flatbuffers::FlatBufferBuilder &fbb_;"; + code_ += " flatbuffers::uoffset_t start_;"; + + bool has_string_or_vector_fields = false; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; if (!field.deprecated) { - code += " void add_" + field.name + "("; - code += GenTypeWire(field.value.type, " ", true) + field.name; - code += ") {\n"; - - code += " fbb_.Add"; - if (IsScalar(field.value.type.base_type)) { - code += "Element<" + GenTypeWire(field.value.type, "", false) + ">"; - } else if (IsStruct(field.value.type)) { - code += "Struct"; - } else { - code += "Offset"; + const bool is_scalar = IsScalar(field.value.type.base_type); + const bool is_string = field.value.type.base_type == BASE_TYPE_STRING; + const bool is_vector = field.value.type.base_type == BASE_TYPE_VECTOR; + if (is_string || is_vector) { + has_string_or_vector_fields = true; } - code += "(" + struct_def.name + "::" + GenFieldOffsetName(field) + ", "; - code += GenUnderlyingCast(field, false, field.name); - if (IsScalar(field.value.type.base_type)) - code += ", " + GenDefaultConstant(field); - code += ");\n"; - code += " }\n"; + std::string offset = GenFieldOffsetName(field); + std::string name = GenUnderlyingCast(field, false, field.name); + std::string value = is_scalar ? GenDefaultConstant(field) : ""; + + // Generate accessor functions of the form: + // void add_name(type name) { + // fbb_.AddElement(offset, name, default); + // } + code_.SetValue("FIELD_NAME", field.name); + code_.SetValue("FIELD_TYPE", GenTypeWire(field.value.type, " ", true)); + code_.SetValue("ADD_OFFSET", struct_def.name + "::" + offset); + code_.SetValue("ADD_NAME", name); + code_.SetValue("ADD_VALUE", value); + if (is_scalar) { + const auto type = GenTypeWire(field.value.type, "", false); + code_.SetValue("ADD_FN", "AddElement<" + type + ">"); + } else if (IsStruct(field.value.type)) { + code_.SetValue("ADD_FN", "AddStruct"); + } else { + code_.SetValue("ADD_FN", "AddOffset"); + } + + code_ += " void add_{{FIELD_NAME}}({{FIELD_TYPE}}{{FIELD_NAME}}) {"; + code_ += " fbb_.{{ADD_FN}}(\\"; + if (is_scalar) { + code_ += "{{ADD_OFFSET}}, {{ADD_NAME}}, {{ADD_VALUE}});"; + } else { + code_ += "{{ADD_OFFSET}}, {{ADD_NAME}});"; + } + code_ += " }"; } } - code += " " + struct_def.name; - code += "Builder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) "; - code += "{ start_ = fbb_.StartTable(); }\n"; - code += " " + struct_def.name + "Builder &operator=(const "; - code += struct_def.name + "Builder &);\n"; - code += " flatbuffers::Offset<" + struct_def.name; - code += "> Finish() {\n"; - code += " auto o = flatbuffers::Offset<" + struct_def.name; - code += ">(fbb_.EndTable(start_, "; - code += NumToString(struct_def.fields.vec.size()) + "));\n"; + + // Builder constructor + code_ += " {{STRUCT_NAME}}Builder(flatbuffers::FlatBufferBuilder &_fbb)"; + code_ += " : fbb_(_fbb) {"; + code_ += " start_ = fbb_.StartTable();"; + code_ += " }"; + + // Assignment operator; + code_ += " {{STRUCT_NAME}}Builder &operator=" + "(const {{STRUCT_NAME}}Builder &);"; + + // Finish() function. + auto num_fields = NumToString(struct_def.fields.vec.size()); + code_ += " flatbuffers::Offset<{{STRUCT_NAME}}> Finish() {"; + code_ += " const auto end = fbb_.EndTable(start_, " + num_fields + ");"; + code_ += " auto o = flatbuffers::Offset<{{STRUCT_NAME}}>(end);"; + for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; if (!field.deprecated && field.required) { - code += " fbb_.Required(o, "; - code += struct_def.name + "::" + GenFieldOffsetName(field); - code += "); // " + field.name + "\n"; + code_.SetValue("FIELD_NAME", field.name); + code_.SetValue("OFFSET_NAME", GenFieldOffsetName(field)); + code_ += " fbb_.Required(o, {{STRUCT_NAME}}::{{OFFSET_NAME}});"; } } - code += " return o;\n"; - code += " }\n"; - code += "};\n\n"; + code_ += " return o;"; + code_ += " }"; + code_ += "};"; + code_ += ""; // Generate a convenient CreateX function that uses the above builder // to create a table in one go. - bool gen_vector_pars = false; - code += "inline flatbuffers::Offset<" + struct_def.name + "> Create"; - code += struct_def.name; - code += "(flatbuffers::FlatBufferBuilder &_fbb"; + code_ += "inline flatbuffers::Offset<{{STRUCT_NAME}}> " + "Create{{STRUCT_NAME}}("; + code_ += " flatbuffers::FlatBufferBuilder &_fbb\\"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; if (!field.deprecated) { - if (field.value.type.base_type == BASE_TYPE_STRING || - field.value.type.base_type == BASE_TYPE_VECTOR) { - gen_vector_pars = true; - } - GenSimpleParam(field, &code); + GenParam(field, false, ",\n "); } } - code += ") {\n"; - code += " " + struct_def.name + "Builder builder_(_fbb);\n"; + code_ += ") {"; + + code_ += " {{STRUCT_NAME}}Builder builder_(_fbb);"; for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; size; size /= 2) { for (auto it = struct_def.fields.vec.rbegin(); @@ -1096,63 +1283,52 @@ class CppGenerator : public BaseGenerator { const auto &field = **it; if (!field.deprecated && (!struct_def.sortbysize || size == SizeOf(field.value.type.base_type))) { - code += " builder_.add_" + field.name + "(" + field.name + ");\n"; + code_.SetValue("FIELD_NAME", field.name); + code_ += " builder_.add_{{FIELD_NAME}}({{FIELD_NAME}});"; } } } - code += " return builder_.Finish();\n"; - code += "}\n\n"; + code_ += " return builder_.Finish();"; + code_ += "}"; + code_ += ""; // Generate a CreateXDirect function with vector types as parameters - if (gen_vector_pars) { - code += "inline flatbuffers::Offset<" + struct_def.name + "> Create"; - code += struct_def.name; - code += "Direct(flatbuffers::FlatBufferBuilder &_fbb"; + if (has_string_or_vector_fields) { + code_ += "inline flatbuffers::Offset<{{STRUCT_NAME}}> " + "Create{{STRUCT_NAME}}Direct("; + code_ += " flatbuffers::FlatBufferBuilder &_fbb\\"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; if (!field.deprecated) { - if (field.value.type.base_type == BASE_TYPE_STRING) { - code += ",\n"; - code += " const char *"; - code += field.name + " = nullptr"; - } else if (field.value.type.base_type == BASE_TYPE_VECTOR) { - code += ",\n"; - code += " const std::vector<"; - code += GenTypeWire(field.value.type.VectorType(), "", false); - code += "> *" + field.name + " = nullptr"; - } else { - GenSimpleParam(field, &code); - } + GenParam(field, true, ",\n "); } } - code += ") {\n"; - code += " return Create" + struct_def.name + "(_fbb"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - const auto &field = **it; - if (!field.deprecated) { - if (field.value.type.base_type == BASE_TYPE_STRING) { - code += ", " + field.name + " ? "; - code += "_fbb.CreateString(" + field.name + ") : 0"; - } else if (field.value.type.base_type == BASE_TYPE_VECTOR) { - code += ", " + field.name + " ? "; - code += "_fbb.CreateVector<"; - code += GenTypeWire(field.value.type.VectorType(), "", false); - code += ">(*" + field.name + ") : 0"; - } else { - code += ", " + field.name; - } - } - } - code += ");\n"; - code += "}\n\n"; - } - if (parser_.opts.generate_object_based_api) { - // Generate a pre-declaration for a CreateX method that works with an - // unpacked C++ object. - code += TableCreateSignature(struct_def, true) + ";\n\n"; + code_ += ") {"; + code_ += " return Create{{STRUCT_NAME}}("; + code_ += " _fbb\\"; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + const auto &field = **it; + if (!field.deprecated) { + code_.SetValue("FIELD_NAME", field.name); + + if (field.value.type.base_type == BASE_TYPE_STRING) { + code_ += ",\n {{FIELD_NAME}} ? " + "_fbb.CreateString({{FIELD_NAME}}) : 0\\"; + } else if (field.value.type.base_type == BASE_TYPE_VECTOR) { + auto type = GenTypeWire(field.value.type.VectorType(), "", false); + code_ += ",\n {{FIELD_NAME}} ? " + "_fbb.CreateVector<" + type + ">(*{{FIELD_NAME}}) : 0\\"; + } else { + code_ += ",\n {{FIELD_NAME}}\\"; + } + } + } + code_ += ");"; + code_ += "}"; + code_ += ""; } } @@ -1183,185 +1359,247 @@ class CppGenerator : public BaseGenerator { } }; + std::string GenUnpackFieldStatement(const FieldDef &field, + const FieldDef *union_field) { + std::string code; + switch (field.value.type.base_type) { + case BASE_TYPE_VECTOR: { + std::string indexing; + if (field.value.type.enum_def) { + indexing += "(" + field.value.type.enum_def->name + ")"; + } + indexing += "_e->Get(_i)"; + if (field.value.type.element == BASE_TYPE_BOOL) { + indexing += " != 0"; + } + + // Generate code that pushes data from _e to _o in the form: + // for (uoffset_t i = 0; i < _e->size(); ++i) { + // _o->field.push_back(_e->Get(_i)); + // } + code += "for (flatbuffers::uoffset_t _i = 0;"; + code += " _i < _e->size(); _i++) { "; + code += "_o->" + field.name + ".push_back("; + code += GenUnpackVal(field.value.type.VectorType(), + indexing, true, field); + code += "); }"; + break; + } + case BASE_TYPE_UTYPE: { + assert(union_field->value.type.base_type == BASE_TYPE_UNION); + // Generate code that sets the union type, of the form: + // _o->field.type = _e; + code += "_o->" + union_field->name + ".type = _e;"; + break; + } + case BASE_TYPE_UNION: { + // Generate code that sets the union table, of the form: + // _o->field.table = Union::Unpack(_e, field_type(), resolver); + code += "_o->" + field.name + ".table = "; + code += field.value.type.enum_def->name + "Union::UnPack("; + code += "_e, " + field.name + UnionTypeFieldSuffix() + "(),"; + code += "resolver);"; + break; + } + default: { + auto cpp_type = field.attributes.Lookup("cpp_type"); + if (cpp_type) { + // Generate code that resolves the cpp pointer type, of the form: + // if (resolver) + // (*resolver)(&_o->field, (hash_value_t)(_e)); + // else + // _o->field = nullptr; + code += "if (resolver) "; + code += "(*resolver)"; + code += "(reinterpret_cast(&_o->" + field.name + "), "; + code += "static_cast(_e));"; + code += " else "; + code += "_o->" + field.name + " = nullptr;"; + } else { + // Generate code for assigning the value, of the form: + // _o->field = value; + code += "_o->" + field.name + " = "; + code += GenUnpackVal(field.value.type, "_e", false, field) + ";"; + } + break; + } + } + return code; + } + + std::string GenCreateParam(const FieldDef &field) { + std::string value = "_o->"; + if (field.value.type.base_type == BASE_TYPE_UTYPE) { + value += field.name.substr(0, field.name.size() - + strlen(UnionTypeFieldSuffix())); + value += ".type"; + } else { + value += field.name; + } + if (field.attributes.Lookup("cpp_type")) { + auto type = GenTypeBasic(field.value.type, false); + value = "_rehasher ? " + "static_cast<" + type + ">((*_rehasher)(" + value + ")) : 0"; + } + + std::string code; + switch (field.value.type.base_type) { + // String fields are of the form: + // _fbb.CreateString(_o->field) + case BASE_TYPE_STRING: { + code += "_fbb.CreateString(" + value + ")"; + + // For optional fields, check to see if there actually is any data + // in _o->field before attempting to access it. + if (!field.required) { + code = value + ".size() ? " + code + " : 0"; + } + break; + } + // Vector fields come in several flavours, of the forms: + // _fbb.CreateVector(_o->field); + // _fbb.CreateVector((const utype*)_o->field.data(), _o->field.size()); + // _fbb.CreateVectorOfStrings(_o->field) + // _fbb.CreateVectorOfStructs(_o->field) + // _fbb.CreateVector>(_o->field.size() [&](size_t i) { + // return CreateT(_fbb, _o->Get(i), rehasher); + // }); + case BASE_TYPE_VECTOR: { + auto vector_type = field.value.type.VectorType(); + switch (vector_type.base_type) { + case BASE_TYPE_STRING: { + code += "_fbb.CreateVectorOfStrings(" + value + ")"; + break; + } + case BASE_TYPE_STRUCT: { + if (IsStruct(vector_type)) { + code += "_fbb.CreateVectorOfStructs(" + value + ")"; + } else { + code += "_fbb.CreateVector>"; + code += "(" + value + ".size(), [&](size_t i) {"; + code += " return Create" + vector_type.struct_def->name; + code += "(_fbb, " + value + "[i]" + GenPtrGet(field) + ", "; + code += "_rehasher); })"; + } + break; + } + case BASE_TYPE_BOOL: { + code += "_fbb.CreateVector(" + value + ")"; + break; + } + default: { + if (field.value.type.enum_def) { + // For enumerations, we need to get access to the array data for + // the underlying storage type (eg. uint8_t). + const auto basetype = GenTypeBasic( + field.value.type.enum_def->underlying_type, false); + code += "_fbb.CreateVector((const " + basetype + "*)" + value + + ".data(), " + value + ".size())"; + } else { + code += "_fbb.CreateVector(" + value + ")"; + } + break; + } + } + + // For optional fields, check to see if there actually is any data + // in _o->field before attempting to access it. + if (!field.required) { + code = value + ".size() ? " + code + " : 0"; + } + break; + } + case BASE_TYPE_UNION: { + // _o->field.Pack(_fbb); + code += value + ".Pack(_fbb)"; + break; + } + case BASE_TYPE_STRUCT: { + if (IsStruct(field.value.type)) { + if (field.native_inline) { + code += "&" + value; + } else { + code += value + " ? " + value + GenPtrGet(field) + " : 0"; + } + } else { + // _o->field ? CreateT(_fbb, _o->field.get(), _rehasher); + const auto type = field.value.type.struct_def->name; + code += value + " ? Create" + type; + code += "(_fbb, " + value + GenPtrGet(field) + ", _rehasher)"; + code += " : 0"; + } + break; + } + default: { + code += value; + break; + } + } + return code; + } + // Generate code for tables that needs to come after the regular definition. - void GenTablePost(const StructDef &struct_def, std::string *code_ptr) { - std::string &code = *code_ptr; + void GenTablePost(const StructDef &struct_def) { + code_.SetValue("STRUCT_NAME", struct_def.name); + code_.SetValue("NATIVE_NAME", NativeName(struct_def.name)); if (parser_.opts.generate_object_based_api) { - // Generate the UnPack() method. - code += "inline " + TableUnPackSignature(struct_def, false) + " {\n"; - code += " (void)resolver;\n"; - code += " auto _o = new " + NativeName(struct_def.name) + "();\n"; + // Generate the X::UnPack() method. + code_ += "inline " + TableUnPackSignature(struct_def, false) + " {"; + code_ += " (void)resolver;"; + code_ += " auto _o = new {{NATIVE_NAME}}();"; + for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (!field.deprecated) { - auto prefix = " { auto _e = " + field.name + "(); "; - if (!IsScalar(field.value.type.base_type)) prefix += "if (_e) "; - auto deref = "_o->"; - auto dest = deref + field.name; - auto assign = prefix + dest + " = "; - switch (field.value.type.base_type) { - case BASE_TYPE_VECTOR: { - code += prefix; - code += "{ for (flatbuffers::uoffset_t _i = 0;"; - code += " _i < _e->size(); _i++) { "; - code += dest + ".push_back("; - std::string indexing; - if (field.value.type.enum_def) { - indexing += "(" + field.value.type.enum_def->name + ")"; - } - indexing += "_e->Get(_i)"; - if (field.value.type.element == BASE_TYPE_BOOL) - indexing += "!=0"; - code += GenUnpackVal(field.value.type.VectorType(), - indexing, true, field); - code += "); } }"; - break; - } - case BASE_TYPE_UTYPE: { - auto &union_field = **(it + 1); - assert(union_field.value.type.base_type == BASE_TYPE_UNION); - code += prefix + deref + union_field.name + ".type = _e;"; - break; - } - case BASE_TYPE_UNION: { - code += prefix + dest + ".table = "; - code += field.value.type.enum_def->name; - code += "Union::UnPack(_e, "; - code += field.name + UnionTypeFieldSuffix() + "(), resolver);"; - break; - } - default: { - auto cpp_type = field.attributes.Lookup("cpp_type"); - if (cpp_type) { - code += prefix; - code += "if (resolver) (*resolver)(reinterpret_cast(&"; - code += dest; - code += "), static_cast(_e)); else "; - code += dest + " = nullptr"; - } else { - code += assign; - code += GenUnpackVal(field.value.type, "_e", false, field); - } - code += ";"; - break; - } - } - code += " };\n"; + if (field.deprecated) { + continue; } + + // Assign a value from |this| to |_o|. Values from |this| are stored + // in a variable |_e| by calling this->field_type(). The value is then + // assigned to |_o| using the GenUnpackFieldStatement. + const bool is_union = field.value.type.base_type == BASE_TYPE_UTYPE; + const auto statement = + GenUnpackFieldStatement(field, is_union ? *(it + 1) : nullptr); + + code_.SetValue("FIELD_NAME", field.name); + auto prefix = " { auto _e = {{FIELD_NAME}}(); "; + auto check = IsScalar(field.value.type.base_type) ? "" : "if (_e) "; + auto postfix = " };"; + code_ += std::string(prefix) + check + statement + postfix; } - code += " return _o;\n"; - code += "}\n\n"; + code_ += " return _o;"; + code_ += "}"; + code_ += ""; // Generate the X::Pack member function that simply calls the global // CreateX function. - code += "inline " + TablePackSignature(struct_def, false) + " {\n"; - code += " return Create" + struct_def.name + "(_fbb, _o, _rehasher);\n"; - code += "}\n\n"; + code_ += "inline " + TablePackSignature(struct_def, false) + " {"; + code_ += " return Create{{STRUCT_NAME}}(_fbb, _o, _rehasher);"; + code_ += "}"; + code_ += ""; // Generate a CreateX method that works with an unpacked C++ object. - code += TableCreateSignature(struct_def, false) + " {\n"; - code += " (void)rehasher;\n"; - auto before_return_statement = code.size(); - code += " return Create"; - code += struct_def.name + "(_fbb"; - bool any_fields = false; + code_ += "inline " + TableCreateSignature(struct_def, false) + " {"; + code_ += " (void)_rehasher;"; + code_ += " (void)_o;"; + code_ += " return Create{{STRUCT_NAME}}("; + code_ += " _fbb\\"; + for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; - if (!field.deprecated) { - any_fields = true; - auto field_name = field.name; - if (field.value.type.base_type == BASE_TYPE_UTYPE) { - field_name = field_name.substr(0, field_name.size() - - strlen(UnionTypeFieldSuffix())); - field_name += ".type"; - } - auto accessor = "_o->" + field_name; - if (field.attributes.Lookup("cpp_type")) - accessor = "rehasher ? static_cast<" + - GenTypeBasic(field.value.type, false) + - ">((*rehasher)(" + accessor + ")) : 0"; - auto ptrprefix = accessor + " ? "; - auto stlprefix = accessor + ".size() ? "; - auto postfix = " : 0"; - if (field.required && - (field.value.type.base_type == BASE_TYPE_STRING || - field.value.type.base_type == BASE_TYPE_VECTOR)) { - stlprefix = ""; - postfix = ""; - } - code += ",\n"; - code += " "; - switch (field.value.type.base_type) { - case BASE_TYPE_STRING: - code += stlprefix + "_fbb.CreateString(" + accessor + ")"; - code += postfix; - break; - case BASE_TYPE_VECTOR: { - auto vector_type = field.value.type.VectorType(); - code += stlprefix; - switch (vector_type.base_type) { - case BASE_TYPE_STRING: - code += "_fbb.CreateVectorOfStrings(" + accessor + ")"; - break; - case BASE_TYPE_STRUCT: - if (IsStruct(vector_type)) { - code += "_fbb.CreateVectorOfStructs(" + accessor + ")"; - } else { - code += "_fbb.CreateVector>(" + - accessor; - code += ".size(), [&](size_t i) { return Create"; - code += vector_type.struct_def->name + "(_fbb, " + accessor; - code += "[i]" + GenPtrGet(field) + ", rehasher); })"; - } - break; - case BASE_TYPE_BOOL: - code += "_fbb.CreateVector(" + accessor + ")"; - break; - default: { - std::string args = accessor; - if (field.value.type.enum_def) { - const std::string basetype = GenTypeBasic( - field.value.type.enum_def->underlying_type, false); - args = "(const " + basetype + "*)" + accessor + - ".data(), " + accessor + ".size()"; - } - code += "_fbb.CreateVector(" + args + ")"; - break; - } - } - code += postfix; - break; - } - case BASE_TYPE_UNION: - code += accessor + ".Pack(_fbb)"; - break; - case BASE_TYPE_STRUCT: - if (IsStruct(field.value.type)) { - if (field.native_inline) { - code += "&" + accessor; - } else { - code += ptrprefix + accessor + GenPtrGet(field) + postfix; - } - } else { - code += ptrprefix + "Create"; - code += field.value.type.struct_def->name; - code += "(_fbb, " + accessor + GenPtrGet(field) + ", rehasher)"; - code += postfix; - } - break; - default: - code += accessor; - break; - } + if (field.deprecated) { + continue; } + // Call the CreateX function using values from |_o|. + code_ += ",\n " + GenCreateParam(field) + "\\"; } - code += ");\n"; - code += "}\n\n"; - if (!any_fields) code.insert(before_return_statement, " (void)_o;\n"); + code_ += ");"; + code_ += "}"; + code_ += ""; } } @@ -1369,134 +1607,150 @@ class CppGenerator : public BaseGenerator { const FieldDef &field, std::string *code_ptr, int *id, const std::function &f) { if (field.padding) { - for (int i = 0; i < 4; i++) - if (static_cast(field.padding) & (1 << i)) + for (int i = 0; i < 4; i++) { + if (static_cast(field.padding) & (1 << i)) { f((1 << i) * 8, code_ptr, id); + } + } assert(!(field.padding & ~0xF)); } } static void PaddingDefinition(int bits, std::string *code_ptr, int *id) { - *code_ptr += " int" + NumToString(bits) + "_t __padding" + - NumToString((*id)++) + ";\n"; - } - - static void PaddingDeclaration(int bits, std::string *code_ptr, int *id) { - (void)bits; - *code_ptr += " (void)__padding" + NumToString((*id)++) + ";"; + *code_ptr += " int" + NumToString(bits) + "_t padding" + + NumToString((*id)++) + "__;"; } static void PaddingInitializer(int bits, std::string *code_ptr, int *id) { (void)bits; - *code_ptr += ", __padding" + NumToString((*id)++) + "(0)"; + *code_ptr += ",\n padding" + NumToString((*id)++) + "__(0)"; } // Generate an accessor struct with constructor for a flatbuffers struct. - void GenStruct(const StructDef &struct_def, std::string *code_ptr) { - std::string &code = *code_ptr; - + void GenStruct(const StructDef &struct_def) { // Generate an accessor struct, with private variables of the form: // type name_; // Generates manual padding and alignment. // Variables are private because they contain little endian data on all // platforms. - GenComment(struct_def.doc_comment, code_ptr, nullptr); - code += - "MANUALLY_ALIGNED_STRUCT(" + NumToString(struct_def.minalign) + ") "; - code += struct_def.name + " FLATBUFFERS_FINAL_CLASS {\n"; - code += " private:\n"; + GenComment(struct_def.doc_comment); + code_.SetValue("ALIGN", NumToString(struct_def.minalign)); + code_.SetValue("STRUCT_NAME", struct_def.name); + + code_ += "MANUALLY_ALIGNED_STRUCT({{ALIGN}}) " + "{{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS {"; + code_ += " private:"; + int padding_id = 0; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - code += " " + GenTypeGet(field.value.type, " ", "", " ", false); - code += field.name + "_;\n"; - GenPadding(field, &code, &padding_id, PaddingDefinition); + code_.SetValue("FIELD_TYPE", + GenTypeGet(field.value.type, " ", "", " ", false)); + code_.SetValue("FIELD_NAME", field.name); + code_ += " {{FIELD_TYPE}}{{FIELD_NAME}}_;"; + + if (field.padding) { + std::string padding; + GenPadding(field, &padding, &padding_id, PaddingDefinition); + code_ += padding; + } } // Generate GetFullyQualifiedName - code += "\n"; - code += " public:\n"; - GenFullyQualifiedNameGetter(struct_def.name, &code); + code_ += ""; + code_ += " public:"; + GenFullyQualifiedNameGetter(struct_def.name); // Generate a default constructor. - code += " " + struct_def.name + "() { memset(this, 0, sizeof("; - code += struct_def.name + ")); }\n"; + code_ += " {{STRUCT_NAME}}() {"; + code_ += " memset(this, 0, sizeof({{STRUCT_NAME}}));"; + code_ += " }"; // Generate a copy constructor. - code += " " + struct_def.name + "(const " + struct_def.name; - code += " &_o) { memcpy(this, &_o, sizeof("; - code += struct_def.name + ")); }\n"; + code_ += " {{STRUCT_NAME}}(const {{STRUCT_NAME}} &_o) {"; + code_ += " memcpy(this, &_o, sizeof({{STRUCT_NAME}}));"; + code_ += " }"; // Generate a constructor that takes all fields as arguments. - code += " " + struct_def.name + "("; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - const auto &field = **it; - if (it != struct_def.fields.vec.begin()) code += ", "; - code += GenTypeGet(field.value.type, " ", "const ", " &", true); - code += "_" + field.name; - } - code += ")\n"; - code += " : "; + std::string arg_list; + std::string init_list; padding_id = 0; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (it != struct_def.fields.vec.begin()) code += ", "; - code += field.name + "_("; - if (IsScalar(field.value.type.base_type)) { - code += "flatbuffers::EndianScalar("; - code += GenUnderlyingCast(field, false, "_" + field.name); - code += "))"; - } else { - code += "_" + field.name + ")"; + const auto member_name = field.name + "_"; + const auto arg_name = "_" + field.name; + const auto arg_type = + GenTypeGet(field.value.type, " ", "const ", " &", true); + + if (it != struct_def.fields.vec.begin()) { + arg_list += ", "; + init_list += ",\n "; + } + arg_list += arg_type; + arg_list += arg_name; + init_list += member_name; + if (IsScalar(field.value.type.base_type)) { + auto type = GenUnderlyingCast(field, false, arg_name); + init_list += "(flatbuffers::EndianScalar(" + type + "))"; + } else { + init_list += "(" + arg_name + ")"; + } + if (field.padding) { + GenPadding(field, &init_list, &padding_id, PaddingInitializer); } - GenPadding(field, &code, &padding_id, PaddingInitializer); } - code += " {"; - padding_id = 0; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto field = *it; - GenPadding(*field, &code, &padding_id, PaddingDeclaration); - } - code += " }\n\n"; + code_.SetValue("ARG_LIST", arg_list); + code_.SetValue("INIT_LIST", init_list); + code_ += " {{STRUCT_NAME}}({{ARG_LIST}})"; + code_ += " : {{INIT_LIST}} {"; + code_ += " }"; // Generate accessor methods of the form: // type name() const { return flatbuffers::EndianScalar(name_); } for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - GenComment(field.doc_comment, code_ptr, nullptr, " "); + + auto field_type = GenTypeGet(field.value.type, " ", "const ", " &", true); auto is_scalar = IsScalar(field.value.type.base_type); - code += " " + GenTypeGet(field.value.type, " ", "const ", " &", true); - code += field.name + "() const { return "; - code += GenUnderlyingCast( - field, true, is_scalar - ? "flatbuffers::EndianScalar(" + field.name + "_)" - : field.name + "_"); - code += "; }\n"; + auto member = field.name + "_"; + auto value = is_scalar ? "flatbuffers::EndianScalar(" + member + ")" + : member; + + code_.SetValue("FIELD_NAME", field.name); + code_.SetValue("FIELD_TYPE", field_type); + code_.SetValue("FIELD_VALUE", GenUnderlyingCast(field, true, value)); + + GenComment(field.doc_comment, " "); + code_ += " {{FIELD_TYPE}}{{FIELD_NAME}}() const {"; + code_ += " return {{FIELD_VALUE}};"; + code_ += " }"; + if (parser_.opts.mutable_buffer) { if (is_scalar) { - code += " void mutate_" + field.name + "("; - code += GenTypeBasic(field.value.type, true); - code += " _" + field.name + ") { flatbuffers::WriteScalar(&"; - code += field.name + "_, "; - code += GenUnderlyingCast(field, false, "_" + field.name); - code += "); }\n"; + code_.SetValue("ARG", GenTypeBasic(field.value.type, true)); + code_.SetValue("FIELD_VALUE", + GenUnderlyingCast(field, false, "_" + field.name)); + + code_ += " void mutate_{{FIELD_NAME}}({{ARG}} _{{FIELD_NAME}}) {"; + code_ += " flatbuffers::WriteScalar(&{{FIELD_NAME}}_, " + "{{FIELD_VALUE}});"; + code_ += " }"; } else { - code += " "; - code += GenTypeGet(field.value.type, "", "", " &", true); - code += "mutable_" + field.name + "() { return " + field.name; - code += "_; }\n"; + code_ += " {{FIELD_TYPE}}mutable_{{FIELD_NAME}}() {"; + code_ += " return {{FIELD_NAME}}_;"; + code_ += " }"; } } } - code += "};\n"; - code += "STRUCT_END(" + struct_def.name + ", "; - code += NumToString(struct_def.bytesize) + ");\n\n"; + code_ += "};"; + + code_.SetValue("STRUCT_BYTE_SIZE", NumToString(struct_def.bytesize)); + code_ += "STRUCT_END({{STRUCT_NAME}}, {{STRUCT_BYTE_SIZE}});"; + code_ += ""; } // Set up the correct namespace. Only open a namespace if the existing one is @@ -1504,31 +1758,43 @@ class CppGenerator : public BaseGenerator { // // The file must start and end with an empty (or null) namespace so that // namespaces are properly opened and closed. - void SetNameSpace(const Namespace *ns, std::string *code_ptr) { - if (cur_name_space_ == ns) return; - // compute the size of the longest common namespace prefix. - // if cur_name_space is A::B::C::D and ns is A::B::E::F::G, + void SetNameSpace(const Namespace *ns) { + if (cur_name_space_ == ns) { + return; + } + + // Compute the size of the longest common namespace prefix. + // If cur_name_space is A::B::C::D and ns is A::B::E::F::G, // the common prefix is A::B:: and we have old_size = 4, new_size = 5 // and common_prefix_size = 2 - auto old_size = - cur_name_space_ == nullptr ? 0 : cur_name_space_->components.size(); - auto new_size = ns == nullptr ? 0 : ns->components.size(); - std::vector::size_type common_prefix_size = 0; + size_t old_size = cur_name_space_ ? cur_name_space_->components.size() : 0; + size_t new_size = ns ? ns->components.size() : 0; + + size_t common_prefix_size = 0; while (common_prefix_size < old_size && common_prefix_size < new_size && ns->components[common_prefix_size] == - cur_name_space_->components[common_prefix_size]) + cur_name_space_->components[common_prefix_size]) { common_prefix_size++; - // close cur_name_space in reverse order to reach the common prefix - // in the previous example, D then C are closed - for (auto j = old_size; j > common_prefix_size; --j) - *code_ptr += - "} // namespace " + cur_name_space_->components[j - 1] + "\n"; - if (old_size != common_prefix_size) *code_ptr += "\n"; + } + + // Close cur_name_space in reverse order to reach the common prefix. + // In the previous example, D then C are closed. + for (size_t j = old_size; j > common_prefix_size; --j) { + code_ += "} // namespace " + cur_name_space_->components[j - 1]; + } + if (old_size != common_prefix_size) { + code_ += ""; + } + // open namespace parts to reach the ns namespace // in the previous example, E, then F, then G are opened - for (auto j = common_prefix_size; j != new_size; ++j) - *code_ptr += "namespace " + ns->components[j] + " {\n"; - if (new_size != common_prefix_size) *code_ptr += "\n"; + for (auto j = common_prefix_size; j != new_size; ++j) { + code_ += "namespace " + ns->components[j] + " {"; + } + if (new_size != common_prefix_size) { + code_ += ""; + } + cur_name_space_ = ns; } }; @@ -1543,7 +1809,7 @@ bool GenerateCPP(const Parser &parser, const std::string &path, std::string CPPMakeRule(const Parser &parser, const std::string &path, const std::string &file_name) { - const std::string filebase = + const auto filebase = flatbuffers::StripPath(flatbuffers::StripExtension(file_name)); const auto included_files = parser.GetIncludedFilesRecursive(file_name); std::string make_rule = GeneratedFileName(path, filebase) + ": "; diff --git a/src/idl_gen_fbs.cpp b/src/idl_gen_fbs.cpp index 237230e8e..7752369ca 100644 --- a/src/idl_gen_fbs.cpp +++ b/src/idl_gen_fbs.cpp @@ -19,6 +19,7 @@ #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" +#include "flatbuffers/code_generators.h" namespace flatbuffers { diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp index 44d89b4c3..8c3220785 100644 --- a/src/idl_gen_general.cpp +++ b/src/idl_gen_general.cpp @@ -39,37 +39,6 @@ std::string MakeCamel(const std::string &in, bool first) { return s; } -struct CommentConfig { - const char *first_line; - const char *content_line_prefix; - const char *last_line; -}; - -// Generate a documentation comment, if available. -void GenComment(const std::vector &dc, std::string *code_ptr, - const CommentConfig *config, const char *prefix) { - if (dc.begin() == dc.end()) { - // Don't output empty comment blocks with 0 lines of comment content. - return; - } - - std::string &code = *code_ptr; - if (config != nullptr && config->first_line != nullptr) { - code += std::string(prefix) + std::string(config->first_line) + "\n"; - } - std::string line_prefix = std::string(prefix) + - ((config != nullptr && config->content_line_prefix != nullptr) ? - config->content_line_prefix : "///"); - for (auto it = dc.begin(); - it != dc.end(); - ++it) { - code += line_prefix + *it + "\n"; - } - if (config != nullptr && config->last_line != nullptr) { - code += std::string(prefix) + std::string(config->last_line) + "\n"; - } -} - // These arrays need to correspond to the IDLOptions::k enum. struct LanguageParameters { @@ -495,7 +464,7 @@ std::string GenDefaultValue(const Value &value, bool enableLangOverrides) { switch (value.type.base_type) { case BASE_TYPE_FLOAT: return value.constant + "f"; case BASE_TYPE_BOOL: return value.constant == "0" ? "false" : "true"; - case BASE_TYPE_ULONG: + case BASE_TYPE_ULONG: { if (lang_.language != IDLOptions::kJava) return value.constant; diff --git a/tests/monster_test_generated.h b/tests/monster_test_generated.h index b5ae9f2f3..82df66e9e 100644 --- a/tests/monster_test_generated.h +++ b/tests/monster_test_generated.h @@ -1,5 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify + #ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ #define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ @@ -37,11 +38,24 @@ enum Color { }; inline const char **EnumNamesColor() { - static const char *names[] = { "Red", "Green", "", "", "", "", "", "Blue", nullptr }; + static const char *names[] = { + "Red", + "Green", + "", + "", + "", + "", + "", + "Blue", + nullptr + }; return names; } -inline const char *EnumNameColor(Color e) { return EnumNamesColor()[static_cast(e) - static_cast(Color_Red)]; } +inline const char *EnumNameColor(Color e) { + const size_t index = static_cast(e) - static_cast(Color_Red); + return EnumNamesColor()[index]; +} enum Any { Any_NONE = 0, @@ -53,11 +67,20 @@ enum Any { }; inline const char **EnumNamesAny() { - static const char *names[] = { "NONE", "Monster", "TestSimpleTableWithEnum", "MyGame_Example2_Monster", nullptr }; + static const char *names[] = { + "NONE", + "Monster", + "TestSimpleTableWithEnum", + "MyGame_Example2_Monster", + nullptr + }; return names; } -inline const char *EnumNameAny(Any e) { return EnumNamesAny()[static_cast(e)]; } +inline const char *EnumNameAny(Any e) { + const size_t index = static_cast(e); + return EnumNamesAny()[index]; +} template struct AnyTraits { static const Any enum_value = Any_NONE; @@ -77,12 +100,13 @@ template<> struct AnyTraits { struct AnyUnion { Any type; - flatbuffers::NativeTable *table; + AnyUnion() : type(Any_NONE), table(nullptr) {} AnyUnion(const AnyUnion &); AnyUnion &operator=(const AnyUnion &); ~AnyUnion() { Reset(); } + void Reset(); template @@ -94,32 +118,55 @@ struct AnyUnion { } } - static flatbuffers::NativeTable *UnPack(const void *union_obj, Any type, const flatbuffers::resolver_function_t *resolver); - flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *rehasher = nullptr) const; + static flatbuffers::NativeTable *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; - MonsterT *AsMonster() { return type == Any_Monster ? reinterpret_cast(table) : nullptr; } - TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() { return type == Any_TestSimpleTableWithEnum ? reinterpret_cast(table) : nullptr; } - MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() { return type == Any_MyGame_Example2_Monster ? reinterpret_cast(table) : nullptr; } + MonsterT *AsMonster() { + return type == Any_Monster ? + reinterpret_cast(table) : nullptr; + } + TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() { + return type == Any_TestSimpleTableWithEnum ? + reinterpret_cast(table) : nullptr; + } + MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() { + return type == Any_MyGame_Example2_Monster ? + reinterpret_cast(table) : nullptr; + } }; -inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *union_obj, Any type); +bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type); MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS { private: int16_t a_; int8_t b_; - int8_t __padding0; + int8_t padding0__; public: - Test() { memset(this, 0, sizeof(Test)); } - Test(const Test &_o) { memcpy(this, &_o, sizeof(Test)); } + Test() { + memset(this, 0, sizeof(Test)); + } + Test(const Test &_o) { + memcpy(this, &_o, sizeof(Test)); + } Test(int16_t _a, int8_t _b) - : a_(flatbuffers::EndianScalar(_a)), b_(flatbuffers::EndianScalar(_b)), __padding0(0) { (void)__padding0; } - - int16_t a() const { return flatbuffers::EndianScalar(a_); } - void mutate_a(int16_t _a) { flatbuffers::WriteScalar(&a_, _a); } - int8_t b() const { return flatbuffers::EndianScalar(b_); } - void mutate_b(int8_t _b) { flatbuffers::WriteScalar(&b_, _b); } + : a_(flatbuffers::EndianScalar(_a)), + b_(flatbuffers::EndianScalar(_b)), + padding0__(0) { + } + int16_t a() const { + return flatbuffers::EndianScalar(a_); + } + void mutate_a(int16_t _a) { + flatbuffers::WriteScalar(&a_, _a); + } + int8_t b() const { + return flatbuffers::EndianScalar(b_); + } + void mutate_b(int8_t _b) { + flatbuffers::WriteScalar(&b_, _b); + } }; STRUCT_END(Test, 4); @@ -128,31 +175,67 @@ MANUALLY_ALIGNED_STRUCT(16) Vec3 FLATBUFFERS_FINAL_CLASS { float x_; float y_; float z_; - int32_t __padding0; + int32_t padding0__; double test1_; int8_t test2_; - int8_t __padding1; + int8_t padding1__; Test test3_; - int16_t __padding2; + int16_t padding2__; public: - Vec3() { memset(this, 0, sizeof(Vec3)); } - Vec3(const Vec3 &_o) { memcpy(this, &_o, sizeof(Vec3)); } + Vec3() { + memset(this, 0, sizeof(Vec3)); + } + Vec3(const Vec3 &_o) { + memcpy(this, &_o, sizeof(Vec3)); + } Vec3(float _x, float _y, float _z, double _test1, Color _test2, const Test &_test3) - : x_(flatbuffers::EndianScalar(_x)), y_(flatbuffers::EndianScalar(_y)), z_(flatbuffers::EndianScalar(_z)), __padding0(0), test1_(flatbuffers::EndianScalar(_test1)), test2_(flatbuffers::EndianScalar(static_cast(_test2))), __padding1(0), test3_(_test3), __padding2(0) { (void)__padding0; (void)__padding1; (void)__padding2; } - - float x() const { return flatbuffers::EndianScalar(x_); } - void mutate_x(float _x) { flatbuffers::WriteScalar(&x_, _x); } - float y() const { return flatbuffers::EndianScalar(y_); } - void mutate_y(float _y) { flatbuffers::WriteScalar(&y_, _y); } - float z() const { return flatbuffers::EndianScalar(z_); } - void mutate_z(float _z) { flatbuffers::WriteScalar(&z_, _z); } - double test1() const { return flatbuffers::EndianScalar(test1_); } - void mutate_test1(double _test1) { flatbuffers::WriteScalar(&test1_, _test1); } - Color test2() const { return static_cast(flatbuffers::EndianScalar(test2_)); } - void mutate_test2(Color _test2) { flatbuffers::WriteScalar(&test2_, static_cast(_test2)); } - const Test &test3() const { return test3_; } - Test &mutable_test3() { return test3_; } + : x_(flatbuffers::EndianScalar(_x)), + y_(flatbuffers::EndianScalar(_y)), + z_(flatbuffers::EndianScalar(_z)), + padding0__(0), + test1_(flatbuffers::EndianScalar(_test1)), + test2_(flatbuffers::EndianScalar(static_cast(_test2))), + padding1__(0), + test3_(_test3), + padding2__(0) { + } + float x() const { + return flatbuffers::EndianScalar(x_); + } + void mutate_x(float _x) { + flatbuffers::WriteScalar(&x_, _x); + } + float y() const { + return flatbuffers::EndianScalar(y_); + } + void mutate_y(float _y) { + flatbuffers::WriteScalar(&y_, _y); + } + float z() const { + return flatbuffers::EndianScalar(z_); + } + void mutate_z(float _z) { + flatbuffers::WriteScalar(&z_, _z); + } + double test1() const { + return flatbuffers::EndianScalar(test1_); + } + void mutate_test1(double _test1) { + flatbuffers::WriteScalar(&test1_, _test1); + } + Color test2() const { + return static_cast(flatbuffers::EndianScalar(test2_)); + } + void mutate_test2(Color _test2) { + flatbuffers::WriteScalar(&test2_, static_cast(_test2)); + } + const Test &test3() const { + return test3_; + } + const Test &mutable_test3() { + return test3_; + } }; STRUCT_END(Vec3, 32); @@ -162,7 +245,8 @@ namespace Example2 { struct MonsterT : public flatbuffers::NativeTable { typedef Monster TableType; - MonsterT() {} + MonsterT() { + } }; struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -178,20 +262,25 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct MonsterBuilder { flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } MonsterBuilder &operator=(const MonsterBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 0)); + const auto end = fbb_.EndTable(start_, 0); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb) { +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb) { MonsterBuilder builder_(_fbb); return builder_.Finish(); } -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *rehasher = nullptr); +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); } // namespace Example2 @@ -201,7 +290,8 @@ struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable { typedef TestSimpleTableWithEnum TableType; Color color; TestSimpleTableWithEnumT() - : color(Color_Green) {} + : color(Color_Green) { + } }; struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -209,8 +299,12 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta enum { VT_COLOR = 4 }; - Color color() const { return static_cast(GetField(VT_COLOR, 2)); } - bool mutate_color(Color _color) { return SetField(VT_COLOR, static_cast(_color)); } + Color color() const { + return static_cast(GetField(VT_COLOR, 2)); + } + bool mutate_color(Color _color) { + return SetField(VT_COLOR, static_cast(_color)); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_COLOR) && @@ -226,22 +320,27 @@ struct TestSimpleTableWithEnumBuilder { void add_color(Color color) { fbb_.AddElement(TestSimpleTableWithEnum::VT_COLOR, static_cast(color), 2); } - TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } TestSimpleTableWithEnumBuilder &operator=(const TestSimpleTableWithEnumBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 1)); + const auto end = fbb_.EndTable(start_, 1); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateTestSimpleTableWithEnum( + flatbuffers::FlatBufferBuilder &_fbb, Color color = Color_Green) { TestSimpleTableWithEnumBuilder builder_(_fbb); builder_.add_color(color); return builder_.Finish(); } -inline flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *rehasher = nullptr); +flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); struct StatT : public flatbuffers::NativeTable { typedef Stat TableType; @@ -249,8 +348,9 @@ struct StatT : public flatbuffers::NativeTable { int64_t val; uint16_t count; StatT() - : val(0), - count(0) {} + : val(0), + count(0) { + } }; struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -260,12 +360,24 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_VAL = 6, VT_COUNT = 8 }; - const flatbuffers::String *id() const { return GetPointer(VT_ID); } - flatbuffers::String *mutable_id() { return GetPointer(VT_ID); } - int64_t val() const { return GetField(VT_VAL, 0); } - bool mutate_val(int64_t _val) { return SetField(VT_VAL, _val); } - uint16_t count() const { return GetField(VT_COUNT, 0); } - bool mutate_count(uint16_t _count) { return SetField(VT_COUNT, _count); } + const flatbuffers::String *id() const { + return GetPointer(VT_ID); + } + flatbuffers::String *mutable_id() { + return GetPointer(VT_ID); + } + int64_t val() const { + return GetField(VT_VAL, 0); + } + bool mutate_val(int64_t _val) { + return SetField(VT_VAL, _val); + } + uint16_t count() const { + return GetField(VT_COUNT, 0); + } + bool mutate_count(uint16_t _count) { + return SetField(VT_COUNT, _count); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ID) && @@ -290,15 +402,20 @@ struct StatBuilder { void add_count(uint16_t count) { fbb_.AddElement(Stat::VT_COUNT, count, 0); } - StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } StatBuilder &operator=(const StatBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 3)); + const auto end = fbb_.EndTable(start_, 3); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateStat( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset id = 0, int64_t val = 0, uint16_t count = 0) { @@ -309,14 +426,19 @@ inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb return builder_.Finish(); } -inline flatbuffers::Offset CreateStatDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateStatDirect( + flatbuffers::FlatBufferBuilder &_fbb, const char *id = nullptr, int64_t val = 0, uint16_t count = 0) { - return CreateStat(_fbb, id ? _fbb.CreateString(id) : 0, val, count); + return CreateStat( + _fbb, + id ? _fbb.CreateString(id) : 0, + val, + count); } -inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *rehasher = nullptr); +flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); struct MonsterT : public flatbuffers::NativeTable { typedef Monster TableType; @@ -348,21 +470,22 @@ struct MonsterT : public flatbuffers::NativeTable { float testf3; std::vector testarrayofstring2; MonsterT() - : mana(150), - hp(100), - color(Color_Blue), - testbool(false), - testhashs32_fnv1(0), - testhashu32_fnv1(0), - testhashs64_fnv1(0), - testhashu64_fnv1(0), - testhashs32_fnv1a(0), - testhashu32_fnv1a(0), - testhashs64_fnv1a(0), - testhashu64_fnv1a(0), - testf(3.14159f), - testf2(3.0f), - testf3(0.0f) {} + : mana(150), + hp(100), + color(Color_Blue), + testbool(false), + testhashs32_fnv1(0), + testhashu32_fnv1(0), + testhashs64_fnv1(0), + testhashu64_fnv1(0), + testhashs32_fnv1a(0), + testhashu32_fnv1a(0), + testhashs64_fnv1a(0), + testhashu64_fnv1a(0), + testf(3.14159f), + testf2(3.0f), + testf3(0.0f) { + } }; /// an example documentation comment: monster object @@ -398,67 +521,186 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_TESTF3 = 58, VT_TESTARRAYOFSTRING2 = 60 }; - const Vec3 *pos() const { return GetStruct(VT_POS); } - Vec3 *mutable_pos() { return GetStruct(VT_POS); } - int16_t mana() const { return GetField(VT_MANA, 150); } - bool mutate_mana(int16_t _mana) { return SetField(VT_MANA, _mana); } - int16_t hp() const { return GetField(VT_HP, 100); } - bool mutate_hp(int16_t _hp) { return SetField(VT_HP, _hp); } - const flatbuffers::String *name() const { return GetPointer(VT_NAME); } - flatbuffers::String *mutable_name() { return GetPointer(VT_NAME); } - bool KeyCompareLessThan(const Monster *o) const { return *name() < *o->name(); } - int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); } - const flatbuffers::Vector *inventory() const { return GetPointer *>(VT_INVENTORY); } - flatbuffers::Vector *mutable_inventory() { return GetPointer *>(VT_INVENTORY); } - Color color() const { return static_cast(GetField(VT_COLOR, 8)); } - bool mutate_color(Color _color) { return SetField(VT_COLOR, static_cast(_color)); } - Any test_type() const { return static_cast(GetField(VT_TEST_TYPE, 0)); } - bool mutate_test_type(Any _test_type) { return SetField(VT_TEST_TYPE, static_cast(_test_type)); } - const void *test() const { return GetPointer(VT_TEST); } - void *mutable_test() { return GetPointer(VT_TEST); } - const flatbuffers::Vector *test4() const { return GetPointer *>(VT_TEST4); } - flatbuffers::Vector *mutable_test4() { return GetPointer *>(VT_TEST4); } - const flatbuffers::Vector> *testarrayofstring() const { return GetPointer> *>(VT_TESTARRAYOFSTRING); } - flatbuffers::Vector> *mutable_testarrayofstring() { return GetPointer> *>(VT_TESTARRAYOFSTRING); } + const Vec3 *pos() const { + return GetStruct(VT_POS); + } + Vec3 *mutable_pos() { + return GetStruct(VT_POS); + } + int16_t mana() const { + return GetField(VT_MANA, 150); + } + bool mutate_mana(int16_t _mana) { + return SetField(VT_MANA, _mana); + } + int16_t hp() const { + return GetField(VT_HP, 100); + } + bool mutate_hp(int16_t _hp) { + return SetField(VT_HP, _hp); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + flatbuffers::String *mutable_name() { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Monster *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *val) const { + return strcmp(name()->c_str(), val); + } + const flatbuffers::Vector *inventory() const { + return GetPointer *>(VT_INVENTORY); + } + flatbuffers::Vector *mutable_inventory() { + return GetPointer *>(VT_INVENTORY); + } + Color color() const { + return static_cast(GetField(VT_COLOR, 8)); + } + bool mutate_color(Color _color) { + return SetField(VT_COLOR, static_cast(_color)); + } + Any test_type() const { + return static_cast(GetField(VT_TEST_TYPE, 0)); + } + bool mutate_test_type(Any _test_type) { + return SetField(VT_TEST_TYPE, static_cast(_test_type)); + } + const void *test() const { + return GetPointer(VT_TEST); + } + void *mutable_test() { + return GetPointer(VT_TEST); + } + const flatbuffers::Vector *test4() const { + return GetPointer *>(VT_TEST4); + } + flatbuffers::Vector *mutable_test4() { + return GetPointer *>(VT_TEST4); + } + const flatbuffers::Vector> *testarrayofstring() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } + flatbuffers::Vector> *mutable_testarrayofstring() { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } /// an example documentation comment: this will end up in the generated code /// multiline too - const flatbuffers::Vector> *testarrayoftables() const { return GetPointer> *>(VT_TESTARRAYOFTABLES); } - flatbuffers::Vector> *mutable_testarrayoftables() { return GetPointer> *>(VT_TESTARRAYOFTABLES); } - const Monster *enemy() const { return GetPointer(VT_ENEMY); } - Monster *mutable_enemy() { return GetPointer(VT_ENEMY); } - const flatbuffers::Vector *testnestedflatbuffer() const { return GetPointer *>(VT_TESTNESTEDFLATBUFFER); } - flatbuffers::Vector *mutable_testnestedflatbuffer() { return GetPointer *>(VT_TESTNESTEDFLATBUFFER); } - const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const { return flatbuffers::GetRoot(testnestedflatbuffer()->Data()); } - const Stat *testempty() const { return GetPointer(VT_TESTEMPTY); } - Stat *mutable_testempty() { return GetPointer(VT_TESTEMPTY); } - bool testbool() const { return GetField(VT_TESTBOOL, 0) != 0; } - bool mutate_testbool(bool _testbool) { return SetField(VT_TESTBOOL, static_cast(_testbool)); } - int32_t testhashs32_fnv1() const { return GetField(VT_TESTHASHS32_FNV1, 0); } - bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1) { return SetField(VT_TESTHASHS32_FNV1, _testhashs32_fnv1); } - uint32_t testhashu32_fnv1() const { return GetField(VT_TESTHASHU32_FNV1, 0); } - bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1) { return SetField(VT_TESTHASHU32_FNV1, _testhashu32_fnv1); } - int64_t testhashs64_fnv1() const { return GetField(VT_TESTHASHS64_FNV1, 0); } - bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1) { return SetField(VT_TESTHASHS64_FNV1, _testhashs64_fnv1); } - uint64_t testhashu64_fnv1() const { return GetField(VT_TESTHASHU64_FNV1, 0); } - bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1) { return SetField(VT_TESTHASHU64_FNV1, _testhashu64_fnv1); } - int32_t testhashs32_fnv1a() const { return GetField(VT_TESTHASHS32_FNV1A, 0); } - bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a) { return SetField(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a); } - uint32_t testhashu32_fnv1a() const { return GetField(VT_TESTHASHU32_FNV1A, 0); } - bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a) { return SetField(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a); } - int64_t testhashs64_fnv1a() const { return GetField(VT_TESTHASHS64_FNV1A, 0); } - bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a) { return SetField(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a); } - uint64_t testhashu64_fnv1a() const { return GetField(VT_TESTHASHU64_FNV1A, 0); } - bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a) { return SetField(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a); } - const flatbuffers::Vector *testarrayofbools() const { return GetPointer *>(VT_TESTARRAYOFBOOLS); } - flatbuffers::Vector *mutable_testarrayofbools() { return GetPointer *>(VT_TESTARRAYOFBOOLS); } - float testf() const { return GetField(VT_TESTF, 3.14159f); } - bool mutate_testf(float _testf) { return SetField(VT_TESTF, _testf); } - float testf2() const { return GetField(VT_TESTF2, 3.0f); } - bool mutate_testf2(float _testf2) { return SetField(VT_TESTF2, _testf2); } - float testf3() const { return GetField(VT_TESTF3, 0.0f); } - bool mutate_testf3(float _testf3) { return SetField(VT_TESTF3, _testf3); } - const flatbuffers::Vector> *testarrayofstring2() const { return GetPointer> *>(VT_TESTARRAYOFSTRING2); } - flatbuffers::Vector> *mutable_testarrayofstring2() { return GetPointer> *>(VT_TESTARRAYOFSTRING2); } + const flatbuffers::Vector> *testarrayoftables() const { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + flatbuffers::Vector> *mutable_testarrayoftables() { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + const Monster *enemy() const { + return GetPointer(VT_ENEMY); + } + Monster *mutable_enemy() { + return GetPointer(VT_ENEMY); + } + const flatbuffers::Vector *testnestedflatbuffer() const { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + flatbuffers::Vector *mutable_testnestedflatbuffer() { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const { + const uint8_t* data = testnestedflatbuffer()->Data(); + return flatbuffers::GetRoot(data); + } + const Stat *testempty() const { + return GetPointer(VT_TESTEMPTY); + } + Stat *mutable_testempty() { + return GetPointer(VT_TESTEMPTY); + } + bool testbool() const { + return GetField(VT_TESTBOOL, 0) != 0; + } + bool mutate_testbool(bool _testbool) { + return SetField(VT_TESTBOOL, static_cast(_testbool)); + } + int32_t testhashs32_fnv1() const { + return GetField(VT_TESTHASHS32_FNV1, 0); + } + bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1) { + return SetField(VT_TESTHASHS32_FNV1, _testhashs32_fnv1); + } + uint32_t testhashu32_fnv1() const { + return GetField(VT_TESTHASHU32_FNV1, 0); + } + bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1) { + return SetField(VT_TESTHASHU32_FNV1, _testhashu32_fnv1); + } + int64_t testhashs64_fnv1() const { + return GetField(VT_TESTHASHS64_FNV1, 0); + } + bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1) { + return SetField(VT_TESTHASHS64_FNV1, _testhashs64_fnv1); + } + uint64_t testhashu64_fnv1() const { + return GetField(VT_TESTHASHU64_FNV1, 0); + } + bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1) { + return SetField(VT_TESTHASHU64_FNV1, _testhashu64_fnv1); + } + int32_t testhashs32_fnv1a() const { + return GetField(VT_TESTHASHS32_FNV1A, 0); + } + bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a) { + return SetField(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a); + } + uint32_t testhashu32_fnv1a() const { + return GetField(VT_TESTHASHU32_FNV1A, 0); + } + bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a) { + return SetField(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a); + } + int64_t testhashs64_fnv1a() const { + return GetField(VT_TESTHASHS64_FNV1A, 0); + } + bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a) { + return SetField(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a); + } + uint64_t testhashu64_fnv1a() const { + return GetField(VT_TESTHASHU64_FNV1A, 0); + } + bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a) { + return SetField(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a); + } + const flatbuffers::Vector *testarrayofbools() const { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + flatbuffers::Vector *mutable_testarrayofbools() { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + float testf() const { + return GetField(VT_TESTF, 3.14159f); + } + bool mutate_testf(float _testf) { + return SetField(VT_TESTF, _testf); + } + float testf2() const { + return GetField(VT_TESTF2, 3.0f); + } + bool mutate_testf2(float _testf2) { + return SetField(VT_TESTF2, _testf2); + } + float testf3() const { + return GetField(VT_TESTF3, 0.0f); + } + bool mutate_testf3(float _testf3) { + return SetField(VT_TESTF3, _testf3); + } + const flatbuffers::Vector> *testarrayofstring2() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } + flatbuffers::Vector> *mutable_testarrayofstring2() { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_POS) && @@ -596,16 +838,21 @@ struct MonsterBuilder { void add_testarrayofstring2(flatbuffers::Offset>> testarrayofstring2) { fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); } - MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } MonsterBuilder &operator=(const MonsterBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 29)); - fbb_.Required(o, Monster::VT_NAME); // name + const auto end = fbb_.EndTable(start_, 29); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Monster::VT_NAME); return o; } }; -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb, const Vec3 *pos = 0, int16_t mana = 150, int16_t hp = 100, @@ -666,7 +913,8 @@ inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder return builder_.Finish(); } -inline flatbuffers::Offset CreateMonsterDirect(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateMonsterDirect( + flatbuffers::FlatBufferBuilder &_fbb, const Vec3 *pos = 0, int16_t mana = 150, int16_t hp = 100, @@ -695,10 +943,39 @@ inline flatbuffers::Offset CreateMonsterDirect(flatbuffers::FlatBufferB float testf2 = 3.0f, float testf3 = 0.0f, const std::vector> *testarrayofstring2 = nullptr) { - return CreateMonster(_fbb, pos, mana, hp, name ? _fbb.CreateString(name) : 0, inventory ? _fbb.CreateVector(*inventory) : 0, color, test_type, test, test4 ? _fbb.CreateVector(*test4) : 0, testarrayofstring ? _fbb.CreateVector>(*testarrayofstring) : 0, testarrayoftables ? _fbb.CreateVector>(*testarrayoftables) : 0, enemy, testnestedflatbuffer ? _fbb.CreateVector(*testnestedflatbuffer) : 0, testempty, testbool, testhashs32_fnv1, testhashu32_fnv1, testhashs64_fnv1, testhashu64_fnv1, testhashs32_fnv1a, testhashu32_fnv1a, testhashs64_fnv1a, testhashu64_fnv1a, testarrayofbools ? _fbb.CreateVector(*testarrayofbools) : 0, testf, testf2, testf3, testarrayofstring2 ? _fbb.CreateVector>(*testarrayofstring2) : 0); + return CreateMonster( + _fbb, + pos, + mana, + hp, + name ? _fbb.CreateString(name) : 0, + inventory ? _fbb.CreateVector(*inventory) : 0, + color, + test_type, + test, + test4 ? _fbb.CreateVector(*test4) : 0, + testarrayofstring ? _fbb.CreateVector>(*testarrayofstring) : 0, + testarrayoftables ? _fbb.CreateVector>(*testarrayoftables) : 0, + enemy, + testnestedflatbuffer ? _fbb.CreateVector(*testnestedflatbuffer) : 0, + testempty, + testbool, + testhashs32_fnv1, + testhashu32_fnv1, + testhashs64_fnv1, + testhashu64_fnv1, + testhashs32_fnv1a, + testhashu32_fnv1a, + testhashs64_fnv1a, + testhashu64_fnv1a, + testarrayofbools ? _fbb.CreateVector(*testarrayofbools) : 0, + testf, + testf2, + testf3, + testarrayofstring2 ? _fbb.CreateVector>(*testarrayofstring2) : 0); } -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *rehasher = nullptr); +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); } // namespace Example @@ -714,10 +991,11 @@ inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder return CreateMonster(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *rehasher) { - (void)rehasher; +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; (void)_o; - return CreateMonster(_fbb); + return CreateMonster( + _fbb); } } // namespace Example2 @@ -735,10 +1013,12 @@ inline flatbuffers::Offset TestSimpleTableWithEnum::Pac return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *rehasher) { - (void)rehasher; - return CreateTestSimpleTableWithEnum(_fbb, - _o->color); +inline flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + return CreateTestSimpleTableWithEnum( + _fbb, + _o->color); } inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *resolver) const { @@ -754,12 +1034,14 @@ inline flatbuffers::Offset Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb return CreateStat(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *rehasher) { - (void)rehasher; - return CreateStat(_fbb, - _o->id.size() ? _fbb.CreateString(_o->id) : 0, - _o->val, - _o->count); +inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + return CreateStat( + _fbb, + _o->id.size() ? _fbb.CreateString(_o->id) : 0, + _o->val, + _o->count); } inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *resolver) const { @@ -769,15 +1051,15 @@ inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *resolve { auto _e = mana(); _o->mana = _e; }; { auto _e = hp(); _o->hp = _e; }; { auto _e = name(); if (_e) _o->name = _e->str(); }; - { auto _e = inventory(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory.push_back(_e->Get(_i)); } } }; + { auto _e = inventory(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory.push_back(_e->Get(_i)); } }; { auto _e = color(); _o->color = _e; }; { auto _e = test_type(); _o->test.type = _e; }; - { auto _e = test(); if (_e) _o->test.table = AnyUnion::UnPack(_e, test_type(), resolver); }; - { auto _e = test4(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4.push_back(*_e->Get(_i)); } } }; - { auto _e = testarrayofstring(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring.push_back(_e->Get(_i)->str()); } } }; - { auto _e = testarrayoftables(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables.push_back(std::unique_ptr(_e->Get(_i)->UnPack(resolver))); } } }; + { auto _e = test(); if (_e) _o->test.table = AnyUnion::UnPack(_e, test_type(),resolver); }; + { auto _e = test4(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4.push_back(*_e->Get(_i)); } }; + { auto _e = testarrayofstring(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring.push_back(_e->Get(_i)->str()); } }; + { auto _e = testarrayoftables(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables.push_back(std::unique_ptr(_e->Get(_i)->UnPack(resolver))); } }; { auto _e = enemy(); if (_e) _o->enemy = std::unique_ptr(_e->UnPack(resolver)); }; - { auto _e = testnestedflatbuffer(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testnestedflatbuffer.push_back(_e->Get(_i)); } } }; + { auto _e = testnestedflatbuffer(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testnestedflatbuffer.push_back(_e->Get(_i)); } }; { auto _e = testempty(); if (_e) _o->testempty = std::unique_ptr(_e->UnPack(resolver)); }; { auto _e = testbool(); _o->testbool = _e; }; { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; }; @@ -788,11 +1070,11 @@ inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *resolve { auto _e = testhashu32_fnv1a(); if (resolver) (*resolver)(reinterpret_cast(&_o->testhashu32_fnv1a), static_cast(_e)); else _o->testhashu32_fnv1a = nullptr; }; { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; }; { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; }; - { auto _e = testarrayofbools(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools.push_back(_e->Get(_i)!=0); } } }; + { auto _e = testarrayofbools(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools.push_back(_e->Get(_i) != 0); } }; { auto _e = testf(); _o->testf = _e; }; { auto _e = testf2(); _o->testf2 = _e; }; { auto _e = testf3(); _o->testf3 = _e; }; - { auto _e = testarrayofstring2(); if (_e) { for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2.push_back(_e->Get(_i)->str()); } } }; + { auto _e = testarrayofstring2(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2.push_back(_e->Get(_i)->str()); } }; return _o; } @@ -800,74 +1082,115 @@ inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder return CreateMonster(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *rehasher) { - (void)rehasher; - return CreateMonster(_fbb, - _o->pos ? _o->pos.get() : 0, - _o->mana, - _o->hp, - _fbb.CreateString(_o->name), - _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0, - _o->color, - _o->test.type, - _o->test.Pack(_fbb), - _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0, - _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0, - _o->testarrayoftables.size() ? _fbb.CreateVector>(_o->testarrayoftables.size(), [&](size_t i) { return CreateMonster(_fbb, _o->testarrayoftables[i].get(), rehasher); }) : 0, - _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), rehasher) : 0, - _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0, - _o->testempty ? CreateStat(_fbb, _o->testempty.get(), rehasher) : 0, - _o->testbool, - _o->testhashs32_fnv1, - _o->testhashu32_fnv1, - _o->testhashs64_fnv1, - _o->testhashu64_fnv1, - _o->testhashs32_fnv1a, - rehasher ? static_cast((*rehasher)(_o->testhashu32_fnv1a)) : 0, - _o->testhashs64_fnv1a, - _o->testhashu64_fnv1a, - _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0, - _o->testf, - _o->testf2, - _o->testf3, - _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0); +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + return CreateMonster( + _fbb, + _o->pos ? _o->pos.get() : 0, + _o->mana, + _o->hp, + _fbb.CreateString(_o->name), + _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0, + _o->color, + _o->test.type, + _o->test.Pack(_fbb), + _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0, + _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0, + _o->testarrayoftables.size() ? _fbb.CreateVector>(_o->testarrayoftables.size(), [&](size_t i) { return CreateMonster(_fbb, _o->testarrayoftables[i].get(), _rehasher); }) : 0, + _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0, + _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0, + _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0, + _o->testbool, + _o->testhashs32_fnv1, + _o->testhashu32_fnv1, + _o->testhashs64_fnv1, + _o->testhashu64_fnv1, + _o->testhashs32_fnv1a, + _rehasher ? static_cast((*_rehasher)(_o->testhashu32_fnv1a)) : 0, + _o->testhashs64_fnv1a, + _o->testhashu64_fnv1a, + _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0, + _o->testf, + _o->testf2, + _o->testf3, + _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0); } -inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *union_obj, Any type) { +inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) { switch (type) { - case Any_NONE: return true; - case Any_Monster: return verifier.VerifyTable(reinterpret_cast(union_obj)); - case Any_TestSimpleTableWithEnum: return verifier.VerifyTable(reinterpret_cast(union_obj)); - case Any_MyGame_Example2_Monster: return verifier.VerifyTable(reinterpret_cast(union_obj)); + case Any_NONE: { + return true; + } + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return false; } } -inline flatbuffers::NativeTable *AnyUnion::UnPack(const void *union_obj, Any type, const flatbuffers::resolver_function_t *resolver) { +inline flatbuffers::NativeTable *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) { switch (type) { - case Any_NONE: return nullptr; - case Any_Monster: return reinterpret_cast(union_obj)->UnPack(resolver); - case Any_TestSimpleTableWithEnum: return reinterpret_cast(union_obj)->UnPack(resolver); - case Any_MyGame_Example2_Monster: return reinterpret_cast(union_obj)->UnPack(resolver); + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } default: return nullptr; } } -inline flatbuffers::Offset AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *rehasher) const { +inline flatbuffers::Offset AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { switch (type) { - case Any_NONE: return 0; - case Any_Monster: return CreateMonster(_fbb, reinterpret_cast(table), rehasher).Union(); - case Any_TestSimpleTableWithEnum: return CreateTestSimpleTableWithEnum(_fbb, reinterpret_cast(table), rehasher).Union(); - case Any_MyGame_Example2_Monster: return CreateMonster(_fbb, reinterpret_cast(table), rehasher).Union(); + case Any_Monster: { + auto ptr = reinterpret_cast(table); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(table); + return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(table); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } default: return 0; } } inline void AnyUnion::Reset() { switch (type) { - case Any_Monster: delete reinterpret_cast(table); break; - case Any_TestSimpleTableWithEnum: delete reinterpret_cast(table); break; - case Any_MyGame_Example2_Monster: delete reinterpret_cast(table); break; + case Any_Monster: { + auto ptr = reinterpret_cast(table); + delete ptr; + break; + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(table); + delete ptr; + break; + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(table); + delete ptr; + break; + } default: break; } table = nullptr; @@ -887,10 +1210,12 @@ inline const char *MonsterIdentifier() { } inline bool MonsterBufferHasIdentifier(const void *buf) { - return flatbuffers::BufferHasIdentifier(buf, MonsterIdentifier()); + return flatbuffers::BufferHasIdentifier( + buf, MonsterIdentifier()); } -inline bool VerifyMonsterBuffer(flatbuffers::Verifier &verifier) { +inline bool VerifyMonsterBuffer( + flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer(MonsterIdentifier()); } @@ -898,12 +1223,16 @@ inline const char *MonsterExtension() { return "mon"; } -inline void FinishMonsterBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset root) { +inline void FinishMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { fbb.Finish(root, MonsterIdentifier()); } -inline std::unique_ptr UnPackMonster(const void *buf, const flatbuffers::resolver_function_t *resolver = nullptr) { - return std::unique_ptr(GetMonster(buf)->UnPack(resolver)); +inline std::unique_ptr UnPackMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return std::unique_ptr(GetMonster(buf)->UnPack(res)); } } // namespace Example diff --git a/tests/namespace_test/namespace_test1_generated.h b/tests/namespace_test/namespace_test1_generated.h index 3e0366946..9c8c28a73 100644 --- a/tests/namespace_test/namespace_test1_generated.h +++ b/tests/namespace_test/namespace_test1_generated.h @@ -1,5 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify + #ifndef FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_H_ #define FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_H_ @@ -21,11 +22,19 @@ enum EnumInNestedNS { }; inline const char **EnumNamesEnumInNestedNS() { - static const char *names[] = { "A", "B", "C", nullptr }; + static const char *names[] = { + "A", + "B", + "C", + nullptr + }; return names; } -inline const char *EnumNameEnumInNestedNS(EnumInNestedNS e) { return EnumNamesEnumInNestedNS()[static_cast(e)]; } +inline const char *EnumNameEnumInNestedNS(EnumInNestedNS e) { + const size_t index = static_cast(e); + return EnumNamesEnumInNestedNS()[index]; +} MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS { private: @@ -33,15 +42,28 @@ MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS { int32_t b_; public: - StructInNestedNS() { memset(this, 0, sizeof(StructInNestedNS)); } - StructInNestedNS(const StructInNestedNS &_o) { memcpy(this, &_o, sizeof(StructInNestedNS)); } + StructInNestedNS() { + memset(this, 0, sizeof(StructInNestedNS)); + } + StructInNestedNS(const StructInNestedNS &_o) { + memcpy(this, &_o, sizeof(StructInNestedNS)); + } StructInNestedNS(int32_t _a, int32_t _b) - : a_(flatbuffers::EndianScalar(_a)), b_(flatbuffers::EndianScalar(_b)) { } - - int32_t a() const { return flatbuffers::EndianScalar(a_); } - void mutate_a(int32_t _a) { flatbuffers::WriteScalar(&a_, _a); } - int32_t b() const { return flatbuffers::EndianScalar(b_); } - void mutate_b(int32_t _b) { flatbuffers::WriteScalar(&b_, _b); } + : a_(flatbuffers::EndianScalar(_a)), + b_(flatbuffers::EndianScalar(_b)) { + } + int32_t a() const { + return flatbuffers::EndianScalar(a_); + } + void mutate_a(int32_t _a) { + flatbuffers::WriteScalar(&a_, _a); + } + int32_t b() const { + return flatbuffers::EndianScalar(b_); + } + void mutate_b(int32_t _b) { + flatbuffers::WriteScalar(&b_, _b); + } }; STRUCT_END(StructInNestedNS, 8); @@ -49,8 +71,12 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { enum { VT_FOO = 4 }; - int32_t foo() const { return GetField(VT_FOO, 0); } - bool mutate_foo(int32_t _foo) { return SetField(VT_FOO, _foo); } + int32_t foo() const { + return GetField(VT_FOO, 0); + } + bool mutate_foo(int32_t _foo) { + return SetField(VT_FOO, _foo); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FOO) && @@ -64,15 +90,20 @@ struct TableInNestedNSBuilder { void add_foo(int32_t foo) { fbb_.AddElement(TableInNestedNS::VT_FOO, foo, 0); } - TableInNestedNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + TableInNestedNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } TableInNestedNSBuilder &operator=(const TableInNestedNSBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 1)); + const auto end = fbb_.EndTable(start_, 1); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTableInNestedNS(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateTableInNestedNS( + flatbuffers::FlatBufferBuilder &_fbb, int32_t foo = 0) { TableInNestedNSBuilder builder_(_fbb); builder_.add_foo(foo); diff --git a/tests/namespace_test/namespace_test2_generated.h b/tests/namespace_test/namespace_test2_generated.h index 693d9f839..15971ba18 100644 --- a/tests/namespace_test/namespace_test2_generated.h +++ b/tests/namespace_test/namespace_test2_generated.h @@ -1,5 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify + #ifndef FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_ #define FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_ @@ -29,12 +30,24 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_FOO_ENUM = 6, VT_FOO_STRUCT = 8 }; - const NamespaceA::NamespaceB::TableInNestedNS *foo_table() const { return GetPointer(VT_FOO_TABLE); } - NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_table() { return GetPointer(VT_FOO_TABLE); } - NamespaceA::NamespaceB::EnumInNestedNS foo_enum() const { return static_cast(GetField(VT_FOO_ENUM, 0)); } - bool mutate_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS _foo_enum) { return SetField(VT_FOO_ENUM, static_cast(_foo_enum)); } - const NamespaceA::NamespaceB::StructInNestedNS *foo_struct() const { return GetStruct(VT_FOO_STRUCT); } - NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() { return GetStruct(VT_FOO_STRUCT); } + const NamespaceA::NamespaceB::TableInNestedNS *foo_table() const { + return GetPointer(VT_FOO_TABLE); + } + NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_table() { + return GetPointer(VT_FOO_TABLE); + } + NamespaceA::NamespaceB::EnumInNestedNS foo_enum() const { + return static_cast(GetField(VT_FOO_ENUM, 0)); + } + bool mutate_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS _foo_enum) { + return SetField(VT_FOO_ENUM, static_cast(_foo_enum)); + } + const NamespaceA::NamespaceB::StructInNestedNS *foo_struct() const { + return GetStruct(VT_FOO_STRUCT); + } + NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() { + return GetStruct(VT_FOO_STRUCT); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FOO_TABLE) && @@ -57,15 +70,20 @@ struct TableInFirstNSBuilder { void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) { fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct); } - TableInFirstNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + TableInFirstNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } TableInFirstNSBuilder &operator=(const TableInFirstNSBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 3)); + const auto end = fbb_.EndTable(start_, 3); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateTableInFirstNS( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset foo_table = 0, NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A, const NamespaceA::NamespaceB::StructInNestedNS *foo_struct = 0) { @@ -85,10 +103,18 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_REFER_TO_A1 = 4, VT_REFER_TO_A2 = 6 }; - const NamespaceA::TableInFirstNS *refer_to_a1() const { return GetPointer(VT_REFER_TO_A1); } - NamespaceA::TableInFirstNS *mutable_refer_to_a1() { return GetPointer(VT_REFER_TO_A1); } - const NamespaceA::SecondTableInA *refer_to_a2() const { return GetPointer(VT_REFER_TO_A2); } - NamespaceA::SecondTableInA *mutable_refer_to_a2() { return GetPointer(VT_REFER_TO_A2); } + const NamespaceA::TableInFirstNS *refer_to_a1() const { + return GetPointer(VT_REFER_TO_A1); + } + NamespaceA::TableInFirstNS *mutable_refer_to_a1() { + return GetPointer(VT_REFER_TO_A1); + } + const NamespaceA::SecondTableInA *refer_to_a2() const { + return GetPointer(VT_REFER_TO_A2); + } + NamespaceA::SecondTableInA *mutable_refer_to_a2() { + return GetPointer(VT_REFER_TO_A2); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_REFER_TO_A1) && @@ -108,15 +134,20 @@ struct TableInCBuilder { void add_refer_to_a2(flatbuffers::Offset refer_to_a2) { fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2); } - TableInCBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + TableInCBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } TableInCBuilder &operator=(const TableInCBuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 2)); + const auto end = fbb_.EndTable(start_, 2); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateTableInC( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset refer_to_a1 = 0, flatbuffers::Offset refer_to_a2 = 0) { TableInCBuilder builder_(_fbb); @@ -133,8 +164,12 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { enum { VT_REFER_TO_C = 4 }; - const NamespaceC::TableInC *refer_to_c() const { return GetPointer(VT_REFER_TO_C); } - NamespaceC::TableInC *mutable_refer_to_c() { return GetPointer(VT_REFER_TO_C); } + const NamespaceC::TableInC *refer_to_c() const { + return GetPointer(VT_REFER_TO_C); + } + NamespaceC::TableInC *mutable_refer_to_c() { + return GetPointer(VT_REFER_TO_C); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_REFER_TO_C) && @@ -149,15 +184,20 @@ struct SecondTableInABuilder { void add_refer_to_c(flatbuffers::Offset refer_to_c) { fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c); } - SecondTableInABuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + SecondTableInABuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } SecondTableInABuilder &operator=(const SecondTableInABuilder &); flatbuffers::Offset Finish() { - auto o = flatbuffers::Offset(fbb_.EndTable(start_, 1)); + const auto end = fbb_.EndTable(start_, 1); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, +inline flatbuffers::Offset CreateSecondTableInA( + flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset refer_to_c = 0) { SecondTableInABuilder builder_(_fbb); builder_.add_refer_to_c(refer_to_c);