Remove generated .h files from repo
diff --git a/CMakeLists.txt b/CMakeLists.txt index 7bf48e6..9a4e86a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt
@@ -515,13 +515,13 @@ endfunction() function(compile_schema_for_test SRC_FBS OPT) - compile_schema("${SRC_FBS}" "${OPT}" "_generated" GEN_FILE) + compile_schema("${SRC_FBS}" "${OPT}" ".fbs" GEN_FILE) target_sources(flattests PRIVATE ${GEN_FILE}) endfunction() -function(compile_schema_for_test_fbsh SRC_FBS OPT) +function(compile_schema_for_test_17 SRC_FBS OPT) compile_schema("${SRC_FBS}" "${OPT}" ".fbs" GEN_FILE) - target_sources(flattests PRIVATE ${GEN_FILE}) + target_sources(flattests_cpp17 PRIVATE ${GEN_FILE}) endfunction() function(compile_schema_for_samples SRC_FBS OPT) @@ -548,17 +548,26 @@ # The flattest target needs some generated files SET(FLATC_OPT_COMP --cpp --gen-compare --gen-mutable --gen-object-api --reflect-names) SET(FLATC_OPT_SCOPED_ENUMS ${FLATC_OPT_COMP};--scoped-enums) + SET(FLATC_OPT_NAKED_PTR ${FLATC_OPT_COMP} --cpp-ptr-type naked) compile_schema_for_test(tests/alignment_test.fbs "${FLATC_OPT_COMP}") - compile_schema_for_test_fbsh(tests/default_vectors_strings_test.fbs "${FLATC_OPT_COMP}") + compile_schema_for_test(tests/default_vectors_strings_test.fbs "${FLATC_OPT_COMP}") + compile_schema_for_test(tests/monster_extra.fbs "${FLATC_OPT_COMP}") compile_schema_for_test(tests/arrays_test.fbs "${FLATC_OPT_SCOPED_ENUMS}") compile_schema_for_test(tests/native_inline_table_test.fbs "${FLATC_OPT_COMP}") compile_schema_for_test(tests/native_type_test.fbs "${FLATC_OPT_COMP}") + compile_schema_for_test(tests/optional_scalars.fbs "${FLATC_OPT_COMP}") compile_schema_for_test(tests/key_field/key_field_sample.fbs "${FLATC_OPT_COMP}") compile_schema_for_test(tests/64bit/test_64bit.fbs "${FLATC_OPT_COMP};--bfbs-gen-embed") compile_schema_for_test(tests/64bit/evolution/v1.fbs "${FLATC_OPT_COMP}") compile_schema_for_test(tests/64bit/evolution/v2.fbs "${FLATC_OPT_COMP}") compile_schema_for_test(tests/union_underlying_type_test.fbs "${FLATC_OPT_SCOPED_ENUMS}") + compile_schema_for_test(tests/evolution_test/evolution_v1.fbs "${FLATC_OPT_SCOPED_ENUMS}") + compile_schema_for_test(tests/evolution_test/evolution_v2.fbs "${FLATC_OPT_SCOPED_ENUMS}") + compile_schema_for_test(tests/vector_table_naked_ptr.fbs "${FLATC_OPT_NAKED_PTR}") + compile_schema_for_test(tests/namespace_test/namespace_test1.fbs "${FLATC_OPT_SCOPED_ENUMS}") + compile_schema_for_test(tests/namespace_test/namespace_test2.fbs "${FLATC_OPT_SCOPED_ENUMS}") + compile_schema_for_test(tests/union_vector/union_vector.fbs "${FLATC_OPT_COMP}") if(FLATBUFFERS_CODE_SANITIZE) add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE}) @@ -588,9 +597,19 @@ if(FLATBUFFERS_BUILD_CPP17) add_executable(flattests_cpp17 ${FlatBuffers_Tests_CPP17_SRCS}) target_link_libraries(flattests_cpp17 PRIVATE $<BUILD_INTERFACE:ProjectConfig>) - target_include_directories(flattests_cpp17 PUBLIC src tests) + target_include_directories(flattests_cpp17 PUBLIC + # Ideally everything is fully qualified from the root directories + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_BINARY_DIR} + # TODO(derekbailey): update includes to fully qualify src/ and tests/ + src + tests + ${CMAKE_CURRENT_BINARY_DIR}/tests + ) target_compile_features(flattests_cpp17 PRIVATE cxx_std_17) # requires cmake 3.8 + compile_schema_for_test_17(tests/optional_scalars.fbs "${FLATC_OPT_COMP}") + if(FLATBUFFERS_CODE_SANITIZE) add_fsanitize_to_target(flattests_cpp17 ${FLATBUFFERS_CODE_SANITIZE}) endif()
diff --git a/scripts/generate_code.py b/scripts/generate_code.py index c89403e..cdd075b 100755 --- a/scripts/generate_code.py +++ b/scripts/generate_code.py
@@ -241,12 +241,6 @@ ) flatc( - BASE_OPTS + CPP_OPTS + ["--cpp-ptr-type", "naked"], - prefix="vector_table_naked_ptr", - schema="vector_table_naked_ptr.fbs", -) - -flatc( BASE_OPTS + CPP_OPTS + CS_OPTS + JAVA_OPTS + KOTLIN_OPTS + PHP_OPTS, prefix="union_vector", schema="union_vector/union_vector.fbs", @@ -362,7 +356,13 @@ ) flatc( - ["--cpp", "--gen-compare", "--gen-mutable", "--gen-object-api", "--reflect-names"], + [ + "--cpp", + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + ], schema="native_type_test.fbs", )
diff --git a/tests/64bit/BUILD.bazel b/tests/64bit/BUILD.bazel new file mode 100644 index 0000000..f6a6d0c --- /dev/null +++ b/tests/64bit/BUILD.bazel
@@ -0,0 +1,30 @@ +load("@rules_cc//cc:defs.bzl", "cc_library") +load("//:build_defs.bzl", "flatbuffer_cc_library") + +package(default_visibility = ["//visibility:public"]) + +cc_library( + name = "offset64_test", + testonly = 1, + srcs = ["offset64_test.cpp"], + hdrs = ["offset64_test.h"], + deps = [ + ":test_64bit_cc_fbs", + "//tests:test_assert", + "//tests/64bit/evolution:v1_cc_fbs", + "//tests/64bit/evolution:v2_cc_fbs", + ], +) + +flatbuffer_cc_library( + name = "test_64bit_cc_fbs", + srcs = ["test_64bit.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +)
diff --git a/tests/64bit/evolution/BUILD.bazel b/tests/64bit/evolution/BUILD.bazel new file mode 100644 index 0000000..98b18a5 --- /dev/null +++ b/tests/64bit/evolution/BUILD.bazel
@@ -0,0 +1,29 @@ +load("//:build_defs.bzl", "flatbuffer_cc_library") + +package(default_visibility = ["//visibility:public"]) + +flatbuffer_cc_library( + name = "v1_cc_fbs", + srcs = ["v1.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +) + +flatbuffer_cc_library( + name = "v2_cc_fbs", + srcs = ["v2.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +)
diff --git a/tests/64bit/evolution/v1_generated.h b/tests/64bit/evolution/v1_generated.h deleted file mode 100644 index f4abe44..0000000 --- a/tests/64bit/evolution/v1_generated.h +++ /dev/null
@@ -1,222 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_V1_V1_H_ -#define FLATBUFFERS_GENERATED_V1_V1_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace v1 { - -struct RootTable; -struct RootTableBuilder; -struct RootTableT; - -bool operator==(const RootTableT &lhs, const RootTableT &rhs); -bool operator!=(const RootTableT &lhs, const RootTableT &rhs); - -inline const ::flatbuffers::TypeTable *RootTableTypeTable(); - -struct RootTableT : public ::flatbuffers::NativeTable { - typedef RootTable TableType; - float a = 0.0f; - std::vector<uint8_t> b{}; -}; - -struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef RootTableT NativeTableType; - typedef RootTableBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return RootTableTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4, - VT_B = 6 - }; - float a() const { - return GetField<float>(VT_A, 0.0f); - } - bool mutate_a(float _a = 0.0f) { - return SetField<float>(VT_A, _a, 0.0f); - } - const ::flatbuffers::Vector<uint8_t> *b() const { - return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_B); - } - ::flatbuffers::Vector<uint8_t> *mutable_b() { - return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<float>(verifier, VT_A, 4) && - VerifyOffset(verifier, VT_B) && - verifier.VerifyVector(b()) && - verifier.EndTable(); - } - RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct RootTableBuilder { - typedef RootTable Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(float a) { - fbb_.AddElement<float>(RootTable::VT_A, a, 0.0f); - } - void add_b(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b) { - fbb_.AddOffset(RootTable::VT_B, b); - } - explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<RootTable> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<RootTable>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<RootTable> CreateRootTable( - ::flatbuffers::FlatBufferBuilder &_fbb, - float a = 0.0f, - ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b = 0) { - RootTableBuilder builder_(_fbb); - builder_.add_b(b); - builder_.add_a(a); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - float a = 0.0f, - const std::vector<uint8_t> *b = nullptr) { - auto b__ = b ? _fbb.CreateVector<uint8_t>(*b) : 0; - return v1::CreateRootTable( - _fbb, - a, - b__); -} - -::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) { - return - (lhs.a == rhs.a) && - (lhs.b == rhs.b); -} - -inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) { - return !(lhs == rhs); -} - - -inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<RootTableT>(new RootTableT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = a(); _o->a = _e; } - { auto _e = b(); if (_e) { _o->b.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->b.begin()); } } -} - -inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return RootTable::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _a = _o->a; - auto _b = _o->b.size() ? _fbb.CreateVector(_o->b) : 0; - return v1::CreateRootTable( - _fbb, - _a, - _b); -} - -inline const ::flatbuffers::TypeTable *RootTableTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_UCHAR, 1, -1 } - }; - static const char * const names[] = { - "a", - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const v1::RootTable *GetRootTable(const void *buf) { - return ::flatbuffers::GetRoot<v1::RootTable>(buf); -} - -inline const v1::RootTable *GetSizePrefixedRootTable(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<v1::RootTable>(buf); -} - -inline RootTable *GetMutableRootTable(void *buf) { - return ::flatbuffers::GetMutableRoot<RootTable>(buf); -} - -inline v1::RootTable *GetMutableSizePrefixedRootTable(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<v1::RootTable>(buf); -} - -template <bool B = false> -inline bool VerifyRootTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<v1::RootTable>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedRootTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<v1::RootTable>(nullptr); -} - -inline void FinishRootTableBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<v1::RootTable> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedRootTableBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<v1::RootTable> root) { - fbb.FinishSizePrefixed(root); -} - -inline std::unique_ptr<v1::RootTableT> UnPackRootTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<v1::RootTableT>(GetRootTable(buf)->UnPack(res)); -} - -inline std::unique_ptr<v1::RootTableT> UnPackSizePrefixedRootTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<v1::RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res)); -} - -} // namespace v1 - -#endif // FLATBUFFERS_GENERATED_V1_V1_H_
diff --git a/tests/64bit/evolution/v2_generated.h b/tests/64bit/evolution/v2_generated.h deleted file mode 100644 index d3f06cd..0000000 --- a/tests/64bit/evolution/v2_generated.h +++ /dev/null
@@ -1,246 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_V2_V2_H_ -#define FLATBUFFERS_GENERATED_V2_V2_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace v2 { - -struct RootTable; -struct RootTableBuilder; -struct RootTableT; - -bool operator==(const RootTableT &lhs, const RootTableT &rhs); -bool operator!=(const RootTableT &lhs, const RootTableT &rhs); - -inline const ::flatbuffers::TypeTable *RootTableTypeTable(); - -struct RootTableT : public ::flatbuffers::NativeTable { - typedef RootTable TableType; - float a = 0.0f; - std::vector<uint8_t> b{}; - std::vector<uint8_t> big_vector{}; -}; - -struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef RootTableT NativeTableType; - typedef RootTableBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return RootTableTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4, - VT_B = 6, - VT_BIG_VECTOR = 8 - }; - float a() const { - return GetField<float>(VT_A, 0.0f); - } - bool mutate_a(float _a = 0.0f) { - return SetField<float>(VT_A, _a, 0.0f); - } - const ::flatbuffers::Vector<uint8_t> *b() const { - return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_B); - } - ::flatbuffers::Vector<uint8_t> *mutable_b() { - return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B); - } - const ::flatbuffers::Vector64<uint8_t> *big_vector() const { - return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR); - } - ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() { - return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<float>(verifier, VT_A, 4) && - VerifyOffset(verifier, VT_B) && - verifier.VerifyVector(b()) && - VerifyOffset64(verifier, VT_BIG_VECTOR) && - verifier.VerifyVector(big_vector()) && - verifier.EndTable(); - } - RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct RootTableBuilder { - typedef RootTable Table; - ::flatbuffers::FlatBufferBuilder64 &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(float a) { - fbb_.AddElement<float>(RootTable::VT_A, a, 0.0f); - } - void add_b(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b) { - fbb_.AddOffset(RootTable::VT_B, b); - } - void add_big_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector) { - fbb_.AddOffset(RootTable::VT_BIG_VECTOR, big_vector); - } - explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<RootTable> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<RootTable>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<RootTable> CreateRootTable( - ::flatbuffers::FlatBufferBuilder64 &_fbb, - float a = 0.0f, - ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b = 0, - ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector = 0) { - RootTableBuilder builder_(_fbb); - builder_.add_big_vector(big_vector); - builder_.add_b(b); - builder_.add_a(a); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect( - ::flatbuffers::FlatBufferBuilder64 &_fbb, - float a = 0.0f, - const std::vector<uint8_t> *b = nullptr, - const std::vector<uint8_t> *big_vector = nullptr) { - auto big_vector__ = big_vector ? _fbb.CreateVector64(*big_vector) : 0; - auto b__ = b ? _fbb.CreateVector<uint8_t>(*b) : 0; - return v2::CreateRootTable( - _fbb, - a, - b__, - big_vector__); -} - -::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) { - return - (lhs.a == rhs.a) && - (lhs.b == rhs.b) && - (lhs.big_vector == rhs.big_vector); -} - -inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) { - return !(lhs == rhs); -} - - -inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<RootTableT>(new RootTableT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = a(); _o->a = _e; } - { auto _e = b(); if (_e) { _o->b.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->b.begin()); } } - { auto _e = big_vector(); if (_e) { _o->big_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_vector.begin()); } } -} - -inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return RootTable::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _a = _o->a; - auto _b = _o->b.size() ? _fbb.CreateVector(_o->b) : 0; - auto _big_vector = _o->big_vector.size() ? _fbb.CreateVector64(_o->big_vector) : 0; - return v2::CreateRootTable( - _fbb, - _a, - _b, - _big_vector); -} - -inline const ::flatbuffers::TypeTable *RootTableTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_UCHAR, 1, -1 }, - { ::flatbuffers::ET_UCHAR, 1, -1 } - }; - static const char * const names[] = { - "a", - "b", - "big_vector" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const v2::RootTable *GetRootTable(const void *buf) { - return ::flatbuffers::GetRoot<v2::RootTable>(buf); -} - -inline const v2::RootTable *GetSizePrefixedRootTable(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf); -} - -inline RootTable *GetMutableRootTable(void *buf) { - return ::flatbuffers::GetMutableRoot<RootTable>(buf); -} - -inline v2::RootTable *GetMutableSizePrefixedRootTable(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf); -} - -template <bool B = false> -inline bool VerifyRootTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<v2::RootTable>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedRootTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<v2::RootTable,::flatbuffers::uoffset64_t>(nullptr); -} - -inline void FinishRootTableBuffer( - ::flatbuffers::FlatBufferBuilder64 &fbb, - ::flatbuffers::Offset<v2::RootTable> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedRootTableBuffer( - ::flatbuffers::FlatBufferBuilder64 &fbb, - ::flatbuffers::Offset<v2::RootTable> root) { - fbb.FinishSizePrefixed(root); -} - -inline std::unique_ptr<v2::RootTableT> UnPackRootTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<v2::RootTableT>(GetRootTable(buf)->UnPack(res)); -} - -inline std::unique_ptr<v2::RootTableT> UnPackSizePrefixedRootTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<v2::RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res)); -} - -} // namespace v2 - -#endif // FLATBUFFERS_GENERATED_V2_V2_H_
diff --git a/tests/64bit/offset64_test.cpp b/tests/64bit/offset64_test.cpp index d185e38..c16ed68 100644 --- a/tests/64bit/offset64_test.cpp +++ b/tests/64bit/offset64_test.cpp
@@ -11,9 +11,9 @@ #include "flatbuffers/buffer.h" #include "flatbuffers/flatbuffer_builder.h" #include "flatbuffers/flatbuffers.h" -#include "tests/64bit/evolution/v1_generated.h" -#include "tests/64bit/evolution/v2_generated.h" -#include "tests/64bit/test_64bit_generated.h" +#include "tests/64bit/evolution/v1.fbs.h" +#include "tests/64bit/evolution/v2.fbs.h" +#include "tests/64bit/test_64bit.fbs.h" #include "tests/test_assert.h" namespace flatbuffers {
diff --git a/tests/64bit/test_64bit_generated.h b/tests/64bit/test_64bit_generated.h deleted file mode 100644 index bd255c5..0000000 --- a/tests/64bit/test_64bit_generated.h +++ /dev/null
@@ -1,683 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_TEST64BIT_H_ -#define FLATBUFFERS_GENERATED_TEST64BIT_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -// For access to the binary schema that produced this file. -#include "test_64bit_bfbs_generated.h" - -struct LeafStruct; - -struct WrapperTable; -struct WrapperTableBuilder; -struct WrapperTableT; - -struct RootTable; -struct RootTableBuilder; -struct RootTableT; - -bool operator==(const LeafStruct &lhs, const LeafStruct &rhs); -bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs); -bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs); -bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs); -bool operator==(const RootTableT &lhs, const RootTableT &rhs); -bool operator!=(const RootTableT &lhs, const RootTableT &rhs); - -inline const ::flatbuffers::TypeTable *LeafStructTypeTable(); - -inline const ::flatbuffers::TypeTable *WrapperTableTypeTable(); - -inline const ::flatbuffers::TypeTable *RootTableTypeTable(); - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) LeafStruct FLATBUFFERS_FINAL_CLASS { - private: - int32_t a_; - int32_t padding0__; - double b_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return LeafStructTypeTable(); - } - LeafStruct() - : a_(0), - padding0__(0), - b_(0) { - (void)padding0__; - } - LeafStruct(int32_t _a, double _b) - : a_(::flatbuffers::EndianScalar(_a)), - padding0__(0), - b_(::flatbuffers::EndianScalar(_b)) { - (void)padding0__; - } - int32_t a() const { - return ::flatbuffers::EndianScalar(a_); - } - void mutate_a(int32_t _a) { - ::flatbuffers::WriteScalar(&a_, _a); - } - double b() const { - return ::flatbuffers::EndianScalar(b_); - } - void mutate_b(double _b) { - ::flatbuffers::WriteScalar(&b_, _b); - } -}; -FLATBUFFERS_STRUCT_END(LeafStruct, 16); - -inline bool operator==(const LeafStruct &lhs, const LeafStruct &rhs) { - return - (lhs.a() == rhs.a()) && - (lhs.b() == rhs.b()); -} - -inline bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs) { - return !(lhs == rhs); -} - - -struct WrapperTableT : public ::flatbuffers::NativeTable { - typedef WrapperTable TableType; - std::vector<int8_t> vector{}; -}; - -struct WrapperTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef WrapperTableT NativeTableType; - typedef WrapperTableBuilder Builder; - typedef RootTableBinarySchema BinarySchema; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return WrapperTableTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_VECTOR = 4 - }; - const ::flatbuffers::Vector<int8_t> *vector() const { - return GetPointer64<const ::flatbuffers::Vector<int8_t> *>(VT_VECTOR); - } - ::flatbuffers::Vector<int8_t> *mutable_vector() { - return GetPointer64<::flatbuffers::Vector<int8_t> *>(VT_VECTOR); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset64(verifier, VT_VECTOR) && - verifier.VerifyVector(vector()) && - verifier.EndTable(); - } - WrapperTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<WrapperTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct WrapperTableBuilder { - typedef WrapperTable Table; - ::flatbuffers::FlatBufferBuilder64 &fbb_; - ::flatbuffers::uoffset_t start_; - void add_vector(::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector) { - fbb_.AddOffset(WrapperTable::VT_VECTOR, vector); - } - explicit WrapperTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<WrapperTable> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<WrapperTable>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable( - ::flatbuffers::FlatBufferBuilder64 &_fbb, - ::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector = 0) { - WrapperTableBuilder builder_(_fbb); - builder_.add_vector(vector); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTableDirect( - ::flatbuffers::FlatBufferBuilder64 &_fbb, - const std::vector<int8_t> *vector = nullptr) { - auto vector__ = vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*vector) : 0; - return CreateWrapperTable( - _fbb, - vector__); -} - -::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct RootTableT : public ::flatbuffers::NativeTable { - typedef RootTable TableType; - std::vector<uint8_t> far_vector{}; - int32_t a = 0; - std::string far_string{}; - std::vector<uint8_t> big_bool_vector{}; - std::vector<uint8_t> big_vector{}; - std::string near_string{}; - std::vector<uint8_t> nested_root{}; - std::vector<LeafStruct> far_struct_vector{}; - std::vector<LeafStruct> big_struct_vector{}; - std::vector<std::unique_ptr<WrapperTableT>> many_vectors{}; - std::vector<uint8_t> forced_aligned_vector{}; - RootTableT() = default; - RootTableT(const RootTableT &o); - RootTableT(RootTableT&&) FLATBUFFERS_NOEXCEPT = default; - RootTableT &operator=(RootTableT o) FLATBUFFERS_NOEXCEPT; -}; - -struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef RootTableT NativeTableType; - typedef RootTableBuilder Builder; - typedef RootTableBinarySchema BinarySchema; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return RootTableTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FAR_VECTOR = 4, - VT_A = 6, - VT_FAR_STRING = 8, - VT_BIG_BOOL_VECTOR = 10, - VT_BIG_VECTOR = 12, - VT_NEAR_STRING = 14, - VT_NESTED_ROOT = 16, - VT_FAR_STRUCT_VECTOR = 18, - VT_BIG_STRUCT_VECTOR = 20, - VT_MANY_VECTORS = 22, - VT_FORCED_ALIGNED_VECTOR = 24 - }; - const ::flatbuffers::Vector<uint8_t> *far_vector() const { - return GetPointer64<const ::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR); - } - ::flatbuffers::Vector<uint8_t> *mutable_far_vector() { - return GetPointer64<::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR); - } - int32_t a() const { - return GetField<int32_t>(VT_A, 0); - } - bool mutate_a(int32_t _a = 0) { - return SetField<int32_t>(VT_A, _a, 0); - } - const ::flatbuffers::String *far_string() const { - return GetPointer64<const ::flatbuffers::String *>(VT_FAR_STRING); - } - ::flatbuffers::String *mutable_far_string() { - return GetPointer64<::flatbuffers::String *>(VT_FAR_STRING); - } - const ::flatbuffers::Vector64<uint8_t> *big_bool_vector() const { - return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_BOOL_VECTOR); - } - ::flatbuffers::Vector64<uint8_t> *mutable_big_bool_vector() { - return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_BOOL_VECTOR); - } - const ::flatbuffers::Vector64<uint8_t> *big_vector() const { - return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR); - } - ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() { - return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR); - } - const ::flatbuffers::String *near_string() const { - return GetPointer<const ::flatbuffers::String *>(VT_NEAR_STRING); - } - ::flatbuffers::String *mutable_near_string() { - return GetPointer<::flatbuffers::String *>(VT_NEAR_STRING); - } - const ::flatbuffers::Vector64<uint8_t> *nested_root() const { - return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT); - } - ::flatbuffers::Vector64<uint8_t> *mutable_nested_root() { - return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT); - } - const RootTable *nested_root_nested_root() const { - const auto _f = nested_root(); - return _f ? ::flatbuffers::GetRoot<RootTable>(_f->Data()) - : nullptr; - } - const ::flatbuffers::Vector<const LeafStruct *> *far_struct_vector() const { - return GetPointer64<const ::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR); - } - ::flatbuffers::Vector<const LeafStruct *> *mutable_far_struct_vector() { - return GetPointer64<::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR); - } - const ::flatbuffers::Vector64<const LeafStruct *> *big_struct_vector() const { - return GetPointer64<const ::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR); - } - ::flatbuffers::Vector64<const LeafStruct *> *mutable_big_struct_vector() { - return GetPointer64<::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR); - } - const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *many_vectors() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS); - } - ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *mutable_many_vectors() { - return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS); - } - const ::flatbuffers::Vector64<uint8_t> *forced_aligned_vector() const { - return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR); - } - ::flatbuffers::Vector64<uint8_t> *mutable_forced_aligned_vector() { - return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset64(verifier, VT_FAR_VECTOR) && - verifier.VerifyVector(far_vector()) && - VerifyField<int32_t>(verifier, VT_A, 4) && - VerifyOffset64(verifier, VT_FAR_STRING) && - verifier.VerifyString(far_string()) && - VerifyOffset64(verifier, VT_BIG_BOOL_VECTOR) && - verifier.VerifyVector(big_bool_vector()) && - VerifyOffset64(verifier, VT_BIG_VECTOR) && - verifier.VerifyVector(big_vector()) && - VerifyOffset(verifier, VT_NEAR_STRING) && - verifier.VerifyString(near_string()) && - VerifyOffset64(verifier, VT_NESTED_ROOT) && - verifier.VerifyVector(nested_root()) && - verifier.template VerifyNestedFlatBuffer<RootTable>(nested_root(), nullptr) && - VerifyOffset64(verifier, VT_FAR_STRUCT_VECTOR) && - verifier.VerifyVector(far_struct_vector()) && - VerifyOffset64(verifier, VT_BIG_STRUCT_VECTOR) && - verifier.VerifyVector(big_struct_vector()) && - VerifyOffset(verifier, VT_MANY_VECTORS) && - verifier.VerifyVector(many_vectors()) && - verifier.VerifyVectorOfTables(many_vectors()) && - VerifyOffset64(verifier, VT_FORCED_ALIGNED_VECTOR) && - verifier.VerifyVector(forced_aligned_vector()) && - verifier.EndTable(); - } - RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct RootTableBuilder { - typedef RootTable Table; - ::flatbuffers::FlatBufferBuilder64 &fbb_; - ::flatbuffers::uoffset_t start_; - void add_far_vector(::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector) { - fbb_.AddOffset(RootTable::VT_FAR_VECTOR, far_vector); - } - void add_a(int32_t a) { - fbb_.AddElement<int32_t>(RootTable::VT_A, a, 0); - } - void add_far_string(::flatbuffers::Offset64<::flatbuffers::String> far_string) { - fbb_.AddOffset(RootTable::VT_FAR_STRING, far_string); - } - void add_big_bool_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_bool_vector) { - fbb_.AddOffset(RootTable::VT_BIG_BOOL_VECTOR, big_bool_vector); - } - void add_big_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector) { - fbb_.AddOffset(RootTable::VT_BIG_VECTOR, big_vector); - } - void add_near_string(::flatbuffers::Offset<::flatbuffers::String> near_string) { - fbb_.AddOffset(RootTable::VT_NEAR_STRING, near_string); - } - void add_nested_root(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root) { - fbb_.AddOffset(RootTable::VT_NESTED_ROOT, nested_root); - } - void add_far_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector) { - fbb_.AddOffset(RootTable::VT_FAR_STRUCT_VECTOR, far_struct_vector); - } - void add_big_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector) { - fbb_.AddOffset(RootTable::VT_BIG_STRUCT_VECTOR, big_struct_vector); - } - void add_many_vectors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors) { - fbb_.AddOffset(RootTable::VT_MANY_VECTORS, many_vectors); - } - void add_forced_aligned_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> forced_aligned_vector) { - fbb_.AddOffset(RootTable::VT_FORCED_ALIGNED_VECTOR, forced_aligned_vector); - } - explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<RootTable> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<RootTable>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<RootTable> CreateRootTable( - ::flatbuffers::FlatBufferBuilder64 &_fbb, - ::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector = 0, - int32_t a = 0, - ::flatbuffers::Offset64<::flatbuffers::String> far_string = 0, - ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_bool_vector = 0, - ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector = 0, - ::flatbuffers::Offset<::flatbuffers::String> near_string = 0, - ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root = 0, - ::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector = 0, - ::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors = 0, - ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> forced_aligned_vector = 0) { - RootTableBuilder builder_(_fbb); - builder_.add_forced_aligned_vector(forced_aligned_vector); - builder_.add_big_struct_vector(big_struct_vector); - builder_.add_nested_root(nested_root); - builder_.add_big_vector(big_vector); - builder_.add_big_bool_vector(big_bool_vector); - builder_.add_many_vectors(many_vectors); - builder_.add_far_struct_vector(far_struct_vector); - builder_.add_near_string(near_string); - builder_.add_far_string(far_string); - builder_.add_a(a); - builder_.add_far_vector(far_vector); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect( - ::flatbuffers::FlatBufferBuilder64 &_fbb, - const std::vector<uint8_t> *far_vector = nullptr, - int32_t a = 0, - const char *far_string = nullptr, - const std::vector<uint8_t> *big_bool_vector = nullptr, - const std::vector<uint8_t> *big_vector = nullptr, - const char *near_string = nullptr, - const std::vector<uint8_t> *nested_root = nullptr, - const std::vector<LeafStruct> *far_struct_vector = nullptr, - const std::vector<LeafStruct> *big_struct_vector = nullptr, - const std::vector<::flatbuffers::Offset<WrapperTable>> *many_vectors = nullptr, - const std::vector<uint8_t> *forced_aligned_vector = nullptr) { - auto far_vector__ = far_vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*far_vector) : 0; - auto far_string__ = far_string ? _fbb.CreateString<::flatbuffers::Offset64>(far_string) : 0; - auto big_bool_vector__ = big_bool_vector ? _fbb.CreateVector64(*big_bool_vector) : 0; - auto big_vector__ = big_vector ? _fbb.CreateVector64(*big_vector) : 0; - auto nested_root__ = nested_root ? _fbb.CreateVector64(*nested_root) : 0; - auto far_struct_vector__ = far_struct_vector ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(*far_struct_vector) : 0; - auto big_struct_vector__ = big_struct_vector ? _fbb.CreateVectorOfStructs64(*big_struct_vector) : 0; - if (forced_aligned_vector) { _fbb.ForceVectorAlignment64(forced_aligned_vector->size(), sizeof(uint8_t), 32); } - auto forced_aligned_vector__ = forced_aligned_vector ? _fbb.CreateVector64(*forced_aligned_vector) : 0; - auto near_string__ = near_string ? _fbb.CreateString(near_string) : 0; - auto many_vectors__ = many_vectors ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>>(*many_vectors) : 0; - return CreateRootTable( - _fbb, - far_vector__, - a, - far_string__, - big_bool_vector__, - big_vector__, - near_string__, - nested_root__, - far_struct_vector__, - big_struct_vector__, - many_vectors__, - forced_aligned_vector__); -} - -::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs) { - return - (lhs.vector == rhs.vector); -} - -inline bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs) { - return !(lhs == rhs); -} - - -inline WrapperTableT *WrapperTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<WrapperTableT>(new WrapperTableT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void WrapperTable::UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = vector(); if (_e) { _o->vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->vector.begin()); } } -} - -inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return WrapperTable::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<WrapperTable> WrapperTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const WrapperTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _vector = _o->vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->vector) : 0; - return CreateWrapperTable( - _fbb, - _vector); -} - - -inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) { - return - (lhs.far_vector == rhs.far_vector) && - (lhs.a == rhs.a) && - (lhs.far_string == rhs.far_string) && - (lhs.big_bool_vector == rhs.big_bool_vector) && - (lhs.big_vector == rhs.big_vector) && - (lhs.near_string == rhs.near_string) && - (lhs.nested_root == rhs.nested_root) && - (lhs.far_struct_vector == rhs.far_struct_vector) && - (lhs.big_struct_vector == rhs.big_struct_vector) && - (lhs.many_vectors.size() == rhs.many_vectors.size() && std::equal(lhs.many_vectors.cbegin(), lhs.many_vectors.cend(), rhs.many_vectors.cbegin(), [](std::unique_ptr<WrapperTableT> const &a, std::unique_ptr<WrapperTableT> const &b) { return (a == b) || (a && b && *a == *b); })) && - (lhs.forced_aligned_vector == rhs.forced_aligned_vector); -} - -inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) { - return !(lhs == rhs); -} - - -inline RootTableT::RootTableT(const RootTableT &o) - : far_vector(o.far_vector), - a(o.a), - far_string(o.far_string), - big_bool_vector(o.big_bool_vector), - big_vector(o.big_vector), - near_string(o.near_string), - nested_root(o.nested_root), - far_struct_vector(o.far_struct_vector), - big_struct_vector(o.big_struct_vector), - forced_aligned_vector(o.forced_aligned_vector) { - many_vectors.reserve(o.many_vectors.size()); - for (const auto &many_vectors_ : o.many_vectors) { many_vectors.emplace_back((many_vectors_) ? new WrapperTableT(*many_vectors_) : nullptr); } -} - -inline RootTableT &RootTableT::operator=(RootTableT o) FLATBUFFERS_NOEXCEPT { - std::swap(far_vector, o.far_vector); - std::swap(a, o.a); - std::swap(far_string, o.far_string); - std::swap(big_bool_vector, o.big_bool_vector); - std::swap(big_vector, o.big_vector); - std::swap(near_string, o.near_string); - std::swap(nested_root, o.nested_root); - std::swap(far_struct_vector, o.far_struct_vector); - std::swap(big_struct_vector, o.big_struct_vector); - std::swap(many_vectors, o.many_vectors); - std::swap(forced_aligned_vector, o.forced_aligned_vector); - return *this; -} - -inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<RootTableT>(new RootTableT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = far_vector(); if (_e) { _o->far_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->far_vector.begin()); } } - { auto _e = a(); _o->a = _e; } - { auto _e = far_string(); if (_e) _o->far_string = _e->str(); } - { auto _e = big_bool_vector(); if (_e) { _o->big_bool_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_bool_vector.begin()); } } - { auto _e = big_vector(); if (_e) { _o->big_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_vector.begin()); } } - { auto _e = near_string(); if (_e) _o->near_string = _e->str(); } - { auto _e = nested_root(); if (_e) { _o->nested_root.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->nested_root.begin()); } } - { auto _e = far_struct_vector(); if (_e) { _o->far_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->far_struct_vector[_i] = *_e->Get(_i); } } else { _o->far_struct_vector.resize(0); } } - { auto _e = big_struct_vector(); if (_e) { _o->big_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset64_t _i = 0; _i < _e->size(); _i++) { _o->big_struct_vector[_i] = *_e->Get(_i); } } else { _o->big_struct_vector.resize(0); } } - { auto _e = many_vectors(); if (_e) { _o->many_vectors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->many_vectors[_i]) { _e->Get(_i)->UnPackTo(_o->many_vectors[_i].get(), _resolver); } else { _o->many_vectors[_i] = std::unique_ptr<WrapperTableT>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->many_vectors.resize(0); } } - { auto _e = forced_aligned_vector(); if (_e) { _o->forced_aligned_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->forced_aligned_vector.begin()); } } -} - -inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return RootTable::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _far_vector = _o->far_vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->far_vector) : 0; - auto _a = _o->a; - auto _far_string = _o->far_string.empty() ? 0 : _fbb.CreateString<::flatbuffers::Offset64>(_o->far_string); - auto _big_bool_vector = _o->big_bool_vector.size() ? _fbb.CreateVector64(_o->big_bool_vector) : 0; - auto _big_vector = _o->big_vector.size() ? _fbb.CreateVector64(_o->big_vector) : 0; - auto _near_string = _o->near_string.empty() ? 0 : _fbb.CreateString(_o->near_string); - auto _nested_root = _o->nested_root.size() ? _fbb.CreateVector64(_o->nested_root) : 0; - auto _far_struct_vector = _o->far_struct_vector.size() ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(_o->far_struct_vector) : 0; - auto _big_struct_vector = _o->big_struct_vector.size() ? _fbb.CreateVectorOfStructs64(_o->big_struct_vector) : 0; - auto _many_vectors = _o->many_vectors.size() ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>> (_o->many_vectors.size(), [](size_t i, _VectorArgs *__va) { return CreateWrapperTable(*__va->__fbb, __va->__o->many_vectors[i].get(), __va->__rehasher); }, &_va ) : 0; - _fbb.ForceVectorAlignment64(_o->forced_aligned_vector.size(), sizeof(uint8_t), 32); - auto _forced_aligned_vector = _o->forced_aligned_vector.size() ? _fbb.CreateVector64(_o->forced_aligned_vector) : 0; - return CreateRootTable( - _fbb, - _far_vector, - _a, - _far_string, - _big_bool_vector, - _big_vector, - _near_string, - _nested_root, - _far_struct_vector, - _big_struct_vector, - _many_vectors, - _forced_aligned_vector); -} - -inline const ::flatbuffers::TypeTable *LeafStructTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 0, -1 } - }; - static const int64_t values[] = { 0, 8, 16 }; - static const char * const names[] = { - "a", - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *WrapperTableTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_CHAR, 1, -1 } - }; - static const char * const names[] = { - "vector" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *RootTableTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_UCHAR, 1, -1 }, - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_STRING, 0, -1 }, - { ::flatbuffers::ET_UCHAR, 1, -1 }, - { ::flatbuffers::ET_UCHAR, 1, -1 }, - { ::flatbuffers::ET_STRING, 0, -1 }, - { ::flatbuffers::ET_UCHAR, 1, -1 }, - { ::flatbuffers::ET_SEQUENCE, 1, 0 }, - { ::flatbuffers::ET_SEQUENCE, 1, 0 }, - { ::flatbuffers::ET_SEQUENCE, 1, 1 }, - { ::flatbuffers::ET_UCHAR, 1, -1 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - LeafStructTypeTable, - WrapperTableTypeTable - }; - static const char * const names[] = { - "far_vector", - "a", - "far_string", - "big_bool_vector", - "big_vector", - "near_string", - "nested_root", - "far_struct_vector", - "big_struct_vector", - "many_vectors", - "forced_aligned_vector" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const RootTable *GetRootTable(const void *buf) { - return ::flatbuffers::GetRoot<RootTable>(buf); -} - -inline const RootTable *GetSizePrefixedRootTable(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf); -} - -inline RootTable *GetMutableRootTable(void *buf) { - return ::flatbuffers::GetMutableRoot<RootTable>(buf); -} - -inline RootTable *GetMutableSizePrefixedRootTable(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf); -} - -template <bool B = false> -inline bool VerifyRootTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<RootTable>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedRootTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<RootTable,::flatbuffers::uoffset64_t>(nullptr); -} - -inline void FinishRootTableBuffer( - ::flatbuffers::FlatBufferBuilder64 &fbb, - ::flatbuffers::Offset<RootTable> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedRootTableBuffer( - ::flatbuffers::FlatBufferBuilder64 &fbb, - ::flatbuffers::Offset<RootTable> root) { - fbb.FinishSizePrefixed(root); -} - -inline std::unique_ptr<RootTableT> UnPackRootTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<RootTableT>(GetRootTable(buf)->UnPack(res)); -} - -inline std::unique_ptr<RootTableT> UnPackSizePrefixedRootTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res)); -} - -#endif // FLATBUFFERS_GENERATED_TEST64BIT_H_
diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel index 6a7373a..38345a0 100644 --- a/tests/BUILD.bazel +++ b/tests/BUILD.bazel
@@ -24,21 +24,12 @@ name = "flatbuffers_test", testonly = 1, srcs = [ - "64bit/evolution/v1_generated.h", - "64bit/evolution/v2_generated.h", - "64bit/offset64_test.cpp", - "64bit/offset64_test.h", - "64bit/test_64bit_bfbs_generated.h", - "64bit/test_64bit_generated.h", "alignment_test.cpp", "alignment_test.h", - "alignment_test_generated.h", "default_vectors_strings_test.cpp", "default_vectors_strings_test.h", "evolution_test.cpp", "evolution_test.h", - "evolution_test/evolution_v1_generated.h", - "evolution_test/evolution_v2_generated.h", "flexbuffers_test.cpp", "flexbuffers_test.h", "fuzz_test.cpp", @@ -46,18 +37,13 @@ "is_quiet_nan.h", "json_test.cpp", "json_test.h", - "key_field/key_field_sample_generated.h", "key_field_test.cpp", "key_field_test.h", "monster_test.cpp", "monster_test.h", "monster_test_bfbs_generated.h", - "namespace_test/namespace_test1_generated.h", - "namespace_test/namespace_test2_generated.h", - "native_inline_table_test_generated.h", "native_type_test_impl.cpp", "native_type_test_impl.h", - "optional_scalars_generated.h", "optional_scalars_test.cpp", "optional_scalars_test.h", "parser_test.cpp", @@ -71,13 +57,10 @@ "test_assert.h", "test_builder.cpp", "test_builder.h", - "union_underlying_type_test_generated.h", - "union_vector/union_vector_generated.h", "util_test.cpp", "util_test.h", - "vector_table_naked_ptr/vector_table_naked_ptr_generated.h", - "vector_table_naked_ptr_test.h", "vector_table_naked_ptr_test.cpp", + "vector_table_naked_ptr_test.h", ], copts = [ "-DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE", @@ -87,13 +70,8 @@ ":arrays_test.bfbs", ":arrays_test.fbs", ":arrays_test.golden", - ":evolution_test/evolution_v1.fbs", - ":evolution_test/evolution_v1.json", - ":evolution_test/evolution_v2.fbs", - ":evolution_test/evolution_v2.json", ":include_test/include_test1.fbs", ":include_test/sub/include_test2.fbs", - ":key_field/key_field_sample.fbs", ":monster_extra.fbs", ":monster_test.bfbs", ":monster_test.fbs", @@ -104,7 +82,6 @@ ":name_clash_test/invalid_test2.fbs", ":name_clash_test/valid_test1.fbs", ":name_clash_test/valid_test2.fbs", - ":native_type_test.fbs", ":optional_scalars.fbs", ":optional_scalars.json", ":optional_scalars_defaults.json", @@ -126,8 +103,8 @@ ":prototest/twice-id.proto", ":prototest/use-reserved-id.proto", ":unicode_test.json", - ":union_vector/union_vector.fbs", - ":union_vector/union_vector.json", + "//tests/evolution_test:test_data", + "//tests/union_vector:test_data", ], includes = [ "", @@ -139,9 +116,18 @@ ":default_vectors_strings_test_cc_fbs", ":monster_extra_cc_fbs", ":monster_test_cc_fbs", + ":native_inline_table_test_cc_fbs", ":native_type_test_cc_fbs", + ":optional_scalars_cc_fbs", + ":union_underlying_type_test_cc_fbs", + ":vector_table_naked_ptr_cc_fbs", "//:flatbuffers", "//src:generate_fbs", + "//tests/64bit:offset64_test", + "//tests/evolution_test:evolution_v1_cc_fbs", + "//tests/evolution_test:evolution_v2_cc_fbs", + "//tests/key_field:key_field_sample_cc_fbs", + "//tests/union_vector:union_vector_cc_fbs", ], ) @@ -151,7 +137,10 @@ name = "test_assert", srcs = ["test_assert.cpp"], hdrs = ["test_assert.h"], - visibility = ["//grpc/tests:__subpackages__"], + visibility = [ + "//grpc/tests:__subpackages__", + "//tests:__subpackages__", + ], deps = ["//:flatbuffers"], ) @@ -245,11 +234,20 @@ flatbuffer_cc_library( name = "monster_extra_cc_fbs", srcs = ["monster_extra.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], ) flatbuffer_cc_library( name = "arrays_test_cc_fbs", srcs = ["arrays_test.fbs"], + filename_suffix = ".fbs", flatc_args = [ "--gen-object-api", "--gen-compare", @@ -258,27 +256,26 @@ "--reflect-names", "--cpp-ptr-type flatbuffers::unique_ptr", "--scoped-enums", + "--filename-suffix .fbs", ], ) flatbuffer_cc_library( name = "native_type_test_cc_fbs", srcs = ["native_type_test.fbs"], + filename_suffix = ".fbs", flatc_args = [ "--gen-object-api", "--gen-mutable", "--cpp-ptr-type flatbuffers::unique_ptr", + "--filename-suffix .fbs", ], ) flatbuffer_cc_library( name = "alignment_test_cc_fbs", srcs = ["alignment_test.fbs"], -) - -flatbuffer_cc_library( - name = "default_vectors_strings_test_cc_fbs", - srcs = ["default_vectors_strings_test.fbs"], + filename_suffix = ".fbs", flatc_args = [ "--gen-compare", "--gen-mutable", @@ -286,5 +283,71 @@ "--reflect-names", "--filename-suffix .fbs", ], - filename_suffix = ".fbs" +) + +flatbuffer_cc_library( + name = "default_vectors_strings_test_cc_fbs", + srcs = ["default_vectors_strings_test.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +) + +flatbuffer_cc_library( + name = "native_inline_table_test_cc_fbs", + srcs = ["native_inline_table_test.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +) + +flatbuffer_cc_library( + name = "optional_scalars_cc_fbs", + srcs = ["optional_scalars.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +) + +flatbuffer_cc_library( + name = "union_underlying_type_test_cc_fbs", + srcs = ["union_underlying_type_test.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + "--scoped-enums", + ], +) + +flatbuffer_cc_library( + name = "vector_table_naked_ptr_cc_fbs", + srcs = ["vector_table_naked_ptr.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + "--cpp-ptr-type naked", + ], )
diff --git a/tests/alignment_test.cpp b/tests/alignment_test.cpp index cff0d0f..6c88f55 100644 --- a/tests/alignment_test.cpp +++ b/tests/alignment_test.cpp
@@ -3,7 +3,7 @@ #include "flatbuffers/flatbuffer_builder.h" #include "flatbuffers/util.h" #include "test_assert.h" -#include "tests/alignment_test_generated.h" +#include "tests/alignment_test.fbs.h" namespace flatbuffers { namespace tests {
diff --git a/tests/cpp17/generated_cpp17/optional_scalars2_generated.h b/tests/cpp17/generated_cpp17/optional_scalars2_generated.h deleted file mode 100644 index 07bcabd..0000000 --- a/tests/cpp17/generated_cpp17/optional_scalars2_generated.h +++ /dev/null
@@ -1,932 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -#ifndef FLATBUFFERS_GENERATED_OPTIONALSCALARS2_OPTIONAL_SCALARS_H_ -#define FLATBUFFERS_GENERATED_OPTIONALSCALARS2_OPTIONAL_SCALARS_H_ - -#include "flatbuffers/flatbuffers.h" - -namespace optional_scalars { - -struct ScalarStuff; -struct ScalarStuffBuilder; -struct ScalarStuffT; - -inline const flatbuffers::TypeTable* ScalarStuffTypeTable(); - -enum class OptionalByte : int8_t { - None = 0, - One = 1, - Two = 2, - MIN = None, - MAX = Two -}; - -inline const OptionalByte (&EnumValuesOptionalByte())[3] { - static const OptionalByte values[] = {OptionalByte::None, OptionalByte::One, - OptionalByte::Two}; - return values; -} - -inline const char* const* EnumNamesOptionalByte() { - static const char* const names[4] = {"None", "One", "Two", nullptr}; - return names; -} - -inline const char* EnumNameOptionalByte(OptionalByte e) { - if (flatbuffers::IsOutRange(e, OptionalByte::None, OptionalByte::Two)) - return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesOptionalByte()[index]; -} - -struct ScalarStuffT : public flatbuffers::NativeTable { - typedef ScalarStuff TableType; - int8_t just_i8 = 0; - flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt; - int8_t default_i8 = 42; - uint8_t just_u8 = 0; - flatbuffers::Optional<uint8_t> maybe_u8 = flatbuffers::nullopt; - uint8_t default_u8 = 42; - int16_t just_i16 = 0; - flatbuffers::Optional<int16_t> maybe_i16 = flatbuffers::nullopt; - int16_t default_i16 = 42; - uint16_t just_u16 = 0; - flatbuffers::Optional<uint16_t> maybe_u16 = flatbuffers::nullopt; - uint16_t default_u16 = 42; - int32_t just_i32 = 0; - flatbuffers::Optional<int32_t> maybe_i32 = flatbuffers::nullopt; - int32_t default_i32 = 42; - uint32_t just_u32 = 0; - flatbuffers::Optional<uint32_t> maybe_u32 = flatbuffers::nullopt; - uint32_t default_u32 = 42; - int64_t just_i64 = 0; - flatbuffers::Optional<int64_t> maybe_i64 = flatbuffers::nullopt; - int64_t default_i64 = 42LL; - uint64_t just_u64 = 0; - flatbuffers::Optional<uint64_t> maybe_u64 = flatbuffers::nullopt; - uint64_t default_u64 = 42ULL; - float just_f32 = 0.0f; - flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt; - float default_f32 = 42.0f; - double just_f64 = 0.0; - flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt; - double default_f64 = 42.0; - bool just_bool = false; - flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt; - bool default_bool = true; - optional_scalars::OptionalByte just_enum = - optional_scalars::OptionalByte::None; - flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = - flatbuffers::nullopt; - optional_scalars::OptionalByte default_enum = - optional_scalars::OptionalByte::One; -}; - -struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ScalarStuffT NativeTableType; - typedef ScalarStuffBuilder Builder; - struct Traits; - static const flatbuffers::TypeTable* MiniReflectTypeTable() { - return ScalarStuffTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_JUST_I8 = 4, - VT_MAYBE_I8 = 6, - VT_DEFAULT_I8 = 8, - VT_JUST_U8 = 10, - VT_MAYBE_U8 = 12, - VT_DEFAULT_U8 = 14, - VT_JUST_I16 = 16, - VT_MAYBE_I16 = 18, - VT_DEFAULT_I16 = 20, - VT_JUST_U16 = 22, - VT_MAYBE_U16 = 24, - VT_DEFAULT_U16 = 26, - VT_JUST_I32 = 28, - VT_MAYBE_I32 = 30, - VT_DEFAULT_I32 = 32, - VT_JUST_U32 = 34, - VT_MAYBE_U32 = 36, - VT_DEFAULT_U32 = 38, - VT_JUST_I64 = 40, - VT_MAYBE_I64 = 42, - VT_DEFAULT_I64 = 44, - VT_JUST_U64 = 46, - VT_MAYBE_U64 = 48, - VT_DEFAULT_U64 = 50, - VT_JUST_F32 = 52, - VT_MAYBE_F32 = 54, - VT_DEFAULT_F32 = 56, - VT_JUST_F64 = 58, - VT_MAYBE_F64 = 60, - VT_DEFAULT_F64 = 62, - VT_JUST_BOOL = 64, - VT_MAYBE_BOOL = 66, - VT_DEFAULT_BOOL = 68, - VT_JUST_ENUM = 70, - VT_MAYBE_ENUM = 72, - VT_DEFAULT_ENUM = 74 - }; - int8_t just_i8() const { return GetField<int8_t>(VT_JUST_I8, 0); } - bool mutate_just_i8(int8_t _just_i8) { - return SetField<int8_t>(VT_JUST_I8, _just_i8, 0); - } - flatbuffers::Optional<int8_t> maybe_i8() const { - return GetOptional<int8_t, int8_t>(VT_MAYBE_I8); - } - bool mutate_maybe_i8(int8_t _maybe_i8) { - return SetField<int8_t>(VT_MAYBE_I8, _maybe_i8); - } - int8_t default_i8() const { return GetField<int8_t>(VT_DEFAULT_I8, 42); } - bool mutate_default_i8(int8_t _default_i8) { - return SetField<int8_t>(VT_DEFAULT_I8, _default_i8, 42); - } - uint8_t just_u8() const { return GetField<uint8_t>(VT_JUST_U8, 0); } - bool mutate_just_u8(uint8_t _just_u8) { - return SetField<uint8_t>(VT_JUST_U8, _just_u8, 0); - } - flatbuffers::Optional<uint8_t> maybe_u8() const { - return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8); - } - bool mutate_maybe_u8(uint8_t _maybe_u8) { - return SetField<uint8_t>(VT_MAYBE_U8, _maybe_u8); - } - uint8_t default_u8() const { return GetField<uint8_t>(VT_DEFAULT_U8, 42); } - bool mutate_default_u8(uint8_t _default_u8) { - return SetField<uint8_t>(VT_DEFAULT_U8, _default_u8, 42); - } - int16_t just_i16() const { return GetField<int16_t>(VT_JUST_I16, 0); } - bool mutate_just_i16(int16_t _just_i16) { - return SetField<int16_t>(VT_JUST_I16, _just_i16, 0); - } - flatbuffers::Optional<int16_t> maybe_i16() const { - return GetOptional<int16_t, int16_t>(VT_MAYBE_I16); - } - bool mutate_maybe_i16(int16_t _maybe_i16) { - return SetField<int16_t>(VT_MAYBE_I16, _maybe_i16); - } - int16_t default_i16() const { return GetField<int16_t>(VT_DEFAULT_I16, 42); } - bool mutate_default_i16(int16_t _default_i16) { - return SetField<int16_t>(VT_DEFAULT_I16, _default_i16, 42); - } - uint16_t just_u16() const { return GetField<uint16_t>(VT_JUST_U16, 0); } - bool mutate_just_u16(uint16_t _just_u16) { - return SetField<uint16_t>(VT_JUST_U16, _just_u16, 0); - } - flatbuffers::Optional<uint16_t> maybe_u16() const { - return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16); - } - bool mutate_maybe_u16(uint16_t _maybe_u16) { - return SetField<uint16_t>(VT_MAYBE_U16, _maybe_u16); - } - uint16_t default_u16() const { - return GetField<uint16_t>(VT_DEFAULT_U16, 42); - } - bool mutate_default_u16(uint16_t _default_u16) { - return SetField<uint16_t>(VT_DEFAULT_U16, _default_u16, 42); - } - int32_t just_i32() const { return GetField<int32_t>(VT_JUST_I32, 0); } - bool mutate_just_i32(int32_t _just_i32) { - return SetField<int32_t>(VT_JUST_I32, _just_i32, 0); - } - flatbuffers::Optional<int32_t> maybe_i32() const { - return GetOptional<int32_t, int32_t>(VT_MAYBE_I32); - } - bool mutate_maybe_i32(int32_t _maybe_i32) { - return SetField<int32_t>(VT_MAYBE_I32, _maybe_i32); - } - int32_t default_i32() const { return GetField<int32_t>(VT_DEFAULT_I32, 42); } - bool mutate_default_i32(int32_t _default_i32) { - return SetField<int32_t>(VT_DEFAULT_I32, _default_i32, 42); - } - uint32_t just_u32() const { return GetField<uint32_t>(VT_JUST_U32, 0); } - bool mutate_just_u32(uint32_t _just_u32) { - return SetField<uint32_t>(VT_JUST_U32, _just_u32, 0); - } - flatbuffers::Optional<uint32_t> maybe_u32() const { - return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32); - } - bool mutate_maybe_u32(uint32_t _maybe_u32) { - return SetField<uint32_t>(VT_MAYBE_U32, _maybe_u32); - } - uint32_t default_u32() const { - return GetField<uint32_t>(VT_DEFAULT_U32, 42); - } - bool mutate_default_u32(uint32_t _default_u32) { - return SetField<uint32_t>(VT_DEFAULT_U32, _default_u32, 42); - } - int64_t just_i64() const { return GetField<int64_t>(VT_JUST_I64, 0); } - bool mutate_just_i64(int64_t _just_i64) { - return SetField<int64_t>(VT_JUST_I64, _just_i64, 0); - } - flatbuffers::Optional<int64_t> maybe_i64() const { - return GetOptional<int64_t, int64_t>(VT_MAYBE_I64); - } - bool mutate_maybe_i64(int64_t _maybe_i64) { - return SetField<int64_t>(VT_MAYBE_I64, _maybe_i64); - } - int64_t default_i64() const { - return GetField<int64_t>(VT_DEFAULT_I64, 42LL); - } - bool mutate_default_i64(int64_t _default_i64) { - return SetField<int64_t>(VT_DEFAULT_I64, _default_i64, 42LL); - } - uint64_t just_u64() const { return GetField<uint64_t>(VT_JUST_U64, 0); } - bool mutate_just_u64(uint64_t _just_u64) { - return SetField<uint64_t>(VT_JUST_U64, _just_u64, 0); - } - flatbuffers::Optional<uint64_t> maybe_u64() const { - return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64); - } - bool mutate_maybe_u64(uint64_t _maybe_u64) { - return SetField<uint64_t>(VT_MAYBE_U64, _maybe_u64); - } - uint64_t default_u64() const { - return GetField<uint64_t>(VT_DEFAULT_U64, 42ULL); - } - bool mutate_default_u64(uint64_t _default_u64) { - return SetField<uint64_t>(VT_DEFAULT_U64, _default_u64, 42ULL); - } - float just_f32() const { return GetField<float>(VT_JUST_F32, 0.0f); } - bool mutate_just_f32(float _just_f32) { - return SetField<float>(VT_JUST_F32, _just_f32, 0.0f); - } - flatbuffers::Optional<float> maybe_f32() const { - return GetOptional<float, float>(VT_MAYBE_F32); - } - bool mutate_maybe_f32(float _maybe_f32) { - return SetField<float>(VT_MAYBE_F32, _maybe_f32); - } - float default_f32() const { return GetField<float>(VT_DEFAULT_F32, 42.0f); } - bool mutate_default_f32(float _default_f32) { - return SetField<float>(VT_DEFAULT_F32, _default_f32, 42.0f); - } - double just_f64() const { return GetField<double>(VT_JUST_F64, 0.0); } - bool mutate_just_f64(double _just_f64) { - return SetField<double>(VT_JUST_F64, _just_f64, 0.0); - } - flatbuffers::Optional<double> maybe_f64() const { - return GetOptional<double, double>(VT_MAYBE_F64); - } - bool mutate_maybe_f64(double _maybe_f64) { - return SetField<double>(VT_MAYBE_F64, _maybe_f64); - } - double default_f64() const { return GetField<double>(VT_DEFAULT_F64, 42.0); } - bool mutate_default_f64(double _default_f64) { - return SetField<double>(VT_DEFAULT_F64, _default_f64, 42.0); - } - bool just_bool() const { return GetField<uint8_t>(VT_JUST_BOOL, 0) != 0; } - bool mutate_just_bool(bool _just_bool) { - return SetField<uint8_t>(VT_JUST_BOOL, static_cast<uint8_t>(_just_bool), 0); - } - flatbuffers::Optional<bool> maybe_bool() const { - return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL); - } - bool mutate_maybe_bool(bool _maybe_bool) { - return SetField<uint8_t>(VT_MAYBE_BOOL, static_cast<uint8_t>(_maybe_bool)); - } - bool default_bool() const { - return GetField<uint8_t>(VT_DEFAULT_BOOL, 1) != 0; - } - bool mutate_default_bool(bool _default_bool) { - return SetField<uint8_t>(VT_DEFAULT_BOOL, - static_cast<uint8_t>(_default_bool), 1); - } - optional_scalars::OptionalByte just_enum() const { - return static_cast<optional_scalars::OptionalByte>( - GetField<int8_t>(VT_JUST_ENUM, 0)); - } - bool mutate_just_enum(optional_scalars::OptionalByte _just_enum) { - return SetField<int8_t>(VT_JUST_ENUM, static_cast<int8_t>(_just_enum), 0); - } - flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum() const { - return GetOptional<int8_t, optional_scalars::OptionalByte>(VT_MAYBE_ENUM); - } - bool mutate_maybe_enum(optional_scalars::OptionalByte _maybe_enum) { - return SetField<int8_t>(VT_MAYBE_ENUM, static_cast<int8_t>(_maybe_enum)); - } - optional_scalars::OptionalByte default_enum() const { - return static_cast<optional_scalars::OptionalByte>( - GetField<int8_t>(VT_DEFAULT_ENUM, 1)); - } - bool mutate_default_enum(optional_scalars::OptionalByte _default_enum) { - return SetField<int8_t>(VT_DEFAULT_ENUM, static_cast<int8_t>(_default_enum), - 1); - } - bool Verify(flatbuffers::Verifier& verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int8_t>(verifier, VT_JUST_I8) && - VerifyField<int8_t>(verifier, VT_MAYBE_I8) && - VerifyField<int8_t>(verifier, VT_DEFAULT_I8) && - VerifyField<uint8_t>(verifier, VT_JUST_U8) && - VerifyField<uint8_t>(verifier, VT_MAYBE_U8) && - VerifyField<uint8_t>(verifier, VT_DEFAULT_U8) && - VerifyField<int16_t>(verifier, VT_JUST_I16) && - VerifyField<int16_t>(verifier, VT_MAYBE_I16) && - VerifyField<int16_t>(verifier, VT_DEFAULT_I16) && - VerifyField<uint16_t>(verifier, VT_JUST_U16) && - VerifyField<uint16_t>(verifier, VT_MAYBE_U16) && - VerifyField<uint16_t>(verifier, VT_DEFAULT_U16) && - VerifyField<int32_t>(verifier, VT_JUST_I32) && - VerifyField<int32_t>(verifier, VT_MAYBE_I32) && - VerifyField<int32_t>(verifier, VT_DEFAULT_I32) && - VerifyField<uint32_t>(verifier, VT_JUST_U32) && - VerifyField<uint32_t>(verifier, VT_MAYBE_U32) && - VerifyField<uint32_t>(verifier, VT_DEFAULT_U32) && - VerifyField<int64_t>(verifier, VT_JUST_I64) && - VerifyField<int64_t>(verifier, VT_MAYBE_I64) && - VerifyField<int64_t>(verifier, VT_DEFAULT_I64) && - VerifyField<uint64_t>(verifier, VT_JUST_U64) && - VerifyField<uint64_t>(verifier, VT_MAYBE_U64) && - VerifyField<uint64_t>(verifier, VT_DEFAULT_U64) && - VerifyField<float>(verifier, VT_JUST_F32) && - VerifyField<float>(verifier, VT_MAYBE_F32) && - VerifyField<float>(verifier, VT_DEFAULT_F32) && - VerifyField<double>(verifier, VT_JUST_F64) && - VerifyField<double>(verifier, VT_MAYBE_F64) && - VerifyField<double>(verifier, VT_DEFAULT_F64) && - VerifyField<uint8_t>(verifier, VT_JUST_BOOL) && - VerifyField<uint8_t>(verifier, VT_MAYBE_BOOL) && - VerifyField<uint8_t>(verifier, VT_DEFAULT_BOOL) && - VerifyField<int8_t>(verifier, VT_JUST_ENUM) && - VerifyField<int8_t>(verifier, VT_MAYBE_ENUM) && - VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM) && - verifier.EndTable(); - } - ScalarStuffT* UnPack( - const flatbuffers::resolver_function_t* _resolver = nullptr) const; - void UnPackTo( - ScalarStuffT* _o, - const flatbuffers::resolver_function_t* _resolver = nullptr) const; - static flatbuffers::Offset<ScalarStuff> Pack( - flatbuffers::FlatBufferBuilder& _fbb, const ScalarStuffT* _o, - const flatbuffers::rehasher_function_t* _rehasher = nullptr); -}; - -struct ScalarStuffBuilder { - typedef ScalarStuff Table; - flatbuffers::FlatBufferBuilder& fbb_; - flatbuffers::uoffset_t start_; - void add_just_i8(int8_t just_i8) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_I8, just_i8, 0); - } - void add_maybe_i8(int8_t maybe_i8) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_MAYBE_I8, maybe_i8); - } - void add_default_i8(int8_t default_i8) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_I8, default_i8, 42); - } - void add_just_u8(uint8_t just_u8) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_JUST_U8, just_u8, 0); - } - void add_maybe_u8(uint8_t maybe_u8) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_MAYBE_U8, maybe_u8); - } - void add_default_u8(uint8_t default_u8) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_DEFAULT_U8, default_u8, 42); - } - void add_just_i16(int16_t just_i16) { - fbb_.AddElement<int16_t>(ScalarStuff::VT_JUST_I16, just_i16, 0); - } - void add_maybe_i16(int16_t maybe_i16) { - fbb_.AddElement<int16_t>(ScalarStuff::VT_MAYBE_I16, maybe_i16); - } - void add_default_i16(int16_t default_i16) { - fbb_.AddElement<int16_t>(ScalarStuff::VT_DEFAULT_I16, default_i16, 42); - } - void add_just_u16(uint16_t just_u16) { - fbb_.AddElement<uint16_t>(ScalarStuff::VT_JUST_U16, just_u16, 0); - } - void add_maybe_u16(uint16_t maybe_u16) { - fbb_.AddElement<uint16_t>(ScalarStuff::VT_MAYBE_U16, maybe_u16); - } - void add_default_u16(uint16_t default_u16) { - fbb_.AddElement<uint16_t>(ScalarStuff::VT_DEFAULT_U16, default_u16, 42); - } - void add_just_i32(int32_t just_i32) { - fbb_.AddElement<int32_t>(ScalarStuff::VT_JUST_I32, just_i32, 0); - } - void add_maybe_i32(int32_t maybe_i32) { - fbb_.AddElement<int32_t>(ScalarStuff::VT_MAYBE_I32, maybe_i32); - } - void add_default_i32(int32_t default_i32) { - fbb_.AddElement<int32_t>(ScalarStuff::VT_DEFAULT_I32, default_i32, 42); - } - void add_just_u32(uint32_t just_u32) { - fbb_.AddElement<uint32_t>(ScalarStuff::VT_JUST_U32, just_u32, 0); - } - void add_maybe_u32(uint32_t maybe_u32) { - fbb_.AddElement<uint32_t>(ScalarStuff::VT_MAYBE_U32, maybe_u32); - } - void add_default_u32(uint32_t default_u32) { - fbb_.AddElement<uint32_t>(ScalarStuff::VT_DEFAULT_U32, default_u32, 42); - } - void add_just_i64(int64_t just_i64) { - fbb_.AddElement<int64_t>(ScalarStuff::VT_JUST_I64, just_i64, 0); - } - void add_maybe_i64(int64_t maybe_i64) { - fbb_.AddElement<int64_t>(ScalarStuff::VT_MAYBE_I64, maybe_i64); - } - void add_default_i64(int64_t default_i64) { - fbb_.AddElement<int64_t>(ScalarStuff::VT_DEFAULT_I64, default_i64, 42LL); - } - void add_just_u64(uint64_t just_u64) { - fbb_.AddElement<uint64_t>(ScalarStuff::VT_JUST_U64, just_u64, 0); - } - void add_maybe_u64(uint64_t maybe_u64) { - fbb_.AddElement<uint64_t>(ScalarStuff::VT_MAYBE_U64, maybe_u64); - } - void add_default_u64(uint64_t default_u64) { - fbb_.AddElement<uint64_t>(ScalarStuff::VT_DEFAULT_U64, default_u64, 42ULL); - } - void add_just_f32(float just_f32) { - fbb_.AddElement<float>(ScalarStuff::VT_JUST_F32, just_f32, 0.0f); - } - void add_maybe_f32(float maybe_f32) { - fbb_.AddElement<float>(ScalarStuff::VT_MAYBE_F32, maybe_f32); - } - void add_default_f32(float default_f32) { - fbb_.AddElement<float>(ScalarStuff::VT_DEFAULT_F32, default_f32, 42.0f); - } - void add_just_f64(double just_f64) { - fbb_.AddElement<double>(ScalarStuff::VT_JUST_F64, just_f64, 0.0); - } - void add_maybe_f64(double maybe_f64) { - fbb_.AddElement<double>(ScalarStuff::VT_MAYBE_F64, maybe_f64); - } - void add_default_f64(double default_f64) { - fbb_.AddElement<double>(ScalarStuff::VT_DEFAULT_F64, default_f64, 42.0); - } - void add_just_bool(bool just_bool) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_JUST_BOOL, - static_cast<uint8_t>(just_bool), 0); - } - void add_maybe_bool(bool maybe_bool) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_MAYBE_BOOL, - static_cast<uint8_t>(maybe_bool)); - } - void add_default_bool(bool default_bool) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_DEFAULT_BOOL, - static_cast<uint8_t>(default_bool), 1); - } - void add_just_enum(optional_scalars::OptionalByte just_enum) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_ENUM, - static_cast<int8_t>(just_enum), 0); - } - void add_maybe_enum(optional_scalars::OptionalByte maybe_enum) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_MAYBE_ENUM, - static_cast<int8_t>(maybe_enum)); - } - void add_default_enum(optional_scalars::OptionalByte default_enum) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_ENUM, - static_cast<int8_t>(default_enum), 1); - } - explicit ScalarStuffBuilder(flatbuffers::FlatBufferBuilder& _fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset<ScalarStuff> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset<ScalarStuff>(end); - return o; - } -}; - -inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff( - flatbuffers::FlatBufferBuilder& _fbb, int8_t just_i8 = 0, - flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt, - int8_t default_i8 = 42, uint8_t just_u8 = 0, - flatbuffers::Optional<uint8_t> maybe_u8 = flatbuffers::nullopt, - uint8_t default_u8 = 42, int16_t just_i16 = 0, - flatbuffers::Optional<int16_t> maybe_i16 = flatbuffers::nullopt, - int16_t default_i16 = 42, uint16_t just_u16 = 0, - flatbuffers::Optional<uint16_t> maybe_u16 = flatbuffers::nullopt, - uint16_t default_u16 = 42, int32_t just_i32 = 0, - flatbuffers::Optional<int32_t> maybe_i32 = flatbuffers::nullopt, - int32_t default_i32 = 42, uint32_t just_u32 = 0, - flatbuffers::Optional<uint32_t> maybe_u32 = flatbuffers::nullopt, - uint32_t default_u32 = 42, int64_t just_i64 = 0, - flatbuffers::Optional<int64_t> maybe_i64 = flatbuffers::nullopt, - int64_t default_i64 = 42LL, uint64_t just_u64 = 0, - flatbuffers::Optional<uint64_t> maybe_u64 = flatbuffers::nullopt, - uint64_t default_u64 = 42ULL, float just_f32 = 0.0f, - flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt, - float default_f32 = 42.0f, double just_f64 = 0.0, - flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt, - double default_f64 = 42.0, bool just_bool = false, - flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt, - bool default_bool = true, - optional_scalars::OptionalByte just_enum = - optional_scalars::OptionalByte::None, - flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = - flatbuffers::nullopt, - optional_scalars::OptionalByte default_enum = - optional_scalars::OptionalByte::One) { - ScalarStuffBuilder builder_(_fbb); - builder_.add_default_f64(default_f64); - if (maybe_f64) { - builder_.add_maybe_f64(*maybe_f64); - } - builder_.add_just_f64(just_f64); - builder_.add_default_u64(default_u64); - if (maybe_u64) { - builder_.add_maybe_u64(*maybe_u64); - } - builder_.add_just_u64(just_u64); - builder_.add_default_i64(default_i64); - if (maybe_i64) { - builder_.add_maybe_i64(*maybe_i64); - } - builder_.add_just_i64(just_i64); - builder_.add_default_f32(default_f32); - if (maybe_f32) { - builder_.add_maybe_f32(*maybe_f32); - } - builder_.add_just_f32(just_f32); - builder_.add_default_u32(default_u32); - if (maybe_u32) { - builder_.add_maybe_u32(*maybe_u32); - } - builder_.add_just_u32(just_u32); - builder_.add_default_i32(default_i32); - if (maybe_i32) { - builder_.add_maybe_i32(*maybe_i32); - } - builder_.add_just_i32(just_i32); - builder_.add_default_u16(default_u16); - if (maybe_u16) { - builder_.add_maybe_u16(*maybe_u16); - } - builder_.add_just_u16(just_u16); - builder_.add_default_i16(default_i16); - if (maybe_i16) { - builder_.add_maybe_i16(*maybe_i16); - } - builder_.add_just_i16(just_i16); - builder_.add_default_enum(default_enum); - if (maybe_enum) { - builder_.add_maybe_enum(*maybe_enum); - } - builder_.add_just_enum(just_enum); - builder_.add_default_bool(default_bool); - if (maybe_bool) { - builder_.add_maybe_bool(*maybe_bool); - } - builder_.add_just_bool(just_bool); - builder_.add_default_u8(default_u8); - if (maybe_u8) { - builder_.add_maybe_u8(*maybe_u8); - } - builder_.add_just_u8(just_u8); - builder_.add_default_i8(default_i8); - if (maybe_i8) { - builder_.add_maybe_i8(*maybe_i8); - } - builder_.add_just_i8(just_i8); - return builder_.Finish(); -} - -struct ScalarStuff::Traits { - using type = ScalarStuff; - static auto constexpr Create = CreateScalarStuff; -}; - -flatbuffers::Offset<ScalarStuff> CreateScalarStuff( - flatbuffers::FlatBufferBuilder& _fbb, const ScalarStuffT* _o, - const flatbuffers::rehasher_function_t* _rehasher = nullptr); - -inline ScalarStuffT* ScalarStuff::UnPack( - const flatbuffers::resolver_function_t* _resolver) const { - auto _o = std::make_unique<ScalarStuffT>(); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void ScalarStuff::UnPackTo( - ScalarStuffT* _o, const flatbuffers::resolver_function_t* _resolver) const { - (void)_o; - (void)_resolver; - { - auto _e = just_i8(); - _o->just_i8 = _e; - } - { - auto _e = maybe_i8(); - _o->maybe_i8 = _e; - } - { - auto _e = default_i8(); - _o->default_i8 = _e; - } - { - auto _e = just_u8(); - _o->just_u8 = _e; - } - { - auto _e = maybe_u8(); - _o->maybe_u8 = _e; - } - { - auto _e = default_u8(); - _o->default_u8 = _e; - } - { - auto _e = just_i16(); - _o->just_i16 = _e; - } - { - auto _e = maybe_i16(); - _o->maybe_i16 = _e; - } - { - auto _e = default_i16(); - _o->default_i16 = _e; - } - { - auto _e = just_u16(); - _o->just_u16 = _e; - } - { - auto _e = maybe_u16(); - _o->maybe_u16 = _e; - } - { - auto _e = default_u16(); - _o->default_u16 = _e; - } - { - auto _e = just_i32(); - _o->just_i32 = _e; - } - { - auto _e = maybe_i32(); - _o->maybe_i32 = _e; - } - { - auto _e = default_i32(); - _o->default_i32 = _e; - } - { - auto _e = just_u32(); - _o->just_u32 = _e; - } - { - auto _e = maybe_u32(); - _o->maybe_u32 = _e; - } - { - auto _e = default_u32(); - _o->default_u32 = _e; - } - { - auto _e = just_i64(); - _o->just_i64 = _e; - } - { - auto _e = maybe_i64(); - _o->maybe_i64 = _e; - } - { - auto _e = default_i64(); - _o->default_i64 = _e; - } - { - auto _e = just_u64(); - _o->just_u64 = _e; - } - { - auto _e = maybe_u64(); - _o->maybe_u64 = _e; - } - { - auto _e = default_u64(); - _o->default_u64 = _e; - } - { - auto _e = just_f32(); - _o->just_f32 = _e; - } - { - auto _e = maybe_f32(); - _o->maybe_f32 = _e; - } - { - auto _e = default_f32(); - _o->default_f32 = _e; - } - { - auto _e = just_f64(); - _o->just_f64 = _e; - } - { - auto _e = maybe_f64(); - _o->maybe_f64 = _e; - } - { - auto _e = default_f64(); - _o->default_f64 = _e; - } - { - auto _e = just_bool(); - _o->just_bool = _e; - } - { - auto _e = maybe_bool(); - _o->maybe_bool = _e; - } - { - auto _e = default_bool(); - _o->default_bool = _e; - } - { - auto _e = just_enum(); - _o->just_enum = _e; - } - { - auto _e = maybe_enum(); - _o->maybe_enum = _e; - } - { - auto _e = default_enum(); - _o->default_enum = _e; - } -} - -inline flatbuffers::Offset<ScalarStuff> ScalarStuff::Pack( - flatbuffers::FlatBufferBuilder& _fbb, const ScalarStuffT* _o, - const flatbuffers::rehasher_function_t* _rehasher) { - return CreateScalarStuff(_fbb, _o, _rehasher); -} - -inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff( - flatbuffers::FlatBufferBuilder& _fbb, const ScalarStuffT* _o, - const flatbuffers::rehasher_function_t* _rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { - flatbuffers::FlatBufferBuilder* __fbb; - const ScalarStuffT* __o; - const flatbuffers::rehasher_function_t* __rehasher; - } _va = {&_fbb, _o, _rehasher}; - (void)_va; - auto _just_i8 = _o->just_i8; - auto _maybe_i8 = _o->maybe_i8; - auto _default_i8 = _o->default_i8; - auto _just_u8 = _o->just_u8; - auto _maybe_u8 = _o->maybe_u8; - auto _default_u8 = _o->default_u8; - auto _just_i16 = _o->just_i16; - auto _maybe_i16 = _o->maybe_i16; - auto _default_i16 = _o->default_i16; - auto _just_u16 = _o->just_u16; - auto _maybe_u16 = _o->maybe_u16; - auto _default_u16 = _o->default_u16; - auto _just_i32 = _o->just_i32; - auto _maybe_i32 = _o->maybe_i32; - auto _default_i32 = _o->default_i32; - auto _just_u32 = _o->just_u32; - auto _maybe_u32 = _o->maybe_u32; - auto _default_u32 = _o->default_u32; - auto _just_i64 = _o->just_i64; - auto _maybe_i64 = _o->maybe_i64; - auto _default_i64 = _o->default_i64; - auto _just_u64 = _o->just_u64; - auto _maybe_u64 = _o->maybe_u64; - auto _default_u64 = _o->default_u64; - auto _just_f32 = _o->just_f32; - auto _maybe_f32 = _o->maybe_f32; - auto _default_f32 = _o->default_f32; - auto _just_f64 = _o->just_f64; - auto _maybe_f64 = _o->maybe_f64; - auto _default_f64 = _o->default_f64; - auto _just_bool = _o->just_bool; - auto _maybe_bool = _o->maybe_bool; - auto _default_bool = _o->default_bool; - auto _just_enum = _o->just_enum; - auto _maybe_enum = _o->maybe_enum; - auto _default_enum = _o->default_enum; - return optional_scalars::CreateScalarStuff( - _fbb, _just_i8, _maybe_i8, _default_i8, _just_u8, _maybe_u8, _default_u8, - _just_i16, _maybe_i16, _default_i16, _just_u16, _maybe_u16, _default_u16, - _just_i32, _maybe_i32, _default_i32, _just_u32, _maybe_u32, _default_u32, - _just_i64, _maybe_i64, _default_i64, _just_u64, _maybe_u64, _default_u64, - _just_f32, _maybe_f32, _default_f32, _just_f64, _maybe_f64, _default_f64, - _just_bool, _maybe_bool, _default_bool, _just_enum, _maybe_enum, - _default_enum); -} - -inline const flatbuffers::TypeTable* OptionalByteTypeTable() { - static const flatbuffers::TypeCode type_codes[] = { - {flatbuffers::ET_CHAR, 0, 0}, - {flatbuffers::ET_CHAR, 0, 0}, - {flatbuffers::ET_CHAR, 0, 0}}; - static const flatbuffers::TypeFunction type_refs[] = { - optional_scalars::OptionalByteTypeTable}; - static const char* const names[] = {"None", "One", "Two"}; - static const flatbuffers::TypeTable tt = { - flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names}; - return &tt; -} - -inline const flatbuffers::TypeTable* ScalarStuffTypeTable() { - static const flatbuffers::TypeCode type_codes[] = { - {flatbuffers::ET_CHAR, 0, -1}, {flatbuffers::ET_CHAR, 0, -1}, - {flatbuffers::ET_CHAR, 0, -1}, {flatbuffers::ET_UCHAR, 0, -1}, - {flatbuffers::ET_UCHAR, 0, -1}, {flatbuffers::ET_UCHAR, 0, -1}, - {flatbuffers::ET_SHORT, 0, -1}, {flatbuffers::ET_SHORT, 0, -1}, - {flatbuffers::ET_SHORT, 0, -1}, {flatbuffers::ET_USHORT, 0, -1}, - {flatbuffers::ET_USHORT, 0, -1}, {flatbuffers::ET_USHORT, 0, -1}, - {flatbuffers::ET_INT, 0, -1}, {flatbuffers::ET_INT, 0, -1}, - {flatbuffers::ET_INT, 0, -1}, {flatbuffers::ET_UINT, 0, -1}, - {flatbuffers::ET_UINT, 0, -1}, {flatbuffers::ET_UINT, 0, -1}, - {flatbuffers::ET_LONG, 0, -1}, {flatbuffers::ET_LONG, 0, -1}, - {flatbuffers::ET_LONG, 0, -1}, {flatbuffers::ET_ULONG, 0, -1}, - {flatbuffers::ET_ULONG, 0, -1}, {flatbuffers::ET_ULONG, 0, -1}, - {flatbuffers::ET_FLOAT, 0, -1}, {flatbuffers::ET_FLOAT, 0, -1}, - {flatbuffers::ET_FLOAT, 0, -1}, {flatbuffers::ET_DOUBLE, 0, -1}, - {flatbuffers::ET_DOUBLE, 0, -1}, {flatbuffers::ET_DOUBLE, 0, -1}, - {flatbuffers::ET_BOOL, 0, -1}, {flatbuffers::ET_BOOL, 0, -1}, - {flatbuffers::ET_BOOL, 0, -1}, {flatbuffers::ET_CHAR, 0, 0}, - {flatbuffers::ET_CHAR, 0, 0}, {flatbuffers::ET_CHAR, 0, 0}}; - static const flatbuffers::TypeFunction type_refs[] = { - optional_scalars::OptionalByteTypeTable}; - static const char* const names[] = { - "just_i8", "maybe_i8", "default_i8", "just_u8", - "maybe_u8", "default_u8", "just_i16", "maybe_i16", - "default_i16", "just_u16", "maybe_u16", "default_u16", - "just_i32", "maybe_i32", "default_i32", "just_u32", - "maybe_u32", "default_u32", "just_i64", "maybe_i64", - "default_i64", "just_u64", "maybe_u64", "default_u64", - "just_f32", "maybe_f32", "default_f32", "just_f64", - "maybe_f64", "default_f64", "just_bool", "maybe_bool", - "default_bool", "just_enum", "maybe_enum", "default_enum"}; - static const flatbuffers::TypeTable tt = {flatbuffers::ST_TABLE, - 36, - type_codes, - type_refs, - nullptr, - nullptr, - names}; - return &tt; -} - -inline const optional_scalars::ScalarStuff* GetScalarStuff(const void* buf) { - return flatbuffers::GetRoot<optional_scalars::ScalarStuff>(buf); -} - -inline const optional_scalars::ScalarStuff* GetSizePrefixedScalarStuff( - const void* buf) { - return flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf); -} - -inline ScalarStuff* GetMutableScalarStuff(void* buf) { - return flatbuffers::GetMutableRoot<ScalarStuff>(buf); -} - -inline const char* ScalarStuffIdentifier() { return "NULL"; } - -inline bool ScalarStuffBufferHasIdentifier(const void* buf) { - return flatbuffers::BufferHasIdentifier(buf, ScalarStuffIdentifier()); -} - -inline bool VerifyScalarStuffBuffer(flatbuffers::Verifier& verifier) { - return verifier.VerifyBuffer<optional_scalars::ScalarStuff>( - ScalarStuffIdentifier()); -} - -inline bool VerifySizePrefixedScalarStuffBuffer( - flatbuffers::Verifier& verifier) { - return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>( - ScalarStuffIdentifier()); -} - -inline const char* ScalarStuffExtension() { return "mon"; } - -inline void FinishScalarStuffBuffer( - flatbuffers::FlatBufferBuilder& fbb, - flatbuffers::Offset<optional_scalars::ScalarStuff> root) { - fbb.Finish(root, ScalarStuffIdentifier()); -} - -inline void FinishSizePrefixedScalarStuffBuffer( - flatbuffers::FlatBufferBuilder& fbb, - flatbuffers::Offset<optional_scalars::ScalarStuff> root) { - fbb.FinishSizePrefixed(root, ScalarStuffIdentifier()); -} - -inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff( - const void* buf, const flatbuffers::resolver_function_t* res = nullptr) { - return std::unique_ptr<optional_scalars::ScalarStuffT>( - GetScalarStuff(buf)->UnPack(res)); -} - -inline std::unique_ptr<optional_scalars::ScalarStuffT> -UnPackSizePrefixedScalarStuff( - const void* buf, const flatbuffers::resolver_function_t* res = nullptr) { - return std::unique_ptr<optional_scalars::ScalarStuffT>( - GetSizePrefixedScalarStuff(buf)->UnPack(res)); -} - -} // namespace optional_scalars - -#endif // FLATBUFFERS_GENERATED_OPTIONALSCALARS2_OPTIONAL_SCALARS_H_
diff --git a/tests/cpp17/test_cpp17.cpp b/tests/cpp17/test_cpp17.cpp index 60b11a1..3cf9231 100644 --- a/tests/cpp17/test_cpp17.cpp +++ b/tests/cpp17/test_cpp17.cpp
@@ -31,14 +31,14 @@ // Embed generated code into an isolated namespace. namespace cpp17 { -#include "generated_cpp17/monster_test_generated.h" -#include "generated_cpp17/optional_scalars_generated.h" -#include "generated_cpp17/union_vector_generated.h" +#include "tests/cpp17/generated_cpp17/monster_test_generated.h" +#include "tests/cpp17/generated_cpp17/optional_scalars_generated.h" +#include "tests/cpp17/generated_cpp17/union_vector_generated.h" } // namespace cpp17 namespace cpp11 { -#include "../monster_test_generated.h" -#include "../optional_scalars_generated.h" +#include "tests/monster_test_generated.h" +#include "tests/optional_scalars.fbs.h" } // namespace cpp11 using ::cpp17::MyGame::Example::Monster;
diff --git a/tests/evolution_test.cpp b/tests/evolution_test.cpp index 7899278..da6cdbc 100644 --- a/tests/evolution_test.cpp +++ b/tests/evolution_test.cpp
@@ -1,7 +1,7 @@ #include "evolution_test.h" -#include "evolution_test/evolution_v1_generated.h" -#include "evolution_test/evolution_v2_generated.h" +#include "evolution_test/evolution_v1.fbs.h" +#include "evolution_test/evolution_v2.fbs.h" #include "flatbuffers/idl.h" #include "test_assert.h"
diff --git a/tests/evolution_test/BUILD.bazel b/tests/evolution_test/BUILD.bazel new file mode 100644 index 0000000..da6ce5d --- /dev/null +++ b/tests/evolution_test/BUILD.bazel
@@ -0,0 +1,42 @@ +load("//:build_defs.bzl", "flatbuffer_cc_library") + +package(default_visibility = ["//visibility:public"]) + +flatbuffer_cc_library( + name = "evolution_v1_cc_fbs", + srcs = ["evolution_v1.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + "--scoped-enums", + ], +) + +flatbuffer_cc_library( + name = "evolution_v2_cc_fbs", + srcs = ["evolution_v2.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + "--scoped-enums", + ], +) + +# Data needed by evolution_test.cpp to read at runtime. +filegroup( + name = "test_data", + srcs = [ + "evolution_v1.fbs", + "evolution_v1.json", + "evolution_v2.fbs", + "evolution_v2.json", + ], +)
diff --git a/tests/evolution_test/evolution_v1_generated.h b/tests/evolution_test/evolution_v1_generated.h deleted file mode 100644 index 07216c5..0000000 --- a/tests/evolution_test/evolution_v1_generated.h +++ /dev/null
@@ -1,533 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_EVOLUTIONV1_EVOLUTION_V1_H_ -#define FLATBUFFERS_GENERATED_EVOLUTIONV1_EVOLUTION_V1_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace Evolution { -namespace V1 { - -struct TableA; -struct TableABuilder; - -struct TableB; -struct TableBBuilder; - -struct Struct; - -struct Root; -struct RootBuilder; - -enum class Enum : int8_t { - King = 0, - Queen = 1, - MIN = King, - MAX = Queen -}; - -inline const Enum (&EnumValuesEnum())[2] { - static const Enum values[] = { - Enum::King, - Enum::Queen - }; - return values; -} - -inline const char * const *EnumNamesEnum() { - static const char * const names[3] = { - "King", - "Queen", - nullptr - }; - return names; -} - -inline const char *EnumNameEnum(Enum e) { - if (::flatbuffers::IsOutRange(e, Enum::King, Enum::Queen)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesEnum()[index]; -} - -enum class Union : uint8_t { - NONE = 0, - TableA = 1, - TableB = 2, - MIN = NONE, - MAX = TableB -}; - -inline const Union (&EnumValuesUnion())[3] { - static const Union values[] = { - Union::NONE, - Union::TableA, - Union::TableB - }; - return values; -} - -inline const char * const *EnumNamesUnion() { - static const char * const names[4] = { - "NONE", - "TableA", - "TableB", - nullptr - }; - return names; -} - -inline const char *EnumNameUnion(Union e) { - if (::flatbuffers::IsOutRange(e, Union::NONE, Union::TableB)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesUnion()[index]; -} - -template<typename T> struct UnionTraits { - static const Union enum_value = Union::NONE; -}; - -template<> struct UnionTraits<Evolution::V1::TableA> { - static const Union enum_value = Union::TableA; -}; - -template<> struct UnionTraits<Evolution::V1::TableB> { - static const Union enum_value = Union::TableB; -}; - -template <bool B = false> -bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type); -template <bool B = false> -bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types); - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS { - private: - int32_t a_; - int32_t padding0__; - double b_; - - public: - Struct() - : a_(0), - padding0__(0), - b_(0) { - (void)padding0__; - } - Struct(int32_t _a, double _b) - : a_(::flatbuffers::EndianScalar(_a)), - padding0__(0), - b_(::flatbuffers::EndianScalar(_b)) { - (void)padding0__; - } - int32_t a() const { - return ::flatbuffers::EndianScalar(a_); - } - double b() const { - return ::flatbuffers::EndianScalar(b_); - } -}; -FLATBUFFERS_STRUCT_END(Struct, 16); - -inline bool operator==(const Struct &lhs, const Struct &rhs) { - return - (lhs.a() == rhs.a()) && - (lhs.b() == rhs.b()); -} - -inline bool operator!=(const Struct &lhs, const Struct &rhs) { - return !(lhs == rhs); -} - -template <typename H> -inline H AbslHashValue(H h, const Struct &obj) { - return H::combine(std::move(h), obj.a(), obj.b()); -} - -struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableABuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4, - VT_B = 6 - }; - float a() const { - return GetField<float>(VT_A, 0.0f); - } - int32_t b() const { - return GetField<int32_t>(VT_B, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<float>(verifier, VT_A, 4) && - VerifyField<int32_t>(verifier, VT_B, 4) && - verifier.EndTable(); - } -}; - -struct TableABuilder { - typedef TableA Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(float a) { - fbb_.AddElement<float>(TableA::VT_A, a, 0.0f); - } - void add_b(int32_t b) { - fbb_.AddElement<int32_t>(TableA::VT_B, b, 0); - } - explicit TableABuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableA> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableA>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableA> CreateTableA( - ::flatbuffers::FlatBufferBuilder &_fbb, - float a = 0.0f, - int32_t b = 0) { - TableABuilder builder_(_fbb); - builder_.add_b(b); - builder_.add_a(a); - return builder_.Finish(); -} - -struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableBBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4 - }; - int32_t a() const { - return GetField<int32_t>(VT_A, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_A, 4) && - verifier.EndTable(); - } -}; - -struct TableBBuilder { - typedef TableB Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(int32_t a) { - fbb_.AddElement<int32_t>(TableB::VT_A, a, 0); - } - explicit TableBBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableB> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableB>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableB> CreateTableB( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0) { - TableBBuilder builder_(_fbb); - builder_.add_a(a); - return builder_.Finish(); -} - -struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef RootBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4, - VT_B = 6, - VT_C_TYPE = 8, - VT_C = 10, - VT_D = 12, - VT_E = 14, - VT_F = 16, - VT_G = 18, - VT_H = 20, - VT_I = 22, - VT_J_TYPE = 24, - VT_J = 26 - }; - int32_t a() const { - return GetField<int32_t>(VT_A, 0); - } - bool b() const { - return GetField<uint8_t>(VT_B, 0) != 0; - } - Evolution::V1::Union c_type() const { - return static_cast<Evolution::V1::Union>(GetField<uint8_t>(VT_C_TYPE, 0)); - } - const void *c() const { - return GetPointer<const void *>(VT_C); - } - template<typename T> const T *c_as() const; - const Evolution::V1::TableA *c_as_TableA() const { - return c_type() == Evolution::V1::Union::TableA ? static_cast<const Evolution::V1::TableA *>(c()) : nullptr; - } - const Evolution::V1::TableB *c_as_TableB() const { - return c_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(c()) : nullptr; - } - Evolution::V1::Enum d() const { - return static_cast<Evolution::V1::Enum>(GetField<int8_t>(VT_D, 0)); - } - const Evolution::V1::TableA *e() const { - return GetPointer<const Evolution::V1::TableA *>(VT_E); - } - const Evolution::V1::Struct *f() const { - return GetStruct<const Evolution::V1::Struct *>(VT_F); - } - const ::flatbuffers::Vector<int32_t> *g() const { - return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_G); - } - const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>> *h() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>> *>(VT_H); - } - int32_t i() const { - return GetField<int32_t>(VT_I, 1234); - } - Evolution::V1::Union j_type() const { - return static_cast<Evolution::V1::Union>(GetField<uint8_t>(VT_J_TYPE, 0)); - } - const void *j() const { - return GetPointer<const void *>(VT_J); - } - template<typename T> const T *j_as() const; - const Evolution::V1::TableA *j_as_TableA() const { - return j_type() == Evolution::V1::Union::TableA ? static_cast<const Evolution::V1::TableA *>(j()) : nullptr; - } - const Evolution::V1::TableB *j_as_TableB() const { - return j_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(j()) : nullptr; - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_A, 4) && - VerifyField<uint8_t>(verifier, VT_B, 1) && - VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) && - VerifyOffset(verifier, VT_C) && - VerifyUnion(verifier, c(), c_type()) && - VerifyField<int8_t>(verifier, VT_D, 1) && - VerifyOffset(verifier, VT_E) && - verifier.VerifyTable(e()) && - VerifyField<Evolution::V1::Struct>(verifier, VT_F, 8) && - VerifyOffset(verifier, VT_G) && - verifier.VerifyVector(g()) && - VerifyOffset(verifier, VT_H) && - verifier.VerifyVector(h()) && - verifier.VerifyVectorOfTables(h()) && - VerifyField<int32_t>(verifier, VT_I, 4) && - VerifyField<uint8_t>(verifier, VT_J_TYPE, 1) && - VerifyOffset(verifier, VT_J) && - VerifyUnion(verifier, j(), j_type()) && - verifier.EndTable(); - } -}; - -template<> inline const Evolution::V1::TableA *Root::c_as<Evolution::V1::TableA>() const { - return c_as_TableA(); -} - -template<> inline const Evolution::V1::TableB *Root::c_as<Evolution::V1::TableB>() const { - return c_as_TableB(); -} - -template<> inline const Evolution::V1::TableA *Root::j_as<Evolution::V1::TableA>() const { - return j_as_TableA(); -} - -template<> inline const Evolution::V1::TableB *Root::j_as<Evolution::V1::TableB>() const { - return j_as_TableB(); -} - -struct RootBuilder { - typedef Root Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(int32_t a) { - fbb_.AddElement<int32_t>(Root::VT_A, a, 0); - } - void add_b(bool b) { - fbb_.AddElement<uint8_t>(Root::VT_B, static_cast<uint8_t>(b), 0); - } - void add_c_type(Evolution::V1::Union c_type) { - fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0); - } - void add_c(::flatbuffers::Offset<void> c) { - fbb_.AddOffset(Root::VT_C, c); - } - void add_d(Evolution::V1::Enum d) { - fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0); - } - void add_e(::flatbuffers::Offset<Evolution::V1::TableA> e) { - fbb_.AddOffset(Root::VT_E, e); - } - void add_f(const Evolution::V1::Struct *f) { - fbb_.AddStruct(Root::VT_F, f); - } - void add_g(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g) { - fbb_.AddOffset(Root::VT_G, g); - } - void add_h(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>>> h) { - fbb_.AddOffset(Root::VT_H, h); - } - void add_i(int32_t i) { - fbb_.AddElement<int32_t>(Root::VT_I, i, 1234); - } - void add_j_type(Evolution::V1::Union j_type) { - fbb_.AddElement<uint8_t>(Root::VT_J_TYPE, static_cast<uint8_t>(j_type), 0); - } - void add_j(::flatbuffers::Offset<void> j) { - fbb_.AddOffset(Root::VT_J, j); - } - explicit RootBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<Root> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<Root>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<Root> CreateRoot( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0, - bool b = false, - Evolution::V1::Union c_type = Evolution::V1::Union::NONE, - ::flatbuffers::Offset<void> c = 0, - Evolution::V1::Enum d = Evolution::V1::Enum::King, - ::flatbuffers::Offset<Evolution::V1::TableA> e = 0, - const Evolution::V1::Struct *f = nullptr, - ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>>> h = 0, - int32_t i = 1234, - Evolution::V1::Union j_type = Evolution::V1::Union::NONE, - ::flatbuffers::Offset<void> j = 0) { - RootBuilder builder_(_fbb); - builder_.add_j(j); - builder_.add_i(i); - builder_.add_h(h); - builder_.add_g(g); - builder_.add_f(f); - builder_.add_e(e); - builder_.add_c(c); - builder_.add_a(a); - builder_.add_j_type(j_type); - builder_.add_d(d); - builder_.add_c_type(c_type); - builder_.add_b(b); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<Root> CreateRootDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0, - bool b = false, - Evolution::V1::Union c_type = Evolution::V1::Union::NONE, - ::flatbuffers::Offset<void> c = 0, - Evolution::V1::Enum d = Evolution::V1::Enum::King, - ::flatbuffers::Offset<Evolution::V1::TableA> e = 0, - const Evolution::V1::Struct *f = nullptr, - const std::vector<int32_t> *g = nullptr, - const std::vector<::flatbuffers::Offset<Evolution::V1::TableB>> *h = nullptr, - int32_t i = 1234, - Evolution::V1::Union j_type = Evolution::V1::Union::NONE, - ::flatbuffers::Offset<void> j = 0) { - auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0; - auto h__ = h ? _fbb.CreateVector<::flatbuffers::Offset<Evolution::V1::TableB>>(*h) : 0; - return Evolution::V1::CreateRoot( - _fbb, - a, - b, - c_type, - c, - d, - e, - f, - g__, - h__, - i, - j_type, - j); -} - -template <bool B> -inline bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type) { - switch (type) { - case Union::NONE: { - return true; - } - case Union::TableA: { - auto ptr = reinterpret_cast<const Evolution::V1::TableA *>(obj); - return verifier.VerifyTable(ptr); - } - case Union::TableB: { - auto ptr = reinterpret_cast<const Evolution::V1::TableB *>(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -template <bool B> -inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyUnion( - verifier, values->Get(i), types->GetEnum<Union>(i))) { - return false; - } - } - return true; -} - -inline const Evolution::V1::Root *GetRoot(const void *buf) { - return ::flatbuffers::GetRoot<Evolution::V1::Root>(buf); -} - -inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf); -} - -template <bool B = false> -inline bool VerifyRootBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<Evolution::V1::Root>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedRootBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr); -} - -inline void FinishRootBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Evolution::V1::Root> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedRootBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Evolution::V1::Root> root) { - fbb.FinishSizePrefixed(root); -} - -} // namespace V1 -} // namespace Evolution - -#endif // FLATBUFFERS_GENERATED_EVOLUTIONV1_EVOLUTION_V1_H_
diff --git a/tests/evolution_test/evolution_v2_generated.h b/tests/evolution_test/evolution_v2_generated.h deleted file mode 100644 index 4ba4d89..0000000 --- a/tests/evolution_test/evolution_v2_generated.h +++ /dev/null
@@ -1,621 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_EVOLUTIONV2_EVOLUTION_V2_H_ -#define FLATBUFFERS_GENERATED_EVOLUTIONV2_EVOLUTION_V2_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace Evolution { -namespace V2 { - -struct TableA; -struct TableABuilder; - -struct TableB; -struct TableBBuilder; - -struct TableC; -struct TableCBuilder; - -struct Struct; - -struct Root; -struct RootBuilder; - -enum class Enum : int8_t { - King = 0, - Queen = 1, - Rook = 2, - Bishop = 3, - MIN = King, - MAX = Bishop -}; - -inline const Enum (&EnumValuesEnum())[4] { - static const Enum values[] = { - Enum::King, - Enum::Queen, - Enum::Rook, - Enum::Bishop - }; - return values; -} - -inline const char * const *EnumNamesEnum() { - static const char * const names[5] = { - "King", - "Queen", - "Rook", - "Bishop", - nullptr - }; - return names; -} - -inline const char *EnumNameEnum(Enum e) { - if (::flatbuffers::IsOutRange(e, Enum::King, Enum::Bishop)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesEnum()[index]; -} - -enum class Union : uint8_t { - NONE = 0, - TableA = 1, - TableB = 2, - TableC = 3, - MIN = NONE, - MAX = TableC -}; - -inline const Union (&EnumValuesUnion())[4] { - static const Union values[] = { - Union::NONE, - Union::TableA, - Union::TableB, - Union::TableC - }; - return values; -} - -inline const char * const *EnumNamesUnion() { - static const char * const names[5] = { - "NONE", - "TableA", - "TableB", - "TableC", - nullptr - }; - return names; -} - -inline const char *EnumNameUnion(Union e) { - if (::flatbuffers::IsOutRange(e, Union::NONE, Union::TableC)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesUnion()[index]; -} - -template<typename T> struct UnionTraits { - static const Union enum_value = Union::NONE; -}; - -template<> struct UnionTraits<Evolution::V2::TableA> { - static const Union enum_value = Union::TableA; -}; - -template<> struct UnionTraits<Evolution::V2::TableB> { - static const Union enum_value = Union::TableB; -}; - -template<> struct UnionTraits<Evolution::V2::TableC> { - static const Union enum_value = Union::TableC; -}; - -template <bool B = false> -bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type); -template <bool B = false> -bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types); - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS { - private: - int32_t a_; - int32_t padding0__; - double b_; - - public: - Struct() - : a_(0), - padding0__(0), - b_(0) { - (void)padding0__; - } - Struct(int32_t _a, double _b) - : a_(::flatbuffers::EndianScalar(_a)), - padding0__(0), - b_(::flatbuffers::EndianScalar(_b)) { - (void)padding0__; - } - int32_t a() const { - return ::flatbuffers::EndianScalar(a_); - } - double b() const { - return ::flatbuffers::EndianScalar(b_); - } -}; -FLATBUFFERS_STRUCT_END(Struct, 16); - -inline bool operator==(const Struct &lhs, const Struct &rhs) { - return - (lhs.a() == rhs.a()) && - (lhs.b() == rhs.b()); -} - -inline bool operator!=(const Struct &lhs, const Struct &rhs) { - return !(lhs == rhs); -} - -template <typename H> -inline H AbslHashValue(H h, const Struct &obj) { - return H::combine(std::move(h), obj.a(), obj.b()); -} - -struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableABuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4, - VT_B = 6, - VT_C = 8 - }; - float a() const { - return GetField<float>(VT_A, 0.0f); - } - int32_t b() const { - return GetField<int32_t>(VT_B, 0); - } - const ::flatbuffers::String *c() const { - return GetPointer<const ::flatbuffers::String *>(VT_C); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<float>(verifier, VT_A, 4) && - VerifyField<int32_t>(verifier, VT_B, 4) && - VerifyOffset(verifier, VT_C) && - verifier.VerifyString(c()) && - verifier.EndTable(); - } -}; - -struct TableABuilder { - typedef TableA Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(float a) { - fbb_.AddElement<float>(TableA::VT_A, a, 0.0f); - } - void add_b(int32_t b) { - fbb_.AddElement<int32_t>(TableA::VT_B, b, 0); - } - void add_c(::flatbuffers::Offset<::flatbuffers::String> c) { - fbb_.AddOffset(TableA::VT_C, c); - } - explicit TableABuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableA> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableA>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableA> CreateTableA( - ::flatbuffers::FlatBufferBuilder &_fbb, - float a = 0.0f, - int32_t b = 0, - ::flatbuffers::Offset<::flatbuffers::String> c = 0) { - TableABuilder builder_(_fbb); - builder_.add_c(c); - builder_.add_b(b); - builder_.add_a(a); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<TableA> CreateTableADirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - float a = 0.0f, - int32_t b = 0, - const char *c = nullptr) { - auto c__ = c ? _fbb.CreateString(c) : 0; - return Evolution::V2::CreateTableA( - _fbb, - a, - b, - c__); -} - -struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableBBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4 - }; - int32_t a() const { - return GetField<int32_t>(VT_A, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_A, 4) && - verifier.EndTable(); - } -}; - -struct TableBBuilder { - typedef TableB Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(int32_t a) { - fbb_.AddElement<int32_t>(TableB::VT_A, a, 0); - } - explicit TableBBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableB> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableB>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableB> CreateTableB( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0) { - TableBBuilder builder_(_fbb); - builder_.add_a(a); - return builder_.Finish(); -} - -struct TableC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableCBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4, - VT_B = 6 - }; - double a() const { - return GetField<double>(VT_A, 0.0); - } - const ::flatbuffers::String *b() const { - return GetPointer<const ::flatbuffers::String *>(VT_B); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<double>(verifier, VT_A, 8) && - VerifyOffset(verifier, VT_B) && - verifier.VerifyString(b()) && - verifier.EndTable(); - } -}; - -struct TableCBuilder { - typedef TableC Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(double a) { - fbb_.AddElement<double>(TableC::VT_A, a, 0.0); - } - void add_b(::flatbuffers::Offset<::flatbuffers::String> b) { - fbb_.AddOffset(TableC::VT_B, b); - } - explicit TableCBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableC> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableC>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableC> CreateTableC( - ::flatbuffers::FlatBufferBuilder &_fbb, - double a = 0.0, - ::flatbuffers::Offset<::flatbuffers::String> b = 0) { - TableCBuilder builder_(_fbb); - builder_.add_a(a); - builder_.add_b(b); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<TableC> CreateTableCDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - double a = 0.0, - const char *b = nullptr) { - auto b__ = b ? _fbb.CreateString(b) : 0; - return Evolution::V2::CreateTableC( - _fbb, - a, - b__); -} - -struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef RootBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_B = 6, - VT_C_TYPE = 8, - VT_C = 10, - VT_D = 12, - VT_E = 14, - VT_FF = 16, - VT_G = 18, - VT_H = 20, - VT_I = 22, - VT_K = 28, - VT_L = 30 - }; - bool b() const { - return GetField<uint8_t>(VT_B, 0) != 0; - } - Evolution::V2::Union c_type() const { - return static_cast<Evolution::V2::Union>(GetField<uint8_t>(VT_C_TYPE, 0)); - } - const void *c() const { - return GetPointer<const void *>(VT_C); - } - template<typename T> const T *c_as() const; - const Evolution::V2::TableA *c_as_TableA() const { - return c_type() == Evolution::V2::Union::TableA ? static_cast<const Evolution::V2::TableA *>(c()) : nullptr; - } - const Evolution::V2::TableB *c_as_TableB() const { - return c_type() == Evolution::V2::Union::TableB ? static_cast<const Evolution::V2::TableB *>(c()) : nullptr; - } - const Evolution::V2::TableC *c_as_TableC() const { - return c_type() == Evolution::V2::Union::TableC ? static_cast<const Evolution::V2::TableC *>(c()) : nullptr; - } - Evolution::V2::Enum d() const { - return static_cast<Evolution::V2::Enum>(GetField<int8_t>(VT_D, 0)); - } - const Evolution::V2::TableA *e() const { - return GetPointer<const Evolution::V2::TableA *>(VT_E); - } - const Evolution::V2::Struct *ff() const { - return GetStruct<const Evolution::V2::Struct *>(VT_FF); - } - const ::flatbuffers::Vector<int32_t> *g() const { - return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_G); - } - const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>> *h() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>> *>(VT_H); - } - uint32_t i() const { - return GetField<uint32_t>(VT_I, 1234); - } - const Evolution::V2::TableC *k() const { - return GetPointer<const Evolution::V2::TableC *>(VT_K); - } - uint8_t l() const { - return GetField<uint8_t>(VT_L, 56); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<uint8_t>(verifier, VT_B, 1) && - VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) && - VerifyOffset(verifier, VT_C) && - VerifyUnion(verifier, c(), c_type()) && - VerifyField<int8_t>(verifier, VT_D, 1) && - VerifyOffset(verifier, VT_E) && - verifier.VerifyTable(e()) && - VerifyField<Evolution::V2::Struct>(verifier, VT_FF, 8) && - VerifyOffset(verifier, VT_G) && - verifier.VerifyVector(g()) && - VerifyOffset(verifier, VT_H) && - verifier.VerifyVector(h()) && - verifier.VerifyVectorOfTables(h()) && - VerifyField<uint32_t>(verifier, VT_I, 4) && - VerifyOffset(verifier, VT_K) && - verifier.VerifyTable(k()) && - VerifyField<uint8_t>(verifier, VT_L, 1) && - verifier.EndTable(); - } -}; - -template<> inline const Evolution::V2::TableA *Root::c_as<Evolution::V2::TableA>() const { - return c_as_TableA(); -} - -template<> inline const Evolution::V2::TableB *Root::c_as<Evolution::V2::TableB>() const { - return c_as_TableB(); -} - -template<> inline const Evolution::V2::TableC *Root::c_as<Evolution::V2::TableC>() const { - return c_as_TableC(); -} - -struct RootBuilder { - typedef Root Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_b(bool b) { - fbb_.AddElement<uint8_t>(Root::VT_B, static_cast<uint8_t>(b), 0); - } - void add_c_type(Evolution::V2::Union c_type) { - fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0); - } - void add_c(::flatbuffers::Offset<void> c) { - fbb_.AddOffset(Root::VT_C, c); - } - void add_d(Evolution::V2::Enum d) { - fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0); - } - void add_e(::flatbuffers::Offset<Evolution::V2::TableA> e) { - fbb_.AddOffset(Root::VT_E, e); - } - void add_ff(const Evolution::V2::Struct *ff) { - fbb_.AddStruct(Root::VT_FF, ff); - } - void add_g(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g) { - fbb_.AddOffset(Root::VT_G, g); - } - void add_h(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>>> h) { - fbb_.AddOffset(Root::VT_H, h); - } - void add_i(uint32_t i) { - fbb_.AddElement<uint32_t>(Root::VT_I, i, 1234); - } - void add_k(::flatbuffers::Offset<Evolution::V2::TableC> k) { - fbb_.AddOffset(Root::VT_K, k); - } - void add_l(uint8_t l) { - fbb_.AddElement<uint8_t>(Root::VT_L, l, 56); - } - explicit RootBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<Root> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<Root>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<Root> CreateRoot( - ::flatbuffers::FlatBufferBuilder &_fbb, - bool b = false, - Evolution::V2::Union c_type = Evolution::V2::Union::NONE, - ::flatbuffers::Offset<void> c = 0, - Evolution::V2::Enum d = Evolution::V2::Enum::King, - ::flatbuffers::Offset<Evolution::V2::TableA> e = 0, - const Evolution::V2::Struct *ff = nullptr, - ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>>> h = 0, - uint32_t i = 1234, - ::flatbuffers::Offset<Evolution::V2::TableC> k = 0, - uint8_t l = 56) { - RootBuilder builder_(_fbb); - builder_.add_k(k); - builder_.add_i(i); - builder_.add_h(h); - builder_.add_g(g); - builder_.add_ff(ff); - builder_.add_e(e); - builder_.add_c(c); - builder_.add_l(l); - builder_.add_d(d); - builder_.add_c_type(c_type); - builder_.add_b(b); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<Root> CreateRootDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - bool b = false, - Evolution::V2::Union c_type = Evolution::V2::Union::NONE, - ::flatbuffers::Offset<void> c = 0, - Evolution::V2::Enum d = Evolution::V2::Enum::King, - ::flatbuffers::Offset<Evolution::V2::TableA> e = 0, - const Evolution::V2::Struct *ff = nullptr, - const std::vector<int32_t> *g = nullptr, - const std::vector<::flatbuffers::Offset<Evolution::V2::TableB>> *h = nullptr, - uint32_t i = 1234, - ::flatbuffers::Offset<Evolution::V2::TableC> k = 0, - uint8_t l = 56) { - auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0; - auto h__ = h ? _fbb.CreateVector<::flatbuffers::Offset<Evolution::V2::TableB>>(*h) : 0; - return Evolution::V2::CreateRoot( - _fbb, - b, - c_type, - c, - d, - e, - ff, - g__, - h__, - i, - k, - l); -} - -template <bool B> -inline bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type) { - switch (type) { - case Union::NONE: { - return true; - } - case Union::TableA: { - auto ptr = reinterpret_cast<const Evolution::V2::TableA *>(obj); - return verifier.VerifyTable(ptr); - } - case Union::TableB: { - auto ptr = reinterpret_cast<const Evolution::V2::TableB *>(obj); - return verifier.VerifyTable(ptr); - } - case Union::TableC: { - auto ptr = reinterpret_cast<const Evolution::V2::TableC *>(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -template <bool B> -inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyUnion( - verifier, values->Get(i), types->GetEnum<Union>(i))) { - return false; - } - } - return true; -} - -inline const Evolution::V2::Root *GetRoot(const void *buf) { - return ::flatbuffers::GetRoot<Evolution::V2::Root>(buf); -} - -inline const Evolution::V2::Root *GetSizePrefixedRoot(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf); -} - -template <bool B = false> -inline bool VerifyRootBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<Evolution::V2::Root>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedRootBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr); -} - -inline void FinishRootBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Evolution::V2::Root> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedRootBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Evolution::V2::Root> root) { - fbb.FinishSizePrefixed(root); -} - -} // namespace V2 -} // namespace Evolution - -#endif // FLATBUFFERS_GENERATED_EVOLUTIONV2_EVOLUTION_V2_H_
diff --git a/tests/fuzzer/flatbuffers_64bit_fuzzer.cc b/tests/fuzzer/flatbuffers_64bit_fuzzer.cc index e62a586..eccec69 100644 --- a/tests/fuzzer/flatbuffers_64bit_fuzzer.cc +++ b/tests/fuzzer/flatbuffers_64bit_fuzzer.cc
@@ -2,8 +2,8 @@ #include <filesystem> #include <type_traits> -#include "64bit/test_64bit_bfbs_generated.h" #include "64bit/test_64bit_generated.h" +#include "64bit/test_64bit_bfbs_generated.h" #include "flatbuffers/base.h" #include "flatbuffers/flatbuffer_builder.h" #include "flatbuffers/flatbuffers.h"
diff --git a/tests/json_test.cpp b/tests/json_test.cpp index c6499dd..c3c908f 100644 --- a/tests/json_test.cpp +++ b/tests/json_test.cpp
@@ -4,7 +4,7 @@ #include "flatbuffers/idl.h" #include "monster_test_bfbs_generated.h" #include "monster_test_generated.h" -#include "optional_scalars_generated.h" +#include "optional_scalars.fbs.h" #include "test_assert.h" namespace flatbuffers {
diff --git a/tests/key_field/BUILD.bazel b/tests/key_field/BUILD.bazel new file mode 100644 index 0000000..8c4f1b3 --- /dev/null +++ b/tests/key_field/BUILD.bazel
@@ -0,0 +1,16 @@ +load("//:build_defs.bzl", "flatbuffer_cc_library") + +package(default_visibility = ["//visibility:public"]) + +flatbuffer_cc_library( + name = "key_field_sample_cc_fbs", + srcs = ["key_field_sample.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +)
diff --git a/tests/key_field/key_field_sample_generated.h b/tests/key_field/key_field_sample_generated.h deleted file mode 100644 index 4a9a4d4..0000000 --- a/tests/key_field/key_field_sample_generated.h +++ /dev/null
@@ -1,1033 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_KEYFIELDSAMPLE_KEYFIELD_SAMPLE_H_ -#define FLATBUFFERS_GENERATED_KEYFIELDSAMPLE_KEYFIELD_SAMPLE_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace keyfield { -namespace sample { - -struct Baz; - -struct Bar; - -struct Color; - -struct Apple; - -struct Fruit; - -struct Rice; - -struct Grain; - -struct FooTable; -struct FooTableBuilder; -struct FooTableT; - -bool operator==(const Baz &lhs, const Baz &rhs); -bool operator!=(const Baz &lhs, const Baz &rhs); -bool operator==(const Bar &lhs, const Bar &rhs); -bool operator!=(const Bar &lhs, const Bar &rhs); -bool operator==(const Color &lhs, const Color &rhs); -bool operator!=(const Color &lhs, const Color &rhs); -bool operator==(const Apple &lhs, const Apple &rhs); -bool operator!=(const Apple &lhs, const Apple &rhs); -bool operator==(const Fruit &lhs, const Fruit &rhs); -bool operator!=(const Fruit &lhs, const Fruit &rhs); -bool operator==(const Rice &lhs, const Rice &rhs); -bool operator!=(const Rice &lhs, const Rice &rhs); -bool operator==(const Grain &lhs, const Grain &rhs); -bool operator!=(const Grain &lhs, const Grain &rhs); -bool operator==(const FooTableT &lhs, const FooTableT &rhs); -bool operator!=(const FooTableT &lhs, const FooTableT &rhs); - -inline const ::flatbuffers::TypeTable *BazTypeTable(); - -inline const ::flatbuffers::TypeTable *BarTypeTable(); - -inline const ::flatbuffers::TypeTable *ColorTypeTable(); - -inline const ::flatbuffers::TypeTable *AppleTypeTable(); - -inline const ::flatbuffers::TypeTable *FruitTypeTable(); - -inline const ::flatbuffers::TypeTable *RiceTypeTable(); - -inline const ::flatbuffers::TypeTable *GrainTypeTable(); - -inline const ::flatbuffers::TypeTable *FooTableTypeTable(); - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS { - private: - uint8_t a_[4]; - uint8_t b_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return BazTypeTable(); - } - Baz() - : a_(), - b_(0) { - } - Baz(uint8_t _b) - : a_(), - b_(::flatbuffers::EndianScalar(_b)) { - } - Baz(::flatbuffers::span<const uint8_t, 4> _a, uint8_t _b) - : b_(::flatbuffers::EndianScalar(_b)) { - ::flatbuffers::CastToArray(a_).CopyFromSpan(_a); - } - const ::flatbuffers::Array<uint8_t, 4> *a() const { - return &::flatbuffers::CastToArray(a_); - } - ::flatbuffers::Array<uint8_t, 4> *mutable_a() { - return &::flatbuffers::CastToArray(a_); - } - bool KeyCompareLessThan(const Baz * const o) const { - return KeyCompareWithValue(o->a()) < 0; - } - int KeyCompareWithValue(const ::flatbuffers::Array<uint8_t, 4> *_a) const { - const ::flatbuffers::Array<uint8_t, 4> *curr_a = a(); - for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) { - const auto lhs = curr_a->Get(i); - const auto rhs = _a->Get(i); - if (lhs != rhs) - return static_cast<int>(lhs > rhs) - static_cast<int>(lhs < rhs); - } - return 0; - } - uint8_t b() const { - return ::flatbuffers::EndianScalar(b_); - } - void mutate_b(uint8_t _b) { - ::flatbuffers::WriteScalar(&b_, _b); - } -}; -FLATBUFFERS_STRUCT_END(Baz, 5); - -inline bool operator==(const Baz &lhs, const Baz &rhs) { - return - (*lhs.a() == *rhs.a()) && - (lhs.b() == rhs.b()); -} - -inline bool operator!=(const Baz &lhs, const Baz &rhs) { - return !(lhs == rhs); -} - - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS { - private: - float a_[3]; - uint8_t b_; - int8_t padding0__; int16_t padding1__; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return BarTypeTable(); - } - Bar() - : a_(), - b_(0), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - Bar(uint8_t _b) - : a_(), - b_(::flatbuffers::EndianScalar(_b)), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - Bar(::flatbuffers::span<const float, 3> _a, uint8_t _b) - : b_(::flatbuffers::EndianScalar(_b)), - padding0__(0), - padding1__(0) { - ::flatbuffers::CastToArray(a_).CopyFromSpan(_a); - (void)padding0__; - (void)padding1__; - } - const ::flatbuffers::Array<float, 3> *a() const { - return &::flatbuffers::CastToArray(a_); - } - ::flatbuffers::Array<float, 3> *mutable_a() { - return &::flatbuffers::CastToArray(a_); - } - bool KeyCompareLessThan(const Bar * const o) const { - return KeyCompareWithValue(o->a()) < 0; - } - int KeyCompareWithValue(const ::flatbuffers::Array<float, 3> *_a) const { - const ::flatbuffers::Array<float, 3> *curr_a = a(); - for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) { - const auto lhs = curr_a->Get(i); - const auto rhs = _a->Get(i); - if (lhs != rhs) - return static_cast<int>(lhs > rhs) - static_cast<int>(lhs < rhs); - } - return 0; - } - uint8_t b() const { - return ::flatbuffers::EndianScalar(b_); - } - void mutate_b(uint8_t _b) { - ::flatbuffers::WriteScalar(&b_, _b); - } -}; -FLATBUFFERS_STRUCT_END(Bar, 16); - -inline bool operator==(const Bar &lhs, const Bar &rhs) { - return - (*lhs.a() == *rhs.a()) && - (lhs.b() == rhs.b()); -} - -inline bool operator!=(const Bar &lhs, const Bar &rhs) { - return !(lhs == rhs); -} - - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Color FLATBUFFERS_FINAL_CLASS { - private: - float rgb_[3]; - uint8_t tag_; - int8_t padding0__; int16_t padding1__; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return ColorTypeTable(); - } - Color() - : rgb_(), - tag_(0), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - Color(uint8_t _tag) - : rgb_(), - tag_(::flatbuffers::EndianScalar(_tag)), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - Color(::flatbuffers::span<const float, 3> _rgb, uint8_t _tag) - : tag_(::flatbuffers::EndianScalar(_tag)), - padding0__(0), - padding1__(0) { - ::flatbuffers::CastToArray(rgb_).CopyFromSpan(_rgb); - (void)padding0__; - (void)padding1__; - } - const ::flatbuffers::Array<float, 3> *rgb() const { - return &::flatbuffers::CastToArray(rgb_); - } - ::flatbuffers::Array<float, 3> *mutable_rgb() { - return &::flatbuffers::CastToArray(rgb_); - } - bool KeyCompareLessThan(const Color * const o) const { - return KeyCompareWithValue(o->rgb()) < 0; - } - int KeyCompareWithValue(const ::flatbuffers::Array<float, 3> *_rgb) const { - const ::flatbuffers::Array<float, 3> *curr_rgb = rgb(); - for (::flatbuffers::uoffset_t i = 0; i < curr_rgb->size(); i++) { - const auto lhs = curr_rgb->Get(i); - const auto rhs = _rgb->Get(i); - if (lhs != rhs) - return static_cast<int>(lhs > rhs) - static_cast<int>(lhs < rhs); - } - return 0; - } - uint8_t tag() const { - return ::flatbuffers::EndianScalar(tag_); - } - void mutate_tag(uint8_t _tag) { - ::flatbuffers::WriteScalar(&tag_, _tag); - } -}; -FLATBUFFERS_STRUCT_END(Color, 16); - -inline bool operator==(const Color &lhs, const Color &rhs) { - return - (*lhs.rgb() == *rhs.rgb()) && - (lhs.tag() == rhs.tag()); -} - -inline bool operator!=(const Color &lhs, const Color &rhs) { - return !(lhs == rhs); -} - - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Apple FLATBUFFERS_FINAL_CLASS { - private: - uint8_t tag_; - int8_t padding0__; int16_t padding1__; - keyfield::sample::Color color_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return AppleTypeTable(); - } - Apple() - : tag_(0), - padding0__(0), - padding1__(0), - color_() { - (void)padding0__; - (void)padding1__; - } - Apple(uint8_t _tag, const keyfield::sample::Color &_color) - : tag_(::flatbuffers::EndianScalar(_tag)), - padding0__(0), - padding1__(0), - color_(_color) { - (void)padding0__; - (void)padding1__; - } - uint8_t tag() const { - return ::flatbuffers::EndianScalar(tag_); - } - void mutate_tag(uint8_t _tag) { - ::flatbuffers::WriteScalar(&tag_, _tag); - } - const keyfield::sample::Color &color() const { - return color_; - } - keyfield::sample::Color &mutable_color() { - return color_; - } - bool KeyCompareLessThan(const Apple * const o) const { - return KeyCompareWithValue(o->color()) < 0; - } - int KeyCompareWithValue(const keyfield::sample::Color &_color) const { - const auto &lhs_color = color(); - const auto &rhs_color = _color; - const auto rhs_color_rgb = rhs_color.rgb(); - const auto rgb_compare_result = lhs_color.KeyCompareWithValue(rhs_color_rgb); - if (rgb_compare_result != 0) - return rgb_compare_result; - const auto lhs_color_tag = lhs_color.tag(); - const auto rhs_color_tag = rhs_color.tag(); - if (lhs_color_tag != rhs_color_tag) - return static_cast<int>(lhs_color_tag > rhs_color_tag) - static_cast<int>(lhs_color_tag < rhs_color_tag); - return 0; - } -}; -FLATBUFFERS_STRUCT_END(Apple, 20); - -inline bool operator==(const Apple &lhs, const Apple &rhs) { - return - (lhs.tag() == rhs.tag()) && - (lhs.color() == rhs.color()); -} - -inline bool operator!=(const Apple &lhs, const Apple &rhs) { - return !(lhs == rhs); -} - - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Fruit FLATBUFFERS_FINAL_CLASS { - private: - keyfield::sample::Apple a_; - uint8_t b_; - int8_t padding0__; int16_t padding1__; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return FruitTypeTable(); - } - Fruit() - : a_(), - b_(0), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - Fruit(const keyfield::sample::Apple &_a, uint8_t _b) - : a_(_a), - b_(::flatbuffers::EndianScalar(_b)), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - const keyfield::sample::Apple &a() const { - return a_; - } - keyfield::sample::Apple &mutable_a() { - return a_; - } - bool KeyCompareLessThan(const Fruit * const o) const { - return KeyCompareWithValue(o->a()) < 0; - } - int KeyCompareWithValue(const keyfield::sample::Apple &_a) const { - const auto &lhs_a = a(); - const auto &rhs_a = _a; - const auto lhs_a_tag = lhs_a.tag(); - const auto rhs_a_tag = rhs_a.tag(); - if (lhs_a_tag != rhs_a_tag) - return static_cast<int>(lhs_a_tag > rhs_a_tag) - static_cast<int>(lhs_a_tag < rhs_a_tag); - const auto rhs_a_color = rhs_a.color(); - const auto color_compare_result = lhs_a.KeyCompareWithValue(rhs_a_color); - if (color_compare_result != 0) - return color_compare_result; - return 0; - } - uint8_t b() const { - return ::flatbuffers::EndianScalar(b_); - } - void mutate_b(uint8_t _b) { - ::flatbuffers::WriteScalar(&b_, _b); - } -}; -FLATBUFFERS_STRUCT_END(Fruit, 24); - -inline bool operator==(const Fruit &lhs, const Fruit &rhs) { - return - (lhs.a() == rhs.a()) && - (lhs.b() == rhs.b()); -} - -inline bool operator!=(const Fruit &lhs, const Fruit &rhs) { - return !(lhs == rhs); -} - - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rice FLATBUFFERS_FINAL_CLASS { - private: - uint8_t origin_[3]; - int8_t padding0__; - uint32_t quantity_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return RiceTypeTable(); - } - Rice() - : origin_(), - padding0__(0), - quantity_(0) { - (void)padding0__; - } - Rice(uint32_t _quantity) - : origin_(), - padding0__(0), - quantity_(::flatbuffers::EndianScalar(_quantity)) { - (void)padding0__; - } - Rice(::flatbuffers::span<const uint8_t, 3> _origin, uint32_t _quantity) - : padding0__(0), - quantity_(::flatbuffers::EndianScalar(_quantity)) { - ::flatbuffers::CastToArray(origin_).CopyFromSpan(_origin); - (void)padding0__; - } - const ::flatbuffers::Array<uint8_t, 3> *origin() const { - return &::flatbuffers::CastToArray(origin_); - } - ::flatbuffers::Array<uint8_t, 3> *mutable_origin() { - return &::flatbuffers::CastToArray(origin_); - } - uint32_t quantity() const { - return ::flatbuffers::EndianScalar(quantity_); - } - void mutate_quantity(uint32_t _quantity) { - ::flatbuffers::WriteScalar(&quantity_, _quantity); - } -}; -FLATBUFFERS_STRUCT_END(Rice, 8); - -inline bool operator==(const Rice &lhs, const Rice &rhs) { - return - (*lhs.origin() == *rhs.origin()) && - (lhs.quantity() == rhs.quantity()); -} - -inline bool operator!=(const Rice &lhs, const Rice &rhs) { - return !(lhs == rhs); -} - - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Grain FLATBUFFERS_FINAL_CLASS { - private: - keyfield::sample::Rice a_[3]; - uint8_t tag_; - int8_t padding0__; int16_t padding1__; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return GrainTypeTable(); - } - Grain() - : a_(), - tag_(0), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - Grain(uint8_t _tag) - : a_(), - tag_(::flatbuffers::EndianScalar(_tag)), - padding0__(0), - padding1__(0) { - (void)padding0__; - (void)padding1__; - } - Grain(::flatbuffers::span<const keyfield::sample::Rice, 3> _a, uint8_t _tag) - : tag_(::flatbuffers::EndianScalar(_tag)), - padding0__(0), - padding1__(0) { - ::flatbuffers::CastToArray(a_).CopyFromSpan(_a); - (void)padding0__; - (void)padding1__; - } - const ::flatbuffers::Array<keyfield::sample::Rice, 3> *a() const { - return &::flatbuffers::CastToArray(a_); - } - ::flatbuffers::Array<keyfield::sample::Rice, 3> *mutable_a() { - return &::flatbuffers::CastToArray(a_); - } - bool KeyCompareLessThan(const Grain * const o) const { - return KeyCompareWithValue(o->a()) < 0; - } - int KeyCompareWithValue(const ::flatbuffers::Array<keyfield::sample::Rice, 3> *_a) const { - const ::flatbuffers::Array<keyfield::sample::Rice, 3> *curr_a = a(); - for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) { - const auto &lhs_a = *(curr_a->Get(i)); - const auto &rhs_a = *(_a->Get(i)); - const auto lhs_a_origin = lhs_a.origin(); - const auto rhs_a_origin = rhs_a.origin(); - for (::flatbuffers::uoffset_t i = 0; i < lhs_a_origin->size(); i++) { - const auto lhs_a_origin_elem = lhs_a_origin->Get(i); - const auto rhs_a_origin_elem = rhs_a_origin->Get(i); - if (lhs_a_origin_elem != rhs_a_origin_elem) - return static_cast<int>(lhs_a_origin_elem > rhs_a_origin_elem) - static_cast<int>(lhs_a_origin_elem < rhs_a_origin_elem); - } - const auto lhs_a_quantity = lhs_a.quantity(); - const auto rhs_a_quantity = rhs_a.quantity(); - if (lhs_a_quantity != rhs_a_quantity) - return static_cast<int>(lhs_a_quantity > rhs_a_quantity) - static_cast<int>(lhs_a_quantity < rhs_a_quantity); - } - return 0; - } - uint8_t tag() const { - return ::flatbuffers::EndianScalar(tag_); - } - void mutate_tag(uint8_t _tag) { - ::flatbuffers::WriteScalar(&tag_, _tag); - } -}; -FLATBUFFERS_STRUCT_END(Grain, 28); - -inline bool operator==(const Grain &lhs, const Grain &rhs) { - return - (*lhs.a() == *rhs.a()) && - (lhs.tag() == rhs.tag()); -} - -inline bool operator!=(const Grain &lhs, const Grain &rhs) { - return !(lhs == rhs); -} - - -struct FooTableT : public ::flatbuffers::NativeTable { - typedef FooTable TableType; - int32_t a = 0; - int32_t b = 0; - std::string c{}; - std::vector<keyfield::sample::Baz> d{}; - std::vector<keyfield::sample::Bar> e{}; - std::vector<keyfield::sample::Apple> f{}; - std::vector<keyfield::sample::Fruit> g{}; - std::vector<keyfield::sample::Grain> h{}; -}; - -struct FooTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef FooTableT NativeTableType; - typedef FooTableBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return FooTableTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4, - VT_B = 6, - VT_C = 8, - VT_D = 10, - VT_E = 12, - VT_F = 14, - VT_G = 16, - VT_H = 18 - }; - int32_t a() const { - return GetField<int32_t>(VT_A, 0); - } - bool mutate_a(int32_t _a = 0) { - return SetField<int32_t>(VT_A, _a, 0); - } - int32_t b() const { - return GetField<int32_t>(VT_B, 0); - } - bool mutate_b(int32_t _b = 0) { - return SetField<int32_t>(VT_B, _b, 0); - } - const ::flatbuffers::String *c() const { - return GetPointer<const ::flatbuffers::String *>(VT_C); - } - ::flatbuffers::String *mutable_c() { - return GetPointer<::flatbuffers::String *>(VT_C); - } - bool KeyCompareLessThan(const FooTable * const o) const { - return *c() < *o->c(); - } - int KeyCompareWithValue(const char *_c) const { - return strcmp(c()->c_str(), _c); - } - template<typename StringType> - int KeyCompareWithValue(const StringType& _c) const { - if (c()->c_str() < _c) return -1; - if (_c < c()->c_str()) return 1; - return 0; - } - const ::flatbuffers::Vector<const keyfield::sample::Baz *> *d() const { - return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D); - } - ::flatbuffers::Vector<const keyfield::sample::Baz *> *mutable_d() { - return GetPointer<::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D); - } - const ::flatbuffers::Vector<const keyfield::sample::Bar *> *e() const { - return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E); - } - ::flatbuffers::Vector<const keyfield::sample::Bar *> *mutable_e() { - return GetPointer<::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E); - } - const ::flatbuffers::Vector<const keyfield::sample::Apple *> *f() const { - return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Apple *> *>(VT_F); - } - ::flatbuffers::Vector<const keyfield::sample::Apple *> *mutable_f() { - return GetPointer<::flatbuffers::Vector<const keyfield::sample::Apple *> *>(VT_F); - } - const ::flatbuffers::Vector<const keyfield::sample::Fruit *> *g() const { - return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Fruit *> *>(VT_G); - } - ::flatbuffers::Vector<const keyfield::sample::Fruit *> *mutable_g() { - return GetPointer<::flatbuffers::Vector<const keyfield::sample::Fruit *> *>(VT_G); - } - const ::flatbuffers::Vector<const keyfield::sample::Grain *> *h() const { - return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Grain *> *>(VT_H); - } - ::flatbuffers::Vector<const keyfield::sample::Grain *> *mutable_h() { - return GetPointer<::flatbuffers::Vector<const keyfield::sample::Grain *> *>(VT_H); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_A, 4) && - VerifyField<int32_t>(verifier, VT_B, 4) && - VerifyOffsetRequired(verifier, VT_C) && - verifier.VerifyString(c()) && - VerifyOffset(verifier, VT_D) && - verifier.VerifyVector(d()) && - VerifyOffset(verifier, VT_E) && - verifier.VerifyVector(e()) && - VerifyOffset(verifier, VT_F) && - verifier.VerifyVector(f()) && - VerifyOffset(verifier, VT_G) && - verifier.VerifyVector(g()) && - VerifyOffset(verifier, VT_H) && - verifier.VerifyVector(h()) && - verifier.EndTable(); - } - FooTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<FooTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct FooTableBuilder { - typedef FooTable Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(int32_t a) { - fbb_.AddElement<int32_t>(FooTable::VT_A, a, 0); - } - void add_b(int32_t b) { - fbb_.AddElement<int32_t>(FooTable::VT_B, b, 0); - } - void add_c(::flatbuffers::Offset<::flatbuffers::String> c) { - fbb_.AddOffset(FooTable::VT_C, c); - } - void add_d(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d) { - fbb_.AddOffset(FooTable::VT_D, d); - } - void add_e(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e) { - fbb_.AddOffset(FooTable::VT_E, e); - } - void add_f(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Apple *>> f) { - fbb_.AddOffset(FooTable::VT_F, f); - } - void add_g(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Fruit *>> g) { - fbb_.AddOffset(FooTable::VT_G, g); - } - void add_h(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Grain *>> h) { - fbb_.AddOffset(FooTable::VT_H, h); - } - explicit FooTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<FooTable> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<FooTable>(end); - fbb_.Required(o, FooTable::VT_C); - return o; - } -}; - -inline ::flatbuffers::Offset<FooTable> CreateFooTable( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0, - int32_t b = 0, - ::flatbuffers::Offset<::flatbuffers::String> c = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Apple *>> f = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Fruit *>> g = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Grain *>> h = 0) { - FooTableBuilder builder_(_fbb); - builder_.add_h(h); - builder_.add_g(g); - builder_.add_f(f); - builder_.add_e(e); - builder_.add_d(d); - builder_.add_c(c); - builder_.add_b(b); - builder_.add_a(a); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<FooTable> CreateFooTableDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0, - int32_t b = 0, - const char *c = nullptr, - std::vector<keyfield::sample::Baz> *d = nullptr, - std::vector<keyfield::sample::Bar> *e = nullptr, - std::vector<keyfield::sample::Apple> *f = nullptr, - std::vector<keyfield::sample::Fruit> *g = nullptr, - std::vector<keyfield::sample::Grain> *h = nullptr) { - auto c__ = c ? _fbb.CreateString(c) : 0; - auto d__ = d ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Baz>(d) : 0; - auto e__ = e ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Bar>(e) : 0; - auto f__ = f ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Apple>(f) : 0; - auto g__ = g ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Fruit>(g) : 0; - auto h__ = h ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Grain>(h) : 0; - return keyfield::sample::CreateFooTable( - _fbb, - a, - b, - c__, - d__, - e__, - f__, - g__, - h__); -} - -::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const FooTableT &lhs, const FooTableT &rhs) { - return - (lhs.a == rhs.a) && - (lhs.b == rhs.b) && - (lhs.c == rhs.c) && - (lhs.d == rhs.d) && - (lhs.e == rhs.e) && - (lhs.f == rhs.f) && - (lhs.g == rhs.g) && - (lhs.h == rhs.h); -} - -inline bool operator!=(const FooTableT &lhs, const FooTableT &rhs) { - return !(lhs == rhs); -} - - -inline FooTableT *FooTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<FooTableT>(new FooTableT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void FooTable::UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = a(); _o->a = _e; } - { auto _e = b(); _o->b = _e; } - { auto _e = c(); if (_e) _o->c = _e->str(); } - { auto _e = d(); if (_e) { _o->d.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->d[_i] = *_e->Get(_i); } } else { _o->d.resize(0); } } - { auto _e = e(); if (_e) { _o->e.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->e[_i] = *_e->Get(_i); } } else { _o->e.resize(0); } } - { auto _e = f(); if (_e) { _o->f.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->f[_i] = *_e->Get(_i); } } else { _o->f.resize(0); } } - { auto _e = g(); if (_e) { _o->g.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->g[_i] = *_e->Get(_i); } } else { _o->g.resize(0); } } - { auto _e = h(); if (_e) { _o->h.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->h[_i] = *_e->Get(_i); } } else { _o->h.resize(0); } } -} - -inline ::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return FooTable::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<FooTable> FooTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FooTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _a = _o->a; - auto _b = _o->b; - auto _c = _fbb.CreateString(_o->c); - auto _d = _o->d.size() ? _fbb.CreateVectorOfStructs(_o->d) : 0; - auto _e = _o->e.size() ? _fbb.CreateVectorOfStructs(_o->e) : 0; - auto _f = _o->f.size() ? _fbb.CreateVectorOfStructs(_o->f) : 0; - auto _g = _o->g.size() ? _fbb.CreateVectorOfStructs(_o->g) : 0; - auto _h = _o->h.size() ? _fbb.CreateVectorOfStructs(_o->h) : 0; - return keyfield::sample::CreateFooTable( - _fbb, - _a, - _b, - _c, - _d, - _e, - _f, - _g, - _h); -} - -inline const ::flatbuffers::TypeTable *BazTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_UCHAR, 1, -1 }, - { ::flatbuffers::ET_UCHAR, 0, -1 } - }; - static const int16_t array_sizes[] = { 4, }; - static const int64_t values[] = { 0, 4, 5 }; - static const char * const names[] = { - "a", - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *BarTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_FLOAT, 1, -1 }, - { ::flatbuffers::ET_UCHAR, 0, -1 } - }; - static const int16_t array_sizes[] = { 3, }; - static const int64_t values[] = { 0, 12, 16 }; - static const char * const names[] = { - "a", - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *ColorTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_FLOAT, 1, -1 }, - { ::flatbuffers::ET_UCHAR, 0, -1 } - }; - static const int16_t array_sizes[] = { 3, }; - static const int64_t values[] = { 0, 12, 16 }; - static const char * const names[] = { - "rgb", - "tag" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *AppleTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_UCHAR, 0, -1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - keyfield::sample::ColorTypeTable - }; - static const int64_t values[] = { 0, 4, 20 }; - static const char * const names[] = { - "tag", - "color" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, type_refs, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *FruitTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_UCHAR, 0, -1 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - keyfield::sample::AppleTypeTable - }; - static const int64_t values[] = { 0, 20, 24 }; - static const char * const names[] = { - "a", - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, type_refs, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *RiceTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_UCHAR, 1, -1 }, - { ::flatbuffers::ET_UINT, 0, -1 } - }; - static const int16_t array_sizes[] = { 3, }; - static const int64_t values[] = { 0, 4, 8 }; - static const char * const names[] = { - "origin", - "quantity" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *GrainTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 1, 0 }, - { ::flatbuffers::ET_UCHAR, 0, -1 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - keyfield::sample::RiceTypeTable - }; - static const int16_t array_sizes[] = { 3, }; - static const int64_t values[] = { 0, 24, 28 }; - static const char * const names[] = { - "a", - "tag" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, type_refs, array_sizes, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *FooTableTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_STRING, 0, -1 }, - { ::flatbuffers::ET_SEQUENCE, 1, 0 }, - { ::flatbuffers::ET_SEQUENCE, 1, 1 }, - { ::flatbuffers::ET_SEQUENCE, 1, 2 }, - { ::flatbuffers::ET_SEQUENCE, 1, 3 }, - { ::flatbuffers::ET_SEQUENCE, 1, 4 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - keyfield::sample::BazTypeTable, - keyfield::sample::BarTypeTable, - keyfield::sample::AppleTypeTable, - keyfield::sample::FruitTypeTable, - keyfield::sample::GrainTypeTable - }; - static const char * const names[] = { - "a", - "b", - "c", - "d", - "e", - "f", - "g", - "h" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 8, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const keyfield::sample::FooTable *GetFooTable(const void *buf) { - return ::flatbuffers::GetRoot<keyfield::sample::FooTable>(buf); -} - -inline const keyfield::sample::FooTable *GetSizePrefixedFooTable(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<keyfield::sample::FooTable>(buf); -} - -inline FooTable *GetMutableFooTable(void *buf) { - return ::flatbuffers::GetMutableRoot<FooTable>(buf); -} - -inline keyfield::sample::FooTable *GetMutableSizePrefixedFooTable(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf); -} - -template <bool B = false> -inline bool VerifyFooTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<keyfield::sample::FooTable>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedFooTableBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr); -} - -inline void FinishFooTableBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<keyfield::sample::FooTable> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedFooTableBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<keyfield::sample::FooTable> root) { - fbb.FinishSizePrefixed(root); -} - -inline std::unique_ptr<keyfield::sample::FooTableT> UnPackFooTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<keyfield::sample::FooTableT>(GetFooTable(buf)->UnPack(res)); -} - -inline std::unique_ptr<keyfield::sample::FooTableT> UnPackSizePrefixedFooTable( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<keyfield::sample::FooTableT>(GetSizePrefixedFooTable(buf)->UnPack(res)); -} - -} // namespace sample -} // namespace keyfield - -#endif // FLATBUFFERS_GENERATED_KEYFIELDSAMPLE_KEYFIELD_SAMPLE_H_
diff --git a/tests/key_field_test.cpp b/tests/key_field_test.cpp index db5a0d5..7debbda 100644 --- a/tests/key_field_test.cpp +++ b/tests/key_field_test.cpp
@@ -4,7 +4,7 @@ #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" -#include "key_field/key_field_sample_generated.h" +#include "key_field/key_field_sample.fbs.h" #include "test_assert.h" namespace flatbuffers {
diff --git a/tests/monster_extra_generated.h b/tests/monster_extra_generated.h deleted file mode 100644 index 4c6668b..0000000 --- a/tests/monster_extra_generated.h +++ /dev/null
@@ -1,420 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_MONSTEREXTRA_MYGAME_H_ -#define FLATBUFFERS_GENERATED_MONSTEREXTRA_MYGAME_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace MyGame { - -struct MonsterExtra; -struct MonsterExtraBuilder; -struct MonsterExtraT; - -bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs); -bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs); - -inline const ::flatbuffers::TypeTable *MonsterExtraTypeTable(); - -struct MonsterExtraT : public ::flatbuffers::NativeTable { - typedef MonsterExtra TableType; - double d0 = std::numeric_limits<double>::quiet_NaN(); - double d1 = std::numeric_limits<double>::quiet_NaN(); - double d2 = std::numeric_limits<double>::infinity(); - double d3 = -std::numeric_limits<double>::infinity(); - float f0 = std::numeric_limits<float>::quiet_NaN(); - float f1 = std::numeric_limits<float>::quiet_NaN(); - float f2 = std::numeric_limits<float>::infinity(); - float f3 = -std::numeric_limits<float>::infinity(); - std::vector<double> dvec{}; - std::vector<float> fvec{}; -}; - -struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef MonsterExtraT NativeTableType; - typedef MonsterExtraBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return MonsterExtraTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_D0 = 4, - VT_D1 = 6, - VT_D2 = 8, - VT_D3 = 10, - VT_F0 = 12, - VT_F1 = 14, - VT_F2 = 16, - VT_F3 = 18, - VT_DVEC = 20, - VT_FVEC = 22 - }; - double d0() const { - return GetField<double>(VT_D0, std::numeric_limits<double>::quiet_NaN()); - } - bool mutate_d0(double _d0 = std::numeric_limits<double>::quiet_NaN()) { - return SetField<double>(VT_D0, _d0, std::numeric_limits<double>::quiet_NaN()); - } - double d1() const { - return GetField<double>(VT_D1, std::numeric_limits<double>::quiet_NaN()); - } - bool mutate_d1(double _d1 = std::numeric_limits<double>::quiet_NaN()) { - return SetField<double>(VT_D1, _d1, std::numeric_limits<double>::quiet_NaN()); - } - double d2() const { - return GetField<double>(VT_D2, std::numeric_limits<double>::infinity()); - } - bool mutate_d2(double _d2 = std::numeric_limits<double>::infinity()) { - return SetField<double>(VT_D2, _d2, std::numeric_limits<double>::infinity()); - } - double d3() const { - return GetField<double>(VT_D3, -std::numeric_limits<double>::infinity()); - } - bool mutate_d3(double _d3 = -std::numeric_limits<double>::infinity()) { - return SetField<double>(VT_D3, _d3, -std::numeric_limits<double>::infinity()); - } - float f0() const { - return GetField<float>(VT_F0, std::numeric_limits<float>::quiet_NaN()); - } - bool mutate_f0(float _f0 = std::numeric_limits<float>::quiet_NaN()) { - return SetField<float>(VT_F0, _f0, std::numeric_limits<float>::quiet_NaN()); - } - float f1() const { - return GetField<float>(VT_F1, std::numeric_limits<float>::quiet_NaN()); - } - bool mutate_f1(float _f1 = std::numeric_limits<float>::quiet_NaN()) { - return SetField<float>(VT_F1, _f1, std::numeric_limits<float>::quiet_NaN()); - } - float f2() const { - return GetField<float>(VT_F2, std::numeric_limits<float>::infinity()); - } - bool mutate_f2(float _f2 = std::numeric_limits<float>::infinity()) { - return SetField<float>(VT_F2, _f2, std::numeric_limits<float>::infinity()); - } - float f3() const { - return GetField<float>(VT_F3, -std::numeric_limits<float>::infinity()); - } - bool mutate_f3(float _f3 = -std::numeric_limits<float>::infinity()) { - return SetField<float>(VT_F3, _f3, -std::numeric_limits<float>::infinity()); - } - const ::flatbuffers::Vector<double> *dvec() const { - return GetPointer<const ::flatbuffers::Vector<double> *>(VT_DVEC); - } - ::flatbuffers::Vector<double> *mutable_dvec() { - return GetPointer<::flatbuffers::Vector<double> *>(VT_DVEC); - } - const ::flatbuffers::Vector<float> *fvec() const { - return GetPointer<const ::flatbuffers::Vector<float> *>(VT_FVEC); - } - ::flatbuffers::Vector<float> *mutable_fvec() { - return GetPointer<::flatbuffers::Vector<float> *>(VT_FVEC); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<double>(verifier, VT_D0, 8) && - VerifyField<double>(verifier, VT_D1, 8) && - VerifyField<double>(verifier, VT_D2, 8) && - VerifyField<double>(verifier, VT_D3, 8) && - VerifyField<float>(verifier, VT_F0, 4) && - VerifyField<float>(verifier, VT_F1, 4) && - VerifyField<float>(verifier, VT_F2, 4) && - VerifyField<float>(verifier, VT_F3, 4) && - VerifyOffset(verifier, VT_DVEC) && - verifier.VerifyVector(dvec()) && - VerifyOffset(verifier, VT_FVEC) && - verifier.VerifyVector(fvec()) && - verifier.EndTable(); - } - MonsterExtraT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MonsterExtraT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<MonsterExtra> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct MonsterExtraBuilder { - typedef MonsterExtra Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_d0(double d0) { - fbb_.AddElement<double>(MonsterExtra::VT_D0, d0, std::numeric_limits<double>::quiet_NaN()); - } - void add_d1(double d1) { - fbb_.AddElement<double>(MonsterExtra::VT_D1, d1, std::numeric_limits<double>::quiet_NaN()); - } - void add_d2(double d2) { - fbb_.AddElement<double>(MonsterExtra::VT_D2, d2, std::numeric_limits<double>::infinity()); - } - void add_d3(double d3) { - fbb_.AddElement<double>(MonsterExtra::VT_D3, d3, -std::numeric_limits<double>::infinity()); - } - void add_f0(float f0) { - fbb_.AddElement<float>(MonsterExtra::VT_F0, f0, std::numeric_limits<float>::quiet_NaN()); - } - void add_f1(float f1) { - fbb_.AddElement<float>(MonsterExtra::VT_F1, f1, std::numeric_limits<float>::quiet_NaN()); - } - void add_f2(float f2) { - fbb_.AddElement<float>(MonsterExtra::VT_F2, f2, std::numeric_limits<float>::infinity()); - } - void add_f3(float f3) { - fbb_.AddElement<float>(MonsterExtra::VT_F3, f3, -std::numeric_limits<float>::infinity()); - } - void add_dvec(::flatbuffers::Offset<::flatbuffers::Vector<double>> dvec) { - fbb_.AddOffset(MonsterExtra::VT_DVEC, dvec); - } - void add_fvec(::flatbuffers::Offset<::flatbuffers::Vector<float>> fvec) { - fbb_.AddOffset(MonsterExtra::VT_FVEC, fvec); - } - explicit MonsterExtraBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<MonsterExtra> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<MonsterExtra>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtra( - ::flatbuffers::FlatBufferBuilder &_fbb, - double d0 = std::numeric_limits<double>::quiet_NaN(), - double d1 = std::numeric_limits<double>::quiet_NaN(), - double d2 = std::numeric_limits<double>::infinity(), - double d3 = -std::numeric_limits<double>::infinity(), - float f0 = std::numeric_limits<float>::quiet_NaN(), - float f1 = std::numeric_limits<float>::quiet_NaN(), - float f2 = std::numeric_limits<float>::infinity(), - float f3 = -std::numeric_limits<float>::infinity(), - ::flatbuffers::Offset<::flatbuffers::Vector<double>> dvec = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<float>> fvec = 0) { - MonsterExtraBuilder builder_(_fbb); - builder_.add_d3(d3); - builder_.add_d2(d2); - builder_.add_d1(d1); - builder_.add_d0(d0); - builder_.add_fvec(fvec); - builder_.add_dvec(dvec); - builder_.add_f3(f3); - builder_.add_f2(f2); - builder_.add_f1(f1); - builder_.add_f0(f0); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtraDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - double d0 = std::numeric_limits<double>::quiet_NaN(), - double d1 = std::numeric_limits<double>::quiet_NaN(), - double d2 = std::numeric_limits<double>::infinity(), - double d3 = -std::numeric_limits<double>::infinity(), - float f0 = std::numeric_limits<float>::quiet_NaN(), - float f1 = std::numeric_limits<float>::quiet_NaN(), - float f2 = std::numeric_limits<float>::infinity(), - float f3 = -std::numeric_limits<float>::infinity(), - const std::vector<double> *dvec = nullptr, - const std::vector<float> *fvec = nullptr) { - auto dvec__ = dvec ? _fbb.CreateVector<double>(*dvec) : 0; - auto fvec__ = fvec ? _fbb.CreateVector<float>(*fvec) : 0; - return MyGame::CreateMonsterExtra( - _fbb, - d0, - d1, - d2, - d3, - f0, - f1, - f2, - f3, - dvec__, - fvec__); -} - -::flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs) { - return - (lhs.d0 == rhs.d0) && - (lhs.d1 == rhs.d1) && - (lhs.d2 == rhs.d2) && - (lhs.d3 == rhs.d3) && - (lhs.f0 == rhs.f0) && - (lhs.f1 == rhs.f1) && - (lhs.f2 == rhs.f2) && - (lhs.f3 == rhs.f3) && - (lhs.dvec == rhs.dvec) && - (lhs.fvec == rhs.fvec); -} - -inline bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs) { - return !(lhs == rhs); -} - - -inline MonsterExtraT *MonsterExtra::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<MonsterExtraT>(new MonsterExtraT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void MonsterExtra::UnPackTo(MonsterExtraT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = d0(); _o->d0 = _e; } - { auto _e = d1(); _o->d1 = _e; } - { auto _e = d2(); _o->d2 = _e; } - { auto _e = d3(); _o->d3 = _e; } - { auto _e = f0(); _o->f0 = _e; } - { auto _e = f1(); _o->f1 = _e; } - { auto _e = f2(); _o->f2 = _e; } - { auto _e = f3(); _o->f3 = _e; } - { auto _e = dvec(); if (_e) { _o->dvec.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dvec[_i] = _e->Get(_i); } } else { _o->dvec.resize(0); } } - { auto _e = fvec(); if (_e) { _o->fvec.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->fvec[_i] = _e->Get(_i); } } else { _o->fvec.resize(0); } } -} - -inline ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return MonsterExtra::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<MonsterExtra> MonsterExtra::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MonsterExtraT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _d0 = _o->d0; - auto _d1 = _o->d1; - auto _d2 = _o->d2; - auto _d3 = _o->d3; - auto _f0 = _o->f0; - auto _f1 = _o->f1; - auto _f2 = _o->f2; - auto _f3 = _o->f3; - auto _dvec = _o->dvec.size() ? _fbb.CreateVector(_o->dvec) : 0; - auto _fvec = _o->fvec.size() ? _fbb.CreateVector(_o->fvec) : 0; - return MyGame::CreateMonsterExtra( - _fbb, - _d0, - _d1, - _d2, - _d3, - _f0, - _f1, - _f2, - _f3, - _dvec, - _fvec); -} - -inline const ::flatbuffers::TypeTable *MonsterExtraTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_DOUBLE, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 1, -1 }, - { ::flatbuffers::ET_FLOAT, 1, -1 }, - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const char * const names[] = { - "d0", - "d1", - "d2", - "d3", - "f0", - "f1", - "f2", - "f3", - "dvec", - "fvec", - "deprec" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 11, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const MyGame::MonsterExtra *GetMonsterExtra(const void *buf) { - return ::flatbuffers::GetRoot<MyGame::MonsterExtra>(buf); -} - -inline const MyGame::MonsterExtra *GetSizePrefixedMonsterExtra(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<MyGame::MonsterExtra>(buf); -} - -inline MonsterExtra *GetMutableMonsterExtra(void *buf) { - return ::flatbuffers::GetMutableRoot<MonsterExtra>(buf); -} - -inline MyGame::MonsterExtra *GetMutableSizePrefixedMonsterExtra(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::MonsterExtra>(buf); -} - -inline const char *MonsterExtraIdentifier() { - return "MONE"; -} - -inline bool MonsterExtraBufferHasIdentifier(const void *buf) { - return ::flatbuffers::BufferHasIdentifier( - buf, MonsterExtraIdentifier()); -} - -inline bool SizePrefixedMonsterExtraBufferHasIdentifier(const void *buf) { - return ::flatbuffers::BufferHasIdentifier( - buf, MonsterExtraIdentifier(), true); -} - -template <bool B = false> -inline bool VerifyMonsterExtraBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier()); -} - -template <bool B = false> -inline bool VerifySizePrefixedMonsterExtraBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier()); -} - -inline const char *MonsterExtraExtension() { - return "mon"; -} - -inline void FinishMonsterExtraBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<MyGame::MonsterExtra> root) { - fbb.Finish(root, MonsterExtraIdentifier()); -} - -inline void FinishSizePrefixedMonsterExtraBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<MyGame::MonsterExtra> root) { - fbb.FinishSizePrefixed(root, MonsterExtraIdentifier()); -} - -inline std::unique_ptr<MyGame::MonsterExtraT> UnPackMonsterExtra( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<MyGame::MonsterExtraT>(GetMonsterExtra(buf)->UnPack(res)); -} - -inline std::unique_ptr<MyGame::MonsterExtraT> UnPackSizePrefixedMonsterExtra( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<MyGame::MonsterExtraT>(GetSizePrefixedMonsterExtra(buf)->UnPack(res)); -} - -} // namespace MyGame - -#endif // FLATBUFFERS_GENERATED_MONSTEREXTRA_MYGAME_H_
diff --git a/tests/monster_test.cpp b/tests/monster_test.cpp index 9b188af..1653a9c 100644 --- a/tests/monster_test.cpp +++ b/tests/monster_test.cpp
@@ -10,7 +10,7 @@ #include "flatbuffers/registry.h" #include "flatbuffers/verifier.h" #include "is_quiet_nan.h" -#include "monster_extra_generated.h" +#include "monster_extra.fbs.h" #include "monster_test_generated.h" #include "test_assert.h"
diff --git a/tests/namespace_test/namespace_test1_generated.h b/tests/namespace_test/namespace_test1_generated.h deleted file mode 100644 index 5c3cf32..0000000 --- a/tests/namespace_test/namespace_test1_generated.h +++ /dev/null
@@ -1,470 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_H_ -#define FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace NamespaceA { -namespace NamespaceB { - -struct TableInNestedNS; -struct TableInNestedNSBuilder; -struct TableInNestedNST; - -struct StructInNestedNS; - -bool operator==(const TableInNestedNST &lhs, const TableInNestedNST &rhs); -bool operator!=(const TableInNestedNST &lhs, const TableInNestedNST &rhs); -bool operator==(const StructInNestedNS &lhs, const StructInNestedNS &rhs); -bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs); - -inline const ::flatbuffers::TypeTable *TableInNestedNSTypeTable(); - -inline const ::flatbuffers::TypeTable *StructInNestedNSTypeTable(); - -enum UnionInNestedNS : uint8_t { - UnionInNestedNS_NONE = 0, - UnionInNestedNS_TableInNestedNS = 1, - UnionInNestedNS_MIN = UnionInNestedNS_NONE, - UnionInNestedNS_MAX = UnionInNestedNS_TableInNestedNS -}; - -inline const UnionInNestedNS (&EnumValuesUnionInNestedNS())[2] { - static const UnionInNestedNS values[] = { - UnionInNestedNS_NONE, - UnionInNestedNS_TableInNestedNS - }; - return values; -} - -inline const char * const *EnumNamesUnionInNestedNS() { - static const char * const names[3] = { - "NONE", - "TableInNestedNS", - nullptr - }; - return names; -} - -inline const char *EnumNameUnionInNestedNS(UnionInNestedNS e) { - if (::flatbuffers::IsOutRange(e, UnionInNestedNS_NONE, UnionInNestedNS_TableInNestedNS)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesUnionInNestedNS()[index]; -} - -template<typename T> struct UnionInNestedNSTraits { - static const UnionInNestedNS enum_value = UnionInNestedNS_NONE; -}; - -template<> struct UnionInNestedNSTraits<NamespaceA::NamespaceB::TableInNestedNS> { - static const UnionInNestedNS enum_value = UnionInNestedNS_TableInNestedNS; -}; - -template<typename T> struct UnionInNestedNSUnionTraits { - static const UnionInNestedNS enum_value = UnionInNestedNS_NONE; -}; - -template<> struct UnionInNestedNSUnionTraits<NamespaceA::NamespaceB::TableInNestedNST> { - static const UnionInNestedNS enum_value = UnionInNestedNS_TableInNestedNS; -}; - -struct UnionInNestedNSUnion { - UnionInNestedNS type; - void *value; - - UnionInNestedNSUnion() : type(UnionInNestedNS_NONE), value(nullptr) {} - UnionInNestedNSUnion(UnionInNestedNSUnion&& u) FLATBUFFERS_NOEXCEPT : - type(UnionInNestedNS_NONE), value(nullptr) - { std::swap(type, u.type); std::swap(value, u.value); } - UnionInNestedNSUnion(const UnionInNestedNSUnion &); - UnionInNestedNSUnion &operator=(const UnionInNestedNSUnion &u) - { UnionInNestedNSUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } - UnionInNestedNSUnion &operator=(UnionInNestedNSUnion &&u) FLATBUFFERS_NOEXCEPT - { std::swap(type, u.type); std::swap(value, u.value); return *this; } - ~UnionInNestedNSUnion() { Reset(); } - - void Reset(); - - template <typename T> - void Set(T&& val) { - typedef typename std::remove_reference<T>::type RT; - Reset(); - type = UnionInNestedNSUnionTraits<RT>::enum_value; - if (type != UnionInNestedNS_NONE) { - value = new RT(std::forward<T>(val)); - } - } - - static void *UnPack(const void *obj, UnionInNestedNS type, const ::flatbuffers::resolver_function_t *resolver); - ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; - - NamespaceA::NamespaceB::TableInNestedNST *AsTableInNestedNS() { - return type == UnionInNestedNS_TableInNestedNS ? - reinterpret_cast<NamespaceA::NamespaceB::TableInNestedNST *>(value) : nullptr; - } - const NamespaceA::NamespaceB::TableInNestedNST *AsTableInNestedNS() const { - return type == UnionInNestedNS_TableInNestedNS ? - reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(value) : nullptr; - } -}; - - -inline bool operator==(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUnion &rhs) { - if (lhs.type != rhs.type) return false; - switch (lhs.type) { - case UnionInNestedNS_NONE: { - return true; - } - case UnionInNestedNS_TableInNestedNS: { - return *(reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(lhs.value)) == - *(reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(rhs.value)); - } - default: { - return false; - } - } -} - -inline bool operator!=(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUnion &rhs) { - return !(lhs == rhs); -} - -template <bool B = false> -bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, UnionInNestedNS type); -template <bool B = false> -bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types); - -enum EnumInNestedNS : int8_t { - EnumInNestedNS_A = 0, - EnumInNestedNS_B = 1, - EnumInNestedNS_C = 2, - EnumInNestedNS_MIN = EnumInNestedNS_A, - EnumInNestedNS_MAX = EnumInNestedNS_C -}; - -inline const EnumInNestedNS (&EnumValuesEnumInNestedNS())[3] { - static const EnumInNestedNS values[] = { - EnumInNestedNS_A, - EnumInNestedNS_B, - EnumInNestedNS_C - }; - return values; -} - -inline const char * const *EnumNamesEnumInNestedNS() { - static const char * const names[4] = { - "A", - "B", - "C", - nullptr - }; - return names; -} - -inline const char *EnumNameEnumInNestedNS(EnumInNestedNS e) { - if (::flatbuffers::IsOutRange(e, EnumInNestedNS_A, EnumInNestedNS_C)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesEnumInNestedNS()[index]; -} - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS { - private: - int32_t a_; - int32_t b_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return StructInNestedNSTypeTable(); - } - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceA.NamespaceB.StructInNestedNS"; - } - StructInNestedNS() - : a_(0), - b_(0) { - } - 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); - } -}; -FLATBUFFERS_STRUCT_END(StructInNestedNS, 8); - -inline bool operator==(const StructInNestedNS &lhs, const StructInNestedNS &rhs) { - return - (lhs.a() == rhs.a()) && - (lhs.b() == rhs.b()); -} - -inline bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs) { - return !(lhs == rhs); -} - - -struct TableInNestedNST : public ::flatbuffers::NativeTable { - typedef TableInNestedNS TableType; - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceA.NamespaceB.TableInNestedNST"; - } - int32_t foo = 0; -}; - -struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableInNestedNST NativeTableType; - typedef TableInNestedNSBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return TableInNestedNSTypeTable(); - } - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceA.NamespaceB.TableInNestedNS"; - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FOO = 4 - }; - int32_t foo() const { - return GetField<int32_t>(VT_FOO, 0); - } - bool mutate_foo(int32_t _foo = 0) { - return SetField<int32_t>(VT_FOO, _foo, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_FOO, 4) && - verifier.EndTable(); - } - TableInNestedNST *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TableInNestedNST *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<TableInNestedNS> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct TableInNestedNSBuilder { - typedef TableInNestedNS Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_foo(int32_t foo) { - fbb_.AddElement<int32_t>(TableInNestedNS::VT_FOO, foo, 0); - } - explicit TableInNestedNSBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableInNestedNS> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableInNestedNS>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t foo = 0) { - TableInNestedNSBuilder builder_(_fbb); - builder_.add_foo(foo); - return builder_.Finish(); -} - -::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const TableInNestedNST &lhs, const TableInNestedNST &rhs) { - return - (lhs.foo == rhs.foo); -} - -inline bool operator!=(const TableInNestedNST &lhs, const TableInNestedNST &rhs) { - return !(lhs == rhs); -} - - -inline TableInNestedNST *TableInNestedNS::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<TableInNestedNST>(new TableInNestedNST()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void TableInNestedNS::UnPackTo(TableInNestedNST *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = foo(); _o->foo = _e; } -} - -inline ::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return TableInNestedNS::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<TableInNestedNS> TableInNestedNS::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TableInNestedNST* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _foo = _o->foo; - return NamespaceA::NamespaceB::CreateTableInNestedNS( - _fbb, - _foo); -} - -template <bool B> -inline bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, UnionInNestedNS type) { - switch (type) { - case UnionInNestedNS_NONE: { - return true; - } - case UnionInNestedNS_TableInNestedNS: { - auto ptr = reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNS *>(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -template <bool B> -inline bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyUnionInNestedNS( - verifier, values->Get(i), types->GetEnum<UnionInNestedNS>(i))) { - return false; - } - } - return true; -} - -inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type, const ::flatbuffers::resolver_function_t *resolver) { - (void)resolver; - switch (type) { - case UnionInNestedNS_TableInNestedNS: { - auto ptr = reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNS *>(obj); - return ptr->UnPack(resolver); - } - default: return nullptr; - } -} - -inline ::flatbuffers::Offset<void> UnionInNestedNSUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { - (void)_rehasher; - switch (type) { - case UnionInNestedNS_TableInNestedNS: { - auto ptr = reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(value); - return CreateTableInNestedNS(_fbb, ptr, _rehasher).Union(); - } - default: return 0; - } -} - -inline UnionInNestedNSUnion::UnionInNestedNSUnion(const UnionInNestedNSUnion &u) : type(u.type), value(nullptr) { - switch (type) { - case UnionInNestedNS_TableInNestedNS: { - value = new NamespaceA::NamespaceB::TableInNestedNST(*reinterpret_cast<NamespaceA::NamespaceB::TableInNestedNST *>(u.value)); - break; - } - default: - break; - } -} - -inline void UnionInNestedNSUnion::Reset() { - switch (type) { - case UnionInNestedNS_TableInNestedNS: { - auto ptr = reinterpret_cast<NamespaceA::NamespaceB::TableInNestedNST *>(value); - delete ptr; - break; - } - default: break; - } - value = nullptr; - type = UnionInNestedNS_NONE; -} - -inline const ::flatbuffers::TypeTable *UnionInNestedNSTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, -1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - NamespaceA::NamespaceB::TableInNestedNSTypeTable - }; - static const char * const names[] = { - "NONE", - "TableInNestedNS" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *EnumInNestedNSTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_CHAR, 0, 0 }, - { ::flatbuffers::ET_CHAR, 0, 0 }, - { ::flatbuffers::ET_CHAR, 0, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - NamespaceA::NamespaceB::EnumInNestedNSTypeTable - }; - static const char * const names[] = { - "A", - "B", - "C" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *TableInNestedNSTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const char * const names[] = { - "foo" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *StructInNestedNSTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const int64_t values[] = { 0, 4, 8 }; - static const char * const names[] = { - "a", - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names - }; - return &tt; -} - -} // namespace NamespaceB -} // namespace NamespaceA - -#endif // FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_H_
diff --git a/tests/namespace_test/namespace_test2_generated.h b/tests/namespace_test/namespace_test2_generated.h deleted file mode 100644 index 416c9ff..0000000 --- a/tests/namespace_test/namespace_test2_generated.h +++ /dev/null
@@ -1,614 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_ -#define FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace NamespaceA { - -struct TableInFirstNS; -struct TableInFirstNSBuilder; -struct TableInFirstNST; - -} // namespace NamespaceA - -namespace NamespaceC { - -struct TableInC; -struct TableInCBuilder; -struct TableInCT; - -} // namespace NamespaceC - -namespace NamespaceA { - -struct SecondTableInA; -struct SecondTableInABuilder; -struct SecondTableInAT; - -bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs); -bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs); -} // namespace NamespaceA - -namespace NamespaceC { - -bool operator==(const TableInCT &lhs, const TableInCT &rhs); -bool operator!=(const TableInCT &lhs, const TableInCT &rhs); -} // namespace NamespaceC - -namespace NamespaceA { - -bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs); -bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs); - -inline const ::flatbuffers::TypeTable *TableInFirstNSTypeTable(); - -} // namespace NamespaceA - -namespace NamespaceC { - -inline const ::flatbuffers::TypeTable *TableInCTypeTable(); - -} // namespace NamespaceC - -namespace NamespaceA { - -inline const ::flatbuffers::TypeTable *SecondTableInATypeTable(); - -struct TableInFirstNST : public ::flatbuffers::NativeTable { - typedef TableInFirstNS TableType; - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceA.TableInFirstNST"; - } - std::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST> foo_table{}; - NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A; - NamespaceA::NamespaceB::UnionInNestedNSUnion foo_union{}; - std::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS> foo_struct{}; - TableInFirstNST() = default; - TableInFirstNST(const TableInFirstNST &o); - TableInFirstNST(TableInFirstNST&&) FLATBUFFERS_NOEXCEPT = default; - TableInFirstNST &operator=(TableInFirstNST o) FLATBUFFERS_NOEXCEPT; -}; - -struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableInFirstNST NativeTableType; - typedef TableInFirstNSBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return TableInFirstNSTypeTable(); - } - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceA.TableInFirstNS"; - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FOO_TABLE = 4, - VT_FOO_ENUM = 6, - VT_FOO_UNION_TYPE = 8, - VT_FOO_UNION = 10, - VT_FOO_STRUCT = 12 - }; - const NamespaceA::NamespaceB::TableInNestedNS *foo_table() const { - return GetPointer<const NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE); - } - NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_table() { - return GetPointer<NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE); - } - NamespaceA::NamespaceB::EnumInNestedNS foo_enum() const { - return static_cast<NamespaceA::NamespaceB::EnumInNestedNS>(GetField<int8_t>(VT_FOO_ENUM, 0)); - } - bool mutate_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS _foo_enum = static_cast<NamespaceA::NamespaceB::EnumInNestedNS>(0)) { - return SetField<int8_t>(VT_FOO_ENUM, static_cast<int8_t>(_foo_enum), 0); - } - NamespaceA::NamespaceB::UnionInNestedNS foo_union_type() const { - return static_cast<NamespaceA::NamespaceB::UnionInNestedNS>(GetField<uint8_t>(VT_FOO_UNION_TYPE, 0)); - } - const void *foo_union() const { - return GetPointer<const void *>(VT_FOO_UNION); - } - template<typename T> const T *foo_union_as() const; - const NamespaceA::NamespaceB::TableInNestedNS *foo_union_as_TableInNestedNS() const { - return foo_union_type() == NamespaceA::NamespaceB::UnionInNestedNS_TableInNestedNS ? static_cast<const NamespaceA::NamespaceB::TableInNestedNS *>(foo_union()) : nullptr; - } - template<typename T> T *mutable_foo_union_as(); - NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_union_as_TableInNestedNS() { - return foo_union_type() == NamespaceA::NamespaceB::UnionInNestedNS_TableInNestedNS ? static_cast<NamespaceA::NamespaceB::TableInNestedNS *>(mutable_foo_union()) : nullptr; - } - void *mutable_foo_union() { - return GetPointer<void *>(VT_FOO_UNION); - } - const NamespaceA::NamespaceB::StructInNestedNS *foo_struct() const { - return GetStruct<const NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT); - } - NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() { - return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_FOO_TABLE) && - verifier.VerifyTable(foo_table()) && - VerifyField<int8_t>(verifier, VT_FOO_ENUM, 1) && - VerifyField<uint8_t>(verifier, VT_FOO_UNION_TYPE, 1) && - VerifyOffset(verifier, VT_FOO_UNION) && - VerifyUnionInNestedNS(verifier, foo_union(), foo_union_type()) && - VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT, 4) && - verifier.EndTable(); - } - TableInFirstNST *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TableInFirstNST *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<TableInFirstNS> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS::foo_union_as<NamespaceA::NamespaceB::TableInNestedNS>() const { - return foo_union_as_TableInNestedNS(); -} - -template<> inline NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS::mutable_foo_union_as<NamespaceA::NamespaceB::TableInNestedNS>() { - return mutable_foo_union_as_TableInNestedNS(); -} - -struct TableInFirstNSBuilder { - typedef TableInFirstNS Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_foo_table(::flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) { - fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table); - } - void add_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS foo_enum) { - fbb_.AddElement<int8_t>(TableInFirstNS::VT_FOO_ENUM, static_cast<int8_t>(foo_enum), 0); - } - void add_foo_union_type(NamespaceA::NamespaceB::UnionInNestedNS foo_union_type) { - fbb_.AddElement<uint8_t>(TableInFirstNS::VT_FOO_UNION_TYPE, static_cast<uint8_t>(foo_union_type), 0); - } - void add_foo_union(::flatbuffers::Offset<void> foo_union) { - fbb_.AddOffset(TableInFirstNS::VT_FOO_UNION, foo_union); - } - void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) { - fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct); - } - explicit TableInFirstNSBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableInFirstNS> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableInFirstNS>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS( - ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table = 0, - NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A, - NamespaceA::NamespaceB::UnionInNestedNS foo_union_type = NamespaceA::NamespaceB::UnionInNestedNS_NONE, - ::flatbuffers::Offset<void> foo_union = 0, - const NamespaceA::NamespaceB::StructInNestedNS *foo_struct = nullptr) { - TableInFirstNSBuilder builder_(_fbb); - builder_.add_foo_struct(foo_struct); - builder_.add_foo_union(foo_union); - builder_.add_foo_table(foo_table); - builder_.add_foo_union_type(foo_union_type); - builder_.add_foo_enum(foo_enum); - return builder_.Finish(); -} - -::flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -} // namespace NamespaceA - -namespace NamespaceC { - -struct TableInCT : public ::flatbuffers::NativeTable { - typedef TableInC TableType; - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceC.TableInCT"; - } - std::unique_ptr<NamespaceA::TableInFirstNST> refer_to_a1{}; - std::unique_ptr<NamespaceA::SecondTableInAT> refer_to_a2{}; - TableInCT() = default; - TableInCT(const TableInCT &o); - TableInCT(TableInCT&&) FLATBUFFERS_NOEXCEPT = default; - TableInCT &operator=(TableInCT o) FLATBUFFERS_NOEXCEPT; -}; - -struct TableInC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TableInCT NativeTableType; - typedef TableInCBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return TableInCTypeTable(); - } - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceC.TableInC"; - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_REFER_TO_A1 = 4, - VT_REFER_TO_A2 = 6 - }; - const NamespaceA::TableInFirstNS *refer_to_a1() const { - return GetPointer<const NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1); - } - NamespaceA::TableInFirstNS *mutable_refer_to_a1() { - return GetPointer<NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1); - } - const NamespaceA::SecondTableInA *refer_to_a2() const { - return GetPointer<const NamespaceA::SecondTableInA *>(VT_REFER_TO_A2); - } - NamespaceA::SecondTableInA *mutable_refer_to_a2() { - return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_REFER_TO_A1) && - verifier.VerifyTable(refer_to_a1()) && - VerifyOffset(verifier, VT_REFER_TO_A2) && - verifier.VerifyTable(refer_to_a2()) && - verifier.EndTable(); - } - TableInCT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TableInCT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<TableInC> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct TableInCBuilder { - typedef TableInC Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_refer_to_a1(::flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) { - fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1); - } - void add_refer_to_a2(::flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) { - fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2); - } - explicit TableInCBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TableInC> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TableInC>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TableInC> CreateTableInC( - ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1 = 0, - ::flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2 = 0) { - TableInCBuilder builder_(_fbb); - builder_.add_refer_to_a2(refer_to_a2); - builder_.add_refer_to_a1(refer_to_a1); - return builder_.Finish(); -} - -::flatbuffers::Offset<TableInC> CreateTableInC(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -} // namespace NamespaceC - -namespace NamespaceA { - -struct SecondTableInAT : public ::flatbuffers::NativeTable { - typedef SecondTableInA TableType; - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceA.SecondTableInAT"; - } - std::unique_ptr<NamespaceC::TableInCT> refer_to_c{}; - SecondTableInAT() = default; - SecondTableInAT(const SecondTableInAT &o); - SecondTableInAT(SecondTableInAT&&) FLATBUFFERS_NOEXCEPT = default; - SecondTableInAT &operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT; -}; - -struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef SecondTableInAT NativeTableType; - typedef SecondTableInABuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return SecondTableInATypeTable(); - } - static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "NamespaceA.SecondTableInA"; - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_REFER_TO_C = 4 - }; - const NamespaceC::TableInC *refer_to_c() const { - return GetPointer<const NamespaceC::TableInC *>(VT_REFER_TO_C); - } - NamespaceC::TableInC *mutable_refer_to_c() { - return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_REFER_TO_C) && - verifier.VerifyTable(refer_to_c()) && - verifier.EndTable(); - } - SecondTableInAT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SecondTableInAT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<SecondTableInA> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct SecondTableInABuilder { - typedef SecondTableInA Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_refer_to_c(::flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) { - fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c); - } - explicit SecondTableInABuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<SecondTableInA> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<SecondTableInA>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<SecondTableInA> CreateSecondTableInA( - ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<NamespaceC::TableInC> refer_to_c = 0) { - SecondTableInABuilder builder_(_fbb); - builder_.add_refer_to_c(refer_to_c); - return builder_.Finish(); -} - -::flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs) { - return - ((lhs.foo_table == rhs.foo_table) || (lhs.foo_table && rhs.foo_table && *lhs.foo_table == *rhs.foo_table)) && - (lhs.foo_enum == rhs.foo_enum) && - (lhs.foo_union == rhs.foo_union) && - ((lhs.foo_struct == rhs.foo_struct) || (lhs.foo_struct && rhs.foo_struct && *lhs.foo_struct == *rhs.foo_struct)); -} - -inline bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs) { - return !(lhs == rhs); -} - - -inline TableInFirstNST::TableInFirstNST(const TableInFirstNST &o) - : foo_table((o.foo_table) ? new NamespaceA::NamespaceB::TableInNestedNST(*o.foo_table) : nullptr), - foo_enum(o.foo_enum), - foo_union(o.foo_union), - foo_struct((o.foo_struct) ? new NamespaceA::NamespaceB::StructInNestedNS(*o.foo_struct) : nullptr) { -} - -inline TableInFirstNST &TableInFirstNST::operator=(TableInFirstNST o) FLATBUFFERS_NOEXCEPT { - std::swap(foo_table, o.foo_table); - std::swap(foo_enum, o.foo_enum); - std::swap(foo_union, o.foo_union); - std::swap(foo_struct, o.foo_struct); - return *this; -} - -inline TableInFirstNST *TableInFirstNS::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<TableInFirstNST>(new TableInFirstNST()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void TableInFirstNS::UnPackTo(TableInFirstNST *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = foo_table(); if (_e) { if(_o->foo_table) { _e->UnPackTo(_o->foo_table.get(), _resolver); } else { _o->foo_table = std::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST>(_e->UnPack(_resolver)); } } else if (_o->foo_table) { _o->foo_table.reset(); } } - { auto _e = foo_enum(); _o->foo_enum = _e; } - { auto _e = foo_union_type(); _o->foo_union.type = _e; } - { auto _e = foo_union(); if (_e) _o->foo_union.value = NamespaceA::NamespaceB::UnionInNestedNSUnion::UnPack(_e, foo_union_type(), _resolver); } - { auto _e = foo_struct(); if (_e) _o->foo_struct = std::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS>(new NamespaceA::NamespaceB::StructInNestedNS(*_e)); } -} - -inline ::flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return TableInFirstNS::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<TableInFirstNS> TableInFirstNS::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TableInFirstNST* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _foo_table = _o->foo_table ? CreateTableInNestedNS(_fbb, _o->foo_table.get(), _rehasher) : 0; - auto _foo_enum = _o->foo_enum; - auto _foo_union_type = _o->foo_union.type; - auto _foo_union = _o->foo_union.Pack(_fbb); - auto _foo_struct = _o->foo_struct ? _o->foo_struct.get() : nullptr; - return NamespaceA::CreateTableInFirstNS( - _fbb, - _foo_table, - _foo_enum, - _foo_union_type, - _foo_union, - _foo_struct); -} - -} // namespace NamespaceA - -namespace NamespaceC { - - -inline bool operator==(const TableInCT &lhs, const TableInCT &rhs) { - return - ((lhs.refer_to_a1 == rhs.refer_to_a1) || (lhs.refer_to_a1 && rhs.refer_to_a1 && *lhs.refer_to_a1 == *rhs.refer_to_a1)) && - ((lhs.refer_to_a2 == rhs.refer_to_a2) || (lhs.refer_to_a2 && rhs.refer_to_a2 && *lhs.refer_to_a2 == *rhs.refer_to_a2)); -} - -inline bool operator!=(const TableInCT &lhs, const TableInCT &rhs) { - return !(lhs == rhs); -} - - -inline TableInCT::TableInCT(const TableInCT &o) - : refer_to_a1((o.refer_to_a1) ? new NamespaceA::TableInFirstNST(*o.refer_to_a1) : nullptr), - refer_to_a2((o.refer_to_a2) ? new NamespaceA::SecondTableInAT(*o.refer_to_a2) : nullptr) { -} - -inline TableInCT &TableInCT::operator=(TableInCT o) FLATBUFFERS_NOEXCEPT { - std::swap(refer_to_a1, o.refer_to_a1); - std::swap(refer_to_a2, o.refer_to_a2); - return *this; -} - -inline TableInCT *TableInC::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<TableInCT>(new TableInCT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void TableInC::UnPackTo(TableInCT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = refer_to_a1(); if (_e) { if(_o->refer_to_a1) { _e->UnPackTo(_o->refer_to_a1.get(), _resolver); } else { _o->refer_to_a1 = std::unique_ptr<NamespaceA::TableInFirstNST>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a1) { _o->refer_to_a1.reset(); } } - { auto _e = refer_to_a2(); if (_e) { if(_o->refer_to_a2) { _e->UnPackTo(_o->refer_to_a2.get(), _resolver); } else { _o->refer_to_a2 = std::unique_ptr<NamespaceA::SecondTableInAT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a2) { _o->refer_to_a2.reset(); } } -} - -inline ::flatbuffers::Offset<TableInC> CreateTableInC(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return TableInC::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<TableInC> TableInC::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TableInCT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _refer_to_a1 = _o->refer_to_a1 ? CreateTableInFirstNS(_fbb, _o->refer_to_a1.get(), _rehasher) : 0; - auto _refer_to_a2 = _o->refer_to_a2 ? CreateSecondTableInA(_fbb, _o->refer_to_a2.get(), _rehasher) : 0; - return NamespaceC::CreateTableInC( - _fbb, - _refer_to_a1, - _refer_to_a2); -} - -} // namespace NamespaceC - -namespace NamespaceA { - - -inline bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs) { - return - ((lhs.refer_to_c == rhs.refer_to_c) || (lhs.refer_to_c && rhs.refer_to_c && *lhs.refer_to_c == *rhs.refer_to_c)); -} - -inline bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs) { - return !(lhs == rhs); -} - - -inline SecondTableInAT::SecondTableInAT(const SecondTableInAT &o) - : refer_to_c((o.refer_to_c) ? new NamespaceC::TableInCT(*o.refer_to_c) : nullptr) { -} - -inline SecondTableInAT &SecondTableInAT::operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT { - std::swap(refer_to_c, o.refer_to_c); - return *this; -} - -inline SecondTableInAT *SecondTableInA::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<SecondTableInAT>(new SecondTableInAT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void SecondTableInA::UnPackTo(SecondTableInAT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = refer_to_c(); if (_e) { if(_o->refer_to_c) { _e->UnPackTo(_o->refer_to_c.get(), _resolver); } else { _o->refer_to_c = std::unique_ptr<NamespaceC::TableInCT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_c) { _o->refer_to_c.reset(); } } -} - -inline ::flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return SecondTableInA::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<SecondTableInA> SecondTableInA::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SecondTableInAT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _refer_to_c = _o->refer_to_c ? CreateTableInC(_fbb, _o->refer_to_c.get(), _rehasher) : 0; - return NamespaceA::CreateSecondTableInA( - _fbb, - _refer_to_c); -} - -inline const ::flatbuffers::TypeTable *TableInFirstNSTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_CHAR, 0, 1 }, - { ::flatbuffers::ET_UTYPE, 0, 2 }, - { ::flatbuffers::ET_SEQUENCE, 0, 2 }, - { ::flatbuffers::ET_SEQUENCE, 0, 3 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - NamespaceA::NamespaceB::TableInNestedNSTypeTable, - NamespaceA::NamespaceB::EnumInNestedNSTypeTable, - NamespaceA::NamespaceB::UnionInNestedNSTypeTable, - NamespaceA::NamespaceB::StructInNestedNSTypeTable - }; - static const char * const names[] = { - "foo_table", - "foo_enum", - "foo_union_type", - "foo_union", - "foo_struct" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -} // namespace NamespaceA - -namespace NamespaceC { - -inline const ::flatbuffers::TypeTable *TableInCTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 1 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - NamespaceA::TableInFirstNSTypeTable, - NamespaceA::SecondTableInATypeTable - }; - static const char * const names[] = { - "refer_to_a1", - "refer_to_a2" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -} // namespace NamespaceC - -namespace NamespaceA { - -inline const ::flatbuffers::TypeTable *SecondTableInATypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - NamespaceC::TableInCTypeTable - }; - static const char * const names[] = { - "refer_to_c" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -} // namespace NamespaceA - -#endif // FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_
diff --git a/tests/native_inline_table_test_generated.h b/tests/native_inline_table_test_generated.h deleted file mode 100644 index fca98f6..0000000 --- a/tests/native_inline_table_test_generated.h +++ /dev/null
@@ -1,265 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_NATIVEINLINETABLETEST_H_ -#define FLATBUFFERS_GENERATED_NATIVEINLINETABLETEST_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -struct NativeInlineTable; -struct NativeInlineTableBuilder; -struct NativeInlineTableT; - -struct TestNativeInlineTable; -struct TestNativeInlineTableBuilder; -struct TestNativeInlineTableT; - -bool operator==(const NativeInlineTableT &lhs, const NativeInlineTableT &rhs); -bool operator!=(const NativeInlineTableT &lhs, const NativeInlineTableT &rhs); -bool operator==(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs); -bool operator!=(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs); - -inline const ::flatbuffers::TypeTable *NativeInlineTableTypeTable(); - -inline const ::flatbuffers::TypeTable *TestNativeInlineTableTypeTable(); - -struct NativeInlineTableT : public ::flatbuffers::NativeTable { - typedef NativeInlineTable TableType; - int32_t a = 0; -}; - -struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef NativeInlineTableT NativeTableType; - typedef NativeInlineTableBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return NativeInlineTableTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4 - }; - int32_t a() const { - return GetField<int32_t>(VT_A, 0); - } - bool mutate_a(int32_t _a = 0) { - return SetField<int32_t>(VT_A, _a, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_A, 4) && - verifier.EndTable(); - } - NativeInlineTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(NativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<NativeInlineTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct NativeInlineTableBuilder { - typedef NativeInlineTable Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(int32_t a) { - fbb_.AddElement<int32_t>(NativeInlineTable::VT_A, a, 0); - } - explicit NativeInlineTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<NativeInlineTable> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<NativeInlineTable>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0) { - NativeInlineTableBuilder builder_(_fbb); - builder_.add_a(a); - return builder_.Finish(); -} - -::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct TestNativeInlineTableT : public ::flatbuffers::NativeTable { - typedef TestNativeInlineTable TableType; - std::vector<NativeInlineTableT> t{}; -}; - -struct TestNativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef TestNativeInlineTableT NativeTableType; - typedef TestNativeInlineTableBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return TestNativeInlineTableTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_T = 4 - }; - const ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *t() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *>(VT_T); - } - ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *mutable_t() { - return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *>(VT_T); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_T) && - verifier.VerifyVector(t()) && - verifier.VerifyVectorOfTables(t()) && - verifier.EndTable(); - } - TestNativeInlineTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TestNativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<TestNativeInlineTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct TestNativeInlineTableBuilder { - typedef TestNativeInlineTable Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_t(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>>> t) { - fbb_.AddOffset(TestNativeInlineTable::VT_T, t); - } - explicit TestNativeInlineTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<TestNativeInlineTable> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<TestNativeInlineTable>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable( - ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>>> t = 0) { - TestNativeInlineTableBuilder builder_(_fbb); - builder_.add_t(t); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTableDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - const std::vector<::flatbuffers::Offset<NativeInlineTable>> *t = nullptr) { - auto t__ = t ? _fbb.CreateVector<::flatbuffers::Offset<NativeInlineTable>>(*t) : 0; - return CreateTestNativeInlineTable( - _fbb, - t__); -} - -::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const NativeInlineTableT &lhs, const NativeInlineTableT &rhs) { - return - (lhs.a == rhs.a); -} - -inline bool operator!=(const NativeInlineTableT &lhs, const NativeInlineTableT &rhs) { - return !(lhs == rhs); -} - - -inline NativeInlineTableT *NativeInlineTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<NativeInlineTableT>(new NativeInlineTableT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void NativeInlineTable::UnPackTo(NativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = a(); _o->a = _e; } -} - -inline ::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return NativeInlineTable::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<NativeInlineTable> NativeInlineTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const NativeInlineTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _a = _o->a; - return CreateNativeInlineTable( - _fbb, - _a); -} - - -inline bool operator==(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs) { - return - (lhs.t == rhs.t); -} - -inline bool operator!=(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs) { - return !(lhs == rhs); -} - - -inline TestNativeInlineTableT *TestNativeInlineTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<TestNativeInlineTableT>(new TestNativeInlineTableT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void TestNativeInlineTable::UnPackTo(TestNativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = t(); if (_e) { _o->t.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->t[_i] = *std::unique_ptr<NativeInlineTableT>(_e->Get(_i)->UnPack(_resolver)); } } else { _o->t.resize(0); } } -} - -inline ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return TestNativeInlineTable::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<TestNativeInlineTable> TestNativeInlineTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TestNativeInlineTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _t = _o->t.size() ? _fbb.CreateVector<::flatbuffers::Offset<NativeInlineTable>> (_o->t.size(), [](size_t i, _VectorArgs *__va) { return CreateNativeInlineTable(*__va->__fbb, &(__va->__o->t[i]), __va->__rehasher); }, &_va ) : 0; - return CreateTestNativeInlineTable( - _fbb, - _t); -} - -inline const ::flatbuffers::TypeTable *NativeInlineTableTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const char * const names[] = { - "a" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *TestNativeInlineTableTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 1, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - NativeInlineTableTypeTable - }; - static const char * const names[] = { - "t" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -#endif // FLATBUFFERS_GENERATED_NATIVEINLINETABLETEST_H_
diff --git a/tests/native_type_test_generated.h b/tests/native_type_test_generated.h deleted file mode 100644 index a401e72..0000000 --- a/tests/native_type_test_generated.h +++ /dev/null
@@ -1,599 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_NATIVETYPETEST_GEOMETRY_H_ -#define FLATBUFFERS_GENERATED_NATIVETYPETEST_GEOMETRY_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -#include "native_type_test_impl.h" - -namespace Geometry { - -struct Vector3D; - -struct Vector3DAlt; - -struct Matrix; -struct MatrixBuilder; - -struct ApplicationData; -struct ApplicationDataBuilder; -struct ApplicationDataT; - -bool operator==(const ApplicationDataT &lhs, const ApplicationDataT &rhs); -bool operator!=(const ApplicationDataT &lhs, const ApplicationDataT &rhs); - -inline const ::flatbuffers::TypeTable *Vector3DTypeTable(); - -inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable(); - -inline const ::flatbuffers::TypeTable *MatrixTypeTable(); - -inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable(); - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS { - private: - float x_; - float y_; - float z_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return Vector3DTypeTable(); - } - Vector3D() - : x_(0), - y_(0), - z_(0) { - } - Vector3D(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); - } -}; -FLATBUFFERS_STRUCT_END(Vector3D, 12); - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS { - private: - float a_; - float b_; - float c_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return Vector3DAltTypeTable(); - } - Vector3DAlt() - : a_(0), - b_(0), - c_(0) { - } - Vector3DAlt(float _a, float _b, float _c) - : a_(::flatbuffers::EndianScalar(_a)), - b_(::flatbuffers::EndianScalar(_b)), - c_(::flatbuffers::EndianScalar(_c)) { - } - float a() const { - return ::flatbuffers::EndianScalar(a_); - } - void mutate_a(float _a) { - ::flatbuffers::WriteScalar(&a_, _a); - } - float b() const { - return ::flatbuffers::EndianScalar(b_); - } - void mutate_b(float _b) { - ::flatbuffers::WriteScalar(&b_, _b); - } - float c() const { - return ::flatbuffers::EndianScalar(c_); - } - void mutate_c(float _c) { - ::flatbuffers::WriteScalar(&c_, _c); - } -}; -FLATBUFFERS_STRUCT_END(Vector3DAlt, 12); - -struct Matrix FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef Native::Matrix NativeTableType; - typedef MatrixBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return MatrixTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ROWS = 4, - VT_COLUMNS = 6, - VT_VALUES = 8 - }; - int32_t rows() const { - return GetField<int32_t>(VT_ROWS, 0); - } - bool mutate_rows(int32_t _rows = 0) { - return SetField<int32_t>(VT_ROWS, _rows, 0); - } - int32_t columns() const { - return GetField<int32_t>(VT_COLUMNS, 0); - } - bool mutate_columns(int32_t _columns = 0) { - return SetField<int32_t>(VT_COLUMNS, _columns, 0); - } - const ::flatbuffers::Vector<float> *values() const { - return GetPointer<const ::flatbuffers::Vector<float> *>(VT_VALUES); - } - ::flatbuffers::Vector<float> *mutable_values() { - return GetPointer<::flatbuffers::Vector<float> *>(VT_VALUES); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_ROWS, 4) && - VerifyField<int32_t>(verifier, VT_COLUMNS, 4) && - VerifyOffset(verifier, VT_VALUES) && - verifier.VerifyVector(values()) && - verifier.EndTable(); - } - Native::Matrix *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Native::Matrix *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<Matrix> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Native::Matrix* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct MatrixBuilder { - typedef Matrix Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_rows(int32_t rows) { - fbb_.AddElement<int32_t>(Matrix::VT_ROWS, rows, 0); - } - void add_columns(int32_t columns) { - fbb_.AddElement<int32_t>(Matrix::VT_COLUMNS, columns, 0); - } - void add_values(::flatbuffers::Offset<::flatbuffers::Vector<float>> values) { - fbb_.AddOffset(Matrix::VT_VALUES, values); - } - explicit MatrixBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<Matrix> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<Matrix>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<Matrix> CreateMatrix( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t rows = 0, - int32_t columns = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<float>> values = 0) { - MatrixBuilder builder_(_fbb); - builder_.add_values(values); - builder_.add_columns(columns); - builder_.add_rows(rows); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<Matrix> CreateMatrixDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t rows = 0, - int32_t columns = 0, - const std::vector<float> *values = nullptr) { - auto values__ = values ? _fbb.CreateVector<float>(*values) : 0; - return Geometry::CreateMatrix( - _fbb, - rows, - columns, - values__); -} - -::flatbuffers::Offset<Matrix> CreateMatrix(::flatbuffers::FlatBufferBuilder &_fbb, const Native::Matrix *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct ApplicationDataT : public ::flatbuffers::NativeTable { - typedef ApplicationData TableType; - std::vector<Native::Vector3D> vectors{}; - std::vector<Native::Vector3D> vectors_alt{}; - std::unique_ptr<Native::Vector3D> position{}; - Native::Vector3D position_inline{}; - std::unique_ptr<Native::Matrix> matrix{}; - std::vector<std::unique_ptr<Native::Matrix>> matrices{}; - ApplicationDataT() = default; - ApplicationDataT(const ApplicationDataT &o); - ApplicationDataT(ApplicationDataT&&) FLATBUFFERS_NOEXCEPT = default; - ApplicationDataT &operator=(ApplicationDataT o) FLATBUFFERS_NOEXCEPT; -}; - -struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef ApplicationDataT NativeTableType; - typedef ApplicationDataBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return ApplicationDataTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_VECTORS = 4, - VT_VECTORS_ALT = 6, - VT_POSITION = 8, - VT_POSITION_INLINE = 10, - VT_MATRIX = 12, - VT_MATRICES = 14 - }; - const ::flatbuffers::Vector<const Geometry::Vector3D *> *vectors() const { - return GetPointer<const ::flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS); - } - ::flatbuffers::Vector<const Geometry::Vector3D *> *mutable_vectors() { - return GetPointer<::flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS); - } - const ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *vectors_alt() const { - return GetPointer<const ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT); - } - ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *mutable_vectors_alt() { - return GetPointer<::flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT); - } - const Geometry::Vector3D *position() const { - return GetStruct<const Geometry::Vector3D *>(VT_POSITION); - } - Geometry::Vector3D *mutable_position() { - return GetStruct<Geometry::Vector3D *>(VT_POSITION); - } - const Geometry::Vector3D *position_inline() const { - return GetStruct<const Geometry::Vector3D *>(VT_POSITION_INLINE); - } - Geometry::Vector3D *mutable_position_inline() { - return GetStruct<Geometry::Vector3D *>(VT_POSITION_INLINE); - } - const Geometry::Matrix *matrix() const { - return GetPointer<const Geometry::Matrix *>(VT_MATRIX); - } - Geometry::Matrix *mutable_matrix() { - return GetPointer<Geometry::Matrix *>(VT_MATRIX); - } - const ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *matrices() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *>(VT_MATRICES); - } - ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *mutable_matrices() { - return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *>(VT_MATRICES); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_VECTORS) && - verifier.VerifyVector(vectors()) && - VerifyOffset(verifier, VT_VECTORS_ALT) && - verifier.VerifyVector(vectors_alt()) && - VerifyField<Geometry::Vector3D>(verifier, VT_POSITION, 4) && - VerifyField<Geometry::Vector3D>(verifier, VT_POSITION_INLINE, 4) && - VerifyOffset(verifier, VT_MATRIX) && - verifier.VerifyTable(matrix()) && - VerifyOffset(verifier, VT_MATRICES) && - verifier.VerifyVector(matrices()) && - verifier.VerifyVectorOfTables(matrices()) && - verifier.EndTable(); - } - ApplicationDataT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ApplicationDataT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<ApplicationData> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct ApplicationDataBuilder { - typedef ApplicationData Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_vectors(::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3D *>> vectors) { - fbb_.AddOffset(ApplicationData::VT_VECTORS, vectors); - } - void add_vectors_alt(::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt) { - fbb_.AddOffset(ApplicationData::VT_VECTORS_ALT, vectors_alt); - } - void add_position(const Geometry::Vector3D *position) { - fbb_.AddStruct(ApplicationData::VT_POSITION, position); - } - void add_position_inline(const Geometry::Vector3D *position_inline) { - fbb_.AddStruct(ApplicationData::VT_POSITION_INLINE, position_inline); - } - void add_matrix(::flatbuffers::Offset<Geometry::Matrix> matrix) { - fbb_.AddOffset(ApplicationData::VT_MATRIX, matrix); - } - void add_matrices(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>>> matrices) { - fbb_.AddOffset(ApplicationData::VT_MATRICES, matrices); - } - explicit ApplicationDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<ApplicationData> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<ApplicationData>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData( - ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3D *>> vectors = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt = 0, - const Geometry::Vector3D *position = nullptr, - const Geometry::Vector3D *position_inline = nullptr, - ::flatbuffers::Offset<Geometry::Matrix> matrix = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>>> matrices = 0) { - ApplicationDataBuilder builder_(_fbb); - builder_.add_matrices(matrices); - builder_.add_matrix(matrix); - builder_.add_position_inline(position_inline); - builder_.add_position(position); - builder_.add_vectors_alt(vectors_alt); - builder_.add_vectors(vectors); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - const std::vector<Geometry::Vector3D> *vectors = nullptr, - const std::vector<Geometry::Vector3DAlt> *vectors_alt = nullptr, - const Geometry::Vector3D *position = nullptr, - const Geometry::Vector3D *position_inline = nullptr, - ::flatbuffers::Offset<Geometry::Matrix> matrix = 0, - const std::vector<::flatbuffers::Offset<Geometry::Matrix>> *matrices = nullptr) { - auto vectors__ = vectors ? _fbb.CreateVectorOfStructs<Geometry::Vector3D>(*vectors) : 0; - auto vectors_alt__ = vectors_alt ? _fbb.CreateVectorOfStructs<Geometry::Vector3DAlt>(*vectors_alt) : 0; - auto matrices__ = matrices ? _fbb.CreateVector<::flatbuffers::Offset<Geometry::Matrix>>(*matrices) : 0; - return Geometry::CreateApplicationData( - _fbb, - vectors__, - vectors_alt__, - position, - position_inline, - matrix, - matrices__); -} - -::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -inline Native::Matrix *Matrix::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<Native::Matrix>(new Native::Matrix()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline ::flatbuffers::Offset<Matrix> CreateMatrix(::flatbuffers::FlatBufferBuilder &_fbb, const Native::Matrix *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return Matrix::Pack(_fbb, _o, _rehasher); -} - - -inline bool operator==(const ApplicationDataT &lhs, const ApplicationDataT &rhs) { - return - (lhs.vectors == rhs.vectors) && - (lhs.vectors_alt == rhs.vectors_alt) && - ((lhs.position == rhs.position) || (lhs.position && rhs.position && *lhs.position == *rhs.position)) && - (lhs.position_inline == rhs.position_inline) && - ((lhs.matrix == rhs.matrix) || (lhs.matrix && rhs.matrix && *lhs.matrix == *rhs.matrix)) && - (lhs.matrices.size() == rhs.matrices.size() && std::equal(lhs.matrices.cbegin(), lhs.matrices.cend(), rhs.matrices.cbegin(), [](std::unique_ptr<Native::Matrix> const &a, std::unique_ptr<Native::Matrix> const &b) { return (a == b) || (a && b && *a == *b); })); -} - -inline bool operator!=(const ApplicationDataT &lhs, const ApplicationDataT &rhs) { - return !(lhs == rhs); -} - - -inline ApplicationDataT::ApplicationDataT(const ApplicationDataT &o) - : vectors(o.vectors), - vectors_alt(o.vectors_alt), - position((o.position) ? new Native::Vector3D(*o.position) : nullptr), - position_inline(o.position_inline), - matrix((o.matrix) ? new Native::Matrix(*o.matrix) : nullptr) { - matrices.reserve(o.matrices.size()); - for (const auto &matrices_ : o.matrices) { matrices.emplace_back((matrices_) ? new Native::Matrix(*matrices_) : nullptr); } -} - -inline ApplicationDataT &ApplicationDataT::operator=(ApplicationDataT o) FLATBUFFERS_NOEXCEPT { - std::swap(vectors, o.vectors); - std::swap(vectors_alt, o.vectors_alt); - std::swap(position, o.position); - std::swap(position_inline, o.position_inline); - std::swap(matrix, o.matrix); - std::swap(matrices, o.matrices); - return *this; -} - -inline ApplicationDataT *ApplicationData::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<ApplicationDataT>(new ApplicationDataT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void ApplicationData::UnPackTo(ApplicationDataT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = vectors(); if (_e) { _o->vectors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vectors[_i] = ::flatbuffers::UnPack(*_e->Get(_i)); } } else { _o->vectors.resize(0); } } - { auto _e = vectors_alt(); if (_e) { _o->vectors_alt.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vectors_alt[_i] = ::flatbuffers::UnPackVector3DAlt(*_e->Get(_i)); } } else { _o->vectors_alt.resize(0); } } - { auto _e = position(); if (_e) _o->position = std::unique_ptr<Native::Vector3D>(new Native::Vector3D(::flatbuffers::UnPack(*_e))); } - { auto _e = position_inline(); if (_e) _o->position_inline = ::flatbuffers::UnPack(*_e); } - { auto _e = matrix(); if (_e) { if(_o->matrix) { _e->UnPackTo(_o->matrix.get(), _resolver); } else { _o->matrix = std::unique_ptr<Native::Matrix>(_e->UnPack(_resolver)); } } else if (_o->matrix) { _o->matrix.reset(); } } - { auto _e = matrices(); if (_e) { _o->matrices.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->matrices[_i]) { _e->Get(_i)->UnPackTo(_o->matrices[_i].get(), _resolver); } else { _o->matrices[_i] = std::unique_ptr<Native::Matrix>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->matrices.resize(0); } } -} - -inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return ApplicationData::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<ApplicationData> ApplicationData::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ApplicationDataT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _vectors = _o->vectors.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3D, Native::Vector3D>(_o->vectors) : 0; - auto _vectors_alt = _o->vectors_alt.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3DAlt, Native::Vector3D>(_o->vectors_alt, ::flatbuffers::PackVector3DAlt) : 0; - auto _position = Geometry::Vector3D{}; if (_o->position) _position = ::flatbuffers::Pack(*_o->position); - auto _position_inline = ::flatbuffers::Pack(_o->position_inline); - auto _matrix = _o->matrix ? CreateMatrix(_fbb, _o->matrix.get(), _rehasher) : 0; - auto _matrices = _o->matrices.size() ? _fbb.CreateVector<::flatbuffers::Offset<Geometry::Matrix>> (_o->matrices.size(), [](size_t i, _VectorArgs *__va) { return CreateMatrix(*__va->__fbb, __va->__o->matrices[i].get(), __va->__rehasher); }, &_va ) : 0; - return Geometry::CreateApplicationData( - _fbb, - _vectors, - _vectors_alt, - _o->position ? &_position : nullptr, - &_position_inline, - _matrix, - _matrices); -} - -inline const ::flatbuffers::TypeTable *Vector3DTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 } - }; - static const int64_t values[] = { 0, 4, 8, 12 }; - static const char * const names[] = { - "x", - "y", - "z" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 } - }; - static const int64_t values[] = { 0, 4, 8, 12 }; - static const char * const names[] = { - "a", - "b", - "c" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *MatrixTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 1, -1 } - }; - static const char * const names[] = { - "rows", - "columns", - "values" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 1, 0 }, - { ::flatbuffers::ET_SEQUENCE, 1, 1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 2 }, - { ::flatbuffers::ET_SEQUENCE, 1, 2 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - Geometry::Vector3DTypeTable, - Geometry::Vector3DAltTypeTable, - Geometry::MatrixTypeTable - }; - static const char * const names[] = { - "vectors", - "vectors_alt", - "position", - "position_inline", - "matrix", - "matrices" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const Geometry::ApplicationData *GetApplicationData(const void *buf) { - return ::flatbuffers::GetRoot<Geometry::ApplicationData>(buf); -} - -inline const Geometry::ApplicationData *GetSizePrefixedApplicationData(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<Geometry::ApplicationData>(buf); -} - -inline ApplicationData *GetMutableApplicationData(void *buf) { - return ::flatbuffers::GetMutableRoot<ApplicationData>(buf); -} - -inline Geometry::ApplicationData *GetMutableSizePrefixedApplicationData(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf); -} - -template <bool B = false> -inline bool VerifyApplicationDataBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<Geometry::ApplicationData>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedApplicationDataBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr); -} - -inline void FinishApplicationDataBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Geometry::ApplicationData> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedApplicationDataBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Geometry::ApplicationData> root) { - fbb.FinishSizePrefixed(root); -} - -inline std::unique_ptr<Geometry::ApplicationDataT> UnPackApplicationData( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<Geometry::ApplicationDataT>(GetApplicationData(buf)->UnPack(res)); -} - -inline std::unique_ptr<Geometry::ApplicationDataT> UnPackSizePrefixedApplicationData( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<Geometry::ApplicationDataT>(GetSizePrefixedApplicationData(buf)->UnPack(res)); -} - -} // namespace Geometry - -#endif // FLATBUFFERS_GENERATED_NATIVETYPETEST_GEOMETRY_H_
diff --git a/tests/native_type_test_impl.cpp b/tests/native_type_test_impl.cpp index 8719c14..8bbb618 100644 --- a/tests/native_type_test_impl.cpp +++ b/tests/native_type_test_impl.cpp
@@ -1,6 +1,6 @@ #include "native_type_test_impl.h" -#include "native_type_test_generated.h" +#include "native_type_test.fbs.h" namespace flatbuffers { Geometry::Vector3D Pack(const Native::Vector3D& obj) {
diff --git a/tests/optional_scalars_generated.h b/tests/optional_scalars_generated.h deleted file mode 100644 index e4c6583..0000000 --- a/tests/optional_scalars_generated.h +++ /dev/null
@@ -1,964 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_OPTIONALSCALARS_OPTIONAL_SCALARS_H_ -#define FLATBUFFERS_GENERATED_OPTIONALSCALARS_OPTIONAL_SCALARS_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace optional_scalars { - -struct ScalarStuff; -struct ScalarStuffBuilder; -struct ScalarStuffT; - -bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs); -bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs); - -inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable(); - -enum OptionalByte : int8_t { - OptionalByte_None = 0, - OptionalByte_One = 1, - OptionalByte_Two = 2, - OptionalByte_MIN = OptionalByte_None, - OptionalByte_MAX = OptionalByte_Two -}; - -inline const OptionalByte (&EnumValuesOptionalByte())[3] { - static const OptionalByte values[] = { - OptionalByte_None, - OptionalByte_One, - OptionalByte_Two - }; - return values; -} - -inline const char * const *EnumNamesOptionalByte() { - static const char * const names[4] = { - "None", - "One", - "Two", - nullptr - }; - return names; -} - -inline const char *EnumNameOptionalByte(OptionalByte e) { - if (::flatbuffers::IsOutRange(e, OptionalByte_None, OptionalByte_Two)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesOptionalByte()[index]; -} - -struct ScalarStuffT : public ::flatbuffers::NativeTable { - typedef ScalarStuff TableType; - int8_t just_i8 = 0; - ::flatbuffers::Optional<int8_t> maybe_i8 = ::flatbuffers::nullopt; - int8_t default_i8 = 42; - uint8_t just_u8 = 0; - ::flatbuffers::Optional<uint8_t> maybe_u8 = ::flatbuffers::nullopt; - uint8_t default_u8 = 42; - int16_t just_i16 = 0; - ::flatbuffers::Optional<int16_t> maybe_i16 = ::flatbuffers::nullopt; - int16_t default_i16 = 42; - uint16_t just_u16 = 0; - ::flatbuffers::Optional<uint16_t> maybe_u16 = ::flatbuffers::nullopt; - uint16_t default_u16 = 42; - int32_t just_i32 = 0; - ::flatbuffers::Optional<int32_t> maybe_i32 = ::flatbuffers::nullopt; - int32_t default_i32 = 42; - uint32_t just_u32 = 0; - ::flatbuffers::Optional<uint32_t> maybe_u32 = ::flatbuffers::nullopt; - uint32_t default_u32 = 42; - int64_t just_i64 = 0; - ::flatbuffers::Optional<int64_t> maybe_i64 = ::flatbuffers::nullopt; - int64_t default_i64 = 42LL; - uint64_t just_u64 = 0; - ::flatbuffers::Optional<uint64_t> maybe_u64 = ::flatbuffers::nullopt; - uint64_t default_u64 = 42ULL; - float just_f32 = 0.0f; - ::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt; - float default_f32 = 42.0f; - double just_f64 = 0.0; - ::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt; - double default_f64 = 42.0; - bool just_bool = false; - ::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt; - bool default_bool = true; - optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte_None; - ::flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = ::flatbuffers::nullopt; - optional_scalars::OptionalByte default_enum = optional_scalars::OptionalByte_One; -}; - -struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef ScalarStuffT NativeTableType; - typedef ScalarStuffBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return ScalarStuffTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_JUST_I8 = 4, - VT_MAYBE_I8 = 6, - VT_DEFAULT_I8 = 8, - VT_JUST_U8 = 10, - VT_MAYBE_U8 = 12, - VT_DEFAULT_U8 = 14, - VT_JUST_I16 = 16, - VT_MAYBE_I16 = 18, - VT_DEFAULT_I16 = 20, - VT_JUST_U16 = 22, - VT_MAYBE_U16 = 24, - VT_DEFAULT_U16 = 26, - VT_JUST_I32 = 28, - VT_MAYBE_I32 = 30, - VT_DEFAULT_I32 = 32, - VT_JUST_U32 = 34, - VT_MAYBE_U32 = 36, - VT_DEFAULT_U32 = 38, - VT_JUST_I64 = 40, - VT_MAYBE_I64 = 42, - VT_DEFAULT_I64 = 44, - VT_JUST_U64 = 46, - VT_MAYBE_U64 = 48, - VT_DEFAULT_U64 = 50, - VT_JUST_F32 = 52, - VT_MAYBE_F32 = 54, - VT_DEFAULT_F32 = 56, - VT_JUST_F64 = 58, - VT_MAYBE_F64 = 60, - VT_DEFAULT_F64 = 62, - VT_JUST_BOOL = 64, - VT_MAYBE_BOOL = 66, - VT_DEFAULT_BOOL = 68, - VT_JUST_ENUM = 70, - VT_MAYBE_ENUM = 72, - VT_DEFAULT_ENUM = 74 - }; - int8_t just_i8() const { - return GetField<int8_t>(VT_JUST_I8, 0); - } - bool mutate_just_i8(int8_t _just_i8 = 0) { - return SetField<int8_t>(VT_JUST_I8, _just_i8, 0); - } - ::flatbuffers::Optional<int8_t> maybe_i8() const { - return GetOptional<int8_t, int8_t>(VT_MAYBE_I8); - } - bool mutate_maybe_i8(int8_t _maybe_i8) { - return SetField<int8_t>(VT_MAYBE_I8, _maybe_i8); - } - int8_t default_i8() const { - return GetField<int8_t>(VT_DEFAULT_I8, 42); - } - bool mutate_default_i8(int8_t _default_i8 = 42) { - return SetField<int8_t>(VT_DEFAULT_I8, _default_i8, 42); - } - uint8_t just_u8() const { - return GetField<uint8_t>(VT_JUST_U8, 0); - } - bool mutate_just_u8(uint8_t _just_u8 = 0) { - return SetField<uint8_t>(VT_JUST_U8, _just_u8, 0); - } - ::flatbuffers::Optional<uint8_t> maybe_u8() const { - return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8); - } - bool mutate_maybe_u8(uint8_t _maybe_u8) { - return SetField<uint8_t>(VT_MAYBE_U8, _maybe_u8); - } - uint8_t default_u8() const { - return GetField<uint8_t>(VT_DEFAULT_U8, 42); - } - bool mutate_default_u8(uint8_t _default_u8 = 42) { - return SetField<uint8_t>(VT_DEFAULT_U8, _default_u8, 42); - } - int16_t just_i16() const { - return GetField<int16_t>(VT_JUST_I16, 0); - } - bool mutate_just_i16(int16_t _just_i16 = 0) { - return SetField<int16_t>(VT_JUST_I16, _just_i16, 0); - } - ::flatbuffers::Optional<int16_t> maybe_i16() const { - return GetOptional<int16_t, int16_t>(VT_MAYBE_I16); - } - bool mutate_maybe_i16(int16_t _maybe_i16) { - return SetField<int16_t>(VT_MAYBE_I16, _maybe_i16); - } - int16_t default_i16() const { - return GetField<int16_t>(VT_DEFAULT_I16, 42); - } - bool mutate_default_i16(int16_t _default_i16 = 42) { - return SetField<int16_t>(VT_DEFAULT_I16, _default_i16, 42); - } - uint16_t just_u16() const { - return GetField<uint16_t>(VT_JUST_U16, 0); - } - bool mutate_just_u16(uint16_t _just_u16 = 0) { - return SetField<uint16_t>(VT_JUST_U16, _just_u16, 0); - } - ::flatbuffers::Optional<uint16_t> maybe_u16() const { - return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16); - } - bool mutate_maybe_u16(uint16_t _maybe_u16) { - return SetField<uint16_t>(VT_MAYBE_U16, _maybe_u16); - } - uint16_t default_u16() const { - return GetField<uint16_t>(VT_DEFAULT_U16, 42); - } - bool mutate_default_u16(uint16_t _default_u16 = 42) { - return SetField<uint16_t>(VT_DEFAULT_U16, _default_u16, 42); - } - int32_t just_i32() const { - return GetField<int32_t>(VT_JUST_I32, 0); - } - bool mutate_just_i32(int32_t _just_i32 = 0) { - return SetField<int32_t>(VT_JUST_I32, _just_i32, 0); - } - ::flatbuffers::Optional<int32_t> maybe_i32() const { - return GetOptional<int32_t, int32_t>(VT_MAYBE_I32); - } - bool mutate_maybe_i32(int32_t _maybe_i32) { - return SetField<int32_t>(VT_MAYBE_I32, _maybe_i32); - } - int32_t default_i32() const { - return GetField<int32_t>(VT_DEFAULT_I32, 42); - } - bool mutate_default_i32(int32_t _default_i32 = 42) { - return SetField<int32_t>(VT_DEFAULT_I32, _default_i32, 42); - } - uint32_t just_u32() const { - return GetField<uint32_t>(VT_JUST_U32, 0); - } - bool mutate_just_u32(uint32_t _just_u32 = 0) { - return SetField<uint32_t>(VT_JUST_U32, _just_u32, 0); - } - ::flatbuffers::Optional<uint32_t> maybe_u32() const { - return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32); - } - bool mutate_maybe_u32(uint32_t _maybe_u32) { - return SetField<uint32_t>(VT_MAYBE_U32, _maybe_u32); - } - uint32_t default_u32() const { - return GetField<uint32_t>(VT_DEFAULT_U32, 42); - } - bool mutate_default_u32(uint32_t _default_u32 = 42) { - return SetField<uint32_t>(VT_DEFAULT_U32, _default_u32, 42); - } - int64_t just_i64() const { - return GetField<int64_t>(VT_JUST_I64, 0); - } - bool mutate_just_i64(int64_t _just_i64 = 0) { - return SetField<int64_t>(VT_JUST_I64, _just_i64, 0); - } - ::flatbuffers::Optional<int64_t> maybe_i64() const { - return GetOptional<int64_t, int64_t>(VT_MAYBE_I64); - } - bool mutate_maybe_i64(int64_t _maybe_i64) { - return SetField<int64_t>(VT_MAYBE_I64, _maybe_i64); - } - int64_t default_i64() const { - return GetField<int64_t>(VT_DEFAULT_I64, 42LL); - } - bool mutate_default_i64(int64_t _default_i64 = 42LL) { - return SetField<int64_t>(VT_DEFAULT_I64, _default_i64, 42LL); - } - uint64_t just_u64() const { - return GetField<uint64_t>(VT_JUST_U64, 0); - } - bool mutate_just_u64(uint64_t _just_u64 = 0) { - return SetField<uint64_t>(VT_JUST_U64, _just_u64, 0); - } - ::flatbuffers::Optional<uint64_t> maybe_u64() const { - return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64); - } - bool mutate_maybe_u64(uint64_t _maybe_u64) { - return SetField<uint64_t>(VT_MAYBE_U64, _maybe_u64); - } - uint64_t default_u64() const { - return GetField<uint64_t>(VT_DEFAULT_U64, 42ULL); - } - bool mutate_default_u64(uint64_t _default_u64 = 42ULL) { - return SetField<uint64_t>(VT_DEFAULT_U64, _default_u64, 42ULL); - } - float just_f32() const { - return GetField<float>(VT_JUST_F32, 0.0f); - } - bool mutate_just_f32(float _just_f32 = 0.0f) { - return SetField<float>(VT_JUST_F32, _just_f32, 0.0f); - } - ::flatbuffers::Optional<float> maybe_f32() const { - return GetOptional<float, float>(VT_MAYBE_F32); - } - bool mutate_maybe_f32(float _maybe_f32) { - return SetField<float>(VT_MAYBE_F32, _maybe_f32); - } - float default_f32() const { - return GetField<float>(VT_DEFAULT_F32, 42.0f); - } - bool mutate_default_f32(float _default_f32 = 42.0f) { - return SetField<float>(VT_DEFAULT_F32, _default_f32, 42.0f); - } - double just_f64() const { - return GetField<double>(VT_JUST_F64, 0.0); - } - bool mutate_just_f64(double _just_f64 = 0.0) { - return SetField<double>(VT_JUST_F64, _just_f64, 0.0); - } - ::flatbuffers::Optional<double> maybe_f64() const { - return GetOptional<double, double>(VT_MAYBE_F64); - } - bool mutate_maybe_f64(double _maybe_f64) { - return SetField<double>(VT_MAYBE_F64, _maybe_f64); - } - double default_f64() const { - return GetField<double>(VT_DEFAULT_F64, 42.0); - } - bool mutate_default_f64(double _default_f64 = 42.0) { - return SetField<double>(VT_DEFAULT_F64, _default_f64, 42.0); - } - bool just_bool() const { - return GetField<uint8_t>(VT_JUST_BOOL, 0) != 0; - } - bool mutate_just_bool(bool _just_bool = 0) { - return SetField<uint8_t>(VT_JUST_BOOL, static_cast<uint8_t>(_just_bool), 0); - } - ::flatbuffers::Optional<bool> maybe_bool() const { - return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL); - } - bool mutate_maybe_bool(bool _maybe_bool) { - return SetField<uint8_t>(VT_MAYBE_BOOL, static_cast<uint8_t>(_maybe_bool)); - } - bool default_bool() const { - return GetField<uint8_t>(VT_DEFAULT_BOOL, 1) != 0; - } - bool mutate_default_bool(bool _default_bool = 1) { - return SetField<uint8_t>(VT_DEFAULT_BOOL, static_cast<uint8_t>(_default_bool), 1); - } - optional_scalars::OptionalByte just_enum() const { - return static_cast<optional_scalars::OptionalByte>(GetField<int8_t>(VT_JUST_ENUM, 0)); - } - bool mutate_just_enum(optional_scalars::OptionalByte _just_enum = static_cast<optional_scalars::OptionalByte>(0)) { - return SetField<int8_t>(VT_JUST_ENUM, static_cast<int8_t>(_just_enum), 0); - } - ::flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum() const { - return GetOptional<int8_t, optional_scalars::OptionalByte>(VT_MAYBE_ENUM); - } - bool mutate_maybe_enum(optional_scalars::OptionalByte _maybe_enum) { - return SetField<int8_t>(VT_MAYBE_ENUM, static_cast<int8_t>(_maybe_enum)); - } - optional_scalars::OptionalByte default_enum() const { - return static_cast<optional_scalars::OptionalByte>(GetField<int8_t>(VT_DEFAULT_ENUM, 1)); - } - bool mutate_default_enum(optional_scalars::OptionalByte _default_enum = static_cast<optional_scalars::OptionalByte>(1)) { - return SetField<int8_t>(VT_DEFAULT_ENUM, static_cast<int8_t>(_default_enum), 1); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int8_t>(verifier, VT_JUST_I8, 1) && - VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) && - VerifyField<int8_t>(verifier, VT_DEFAULT_I8, 1) && - VerifyField<uint8_t>(verifier, VT_JUST_U8, 1) && - VerifyField<uint8_t>(verifier, VT_MAYBE_U8, 1) && - VerifyField<uint8_t>(verifier, VT_DEFAULT_U8, 1) && - VerifyField<int16_t>(verifier, VT_JUST_I16, 2) && - VerifyField<int16_t>(verifier, VT_MAYBE_I16, 2) && - VerifyField<int16_t>(verifier, VT_DEFAULT_I16, 2) && - VerifyField<uint16_t>(verifier, VT_JUST_U16, 2) && - VerifyField<uint16_t>(verifier, VT_MAYBE_U16, 2) && - VerifyField<uint16_t>(verifier, VT_DEFAULT_U16, 2) && - VerifyField<int32_t>(verifier, VT_JUST_I32, 4) && - VerifyField<int32_t>(verifier, VT_MAYBE_I32, 4) && - VerifyField<int32_t>(verifier, VT_DEFAULT_I32, 4) && - VerifyField<uint32_t>(verifier, VT_JUST_U32, 4) && - VerifyField<uint32_t>(verifier, VT_MAYBE_U32, 4) && - VerifyField<uint32_t>(verifier, VT_DEFAULT_U32, 4) && - VerifyField<int64_t>(verifier, VT_JUST_I64, 8) && - VerifyField<int64_t>(verifier, VT_MAYBE_I64, 8) && - VerifyField<int64_t>(verifier, VT_DEFAULT_I64, 8) && - VerifyField<uint64_t>(verifier, VT_JUST_U64, 8) && - VerifyField<uint64_t>(verifier, VT_MAYBE_U64, 8) && - VerifyField<uint64_t>(verifier, VT_DEFAULT_U64, 8) && - VerifyField<float>(verifier, VT_JUST_F32, 4) && - VerifyField<float>(verifier, VT_MAYBE_F32, 4) && - VerifyField<float>(verifier, VT_DEFAULT_F32, 4) && - VerifyField<double>(verifier, VT_JUST_F64, 8) && - VerifyField<double>(verifier, VT_MAYBE_F64, 8) && - VerifyField<double>(verifier, VT_DEFAULT_F64, 8) && - VerifyField<uint8_t>(verifier, VT_JUST_BOOL, 1) && - VerifyField<uint8_t>(verifier, VT_MAYBE_BOOL, 1) && - VerifyField<uint8_t>(verifier, VT_DEFAULT_BOOL, 1) && - VerifyField<int8_t>(verifier, VT_JUST_ENUM, 1) && - VerifyField<int8_t>(verifier, VT_MAYBE_ENUM, 1) && - VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM, 1) && - verifier.EndTable(); - } - ScalarStuffT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ScalarStuffT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<ScalarStuff> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct ScalarStuffBuilder { - typedef ScalarStuff Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_just_i8(int8_t just_i8) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_I8, just_i8, 0); - } - void add_maybe_i8(int8_t maybe_i8) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_MAYBE_I8, maybe_i8); - } - void add_default_i8(int8_t default_i8) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_I8, default_i8, 42); - } - void add_just_u8(uint8_t just_u8) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_JUST_U8, just_u8, 0); - } - void add_maybe_u8(uint8_t maybe_u8) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_MAYBE_U8, maybe_u8); - } - void add_default_u8(uint8_t default_u8) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_DEFAULT_U8, default_u8, 42); - } - void add_just_i16(int16_t just_i16) { - fbb_.AddElement<int16_t>(ScalarStuff::VT_JUST_I16, just_i16, 0); - } - void add_maybe_i16(int16_t maybe_i16) { - fbb_.AddElement<int16_t>(ScalarStuff::VT_MAYBE_I16, maybe_i16); - } - void add_default_i16(int16_t default_i16) { - fbb_.AddElement<int16_t>(ScalarStuff::VT_DEFAULT_I16, default_i16, 42); - } - void add_just_u16(uint16_t just_u16) { - fbb_.AddElement<uint16_t>(ScalarStuff::VT_JUST_U16, just_u16, 0); - } - void add_maybe_u16(uint16_t maybe_u16) { - fbb_.AddElement<uint16_t>(ScalarStuff::VT_MAYBE_U16, maybe_u16); - } - void add_default_u16(uint16_t default_u16) { - fbb_.AddElement<uint16_t>(ScalarStuff::VT_DEFAULT_U16, default_u16, 42); - } - void add_just_i32(int32_t just_i32) { - fbb_.AddElement<int32_t>(ScalarStuff::VT_JUST_I32, just_i32, 0); - } - void add_maybe_i32(int32_t maybe_i32) { - fbb_.AddElement<int32_t>(ScalarStuff::VT_MAYBE_I32, maybe_i32); - } - void add_default_i32(int32_t default_i32) { - fbb_.AddElement<int32_t>(ScalarStuff::VT_DEFAULT_I32, default_i32, 42); - } - void add_just_u32(uint32_t just_u32) { - fbb_.AddElement<uint32_t>(ScalarStuff::VT_JUST_U32, just_u32, 0); - } - void add_maybe_u32(uint32_t maybe_u32) { - fbb_.AddElement<uint32_t>(ScalarStuff::VT_MAYBE_U32, maybe_u32); - } - void add_default_u32(uint32_t default_u32) { - fbb_.AddElement<uint32_t>(ScalarStuff::VT_DEFAULT_U32, default_u32, 42); - } - void add_just_i64(int64_t just_i64) { - fbb_.AddElement<int64_t>(ScalarStuff::VT_JUST_I64, just_i64, 0); - } - void add_maybe_i64(int64_t maybe_i64) { - fbb_.AddElement<int64_t>(ScalarStuff::VT_MAYBE_I64, maybe_i64); - } - void add_default_i64(int64_t default_i64) { - fbb_.AddElement<int64_t>(ScalarStuff::VT_DEFAULT_I64, default_i64, 42LL); - } - void add_just_u64(uint64_t just_u64) { - fbb_.AddElement<uint64_t>(ScalarStuff::VT_JUST_U64, just_u64, 0); - } - void add_maybe_u64(uint64_t maybe_u64) { - fbb_.AddElement<uint64_t>(ScalarStuff::VT_MAYBE_U64, maybe_u64); - } - void add_default_u64(uint64_t default_u64) { - fbb_.AddElement<uint64_t>(ScalarStuff::VT_DEFAULT_U64, default_u64, 42ULL); - } - void add_just_f32(float just_f32) { - fbb_.AddElement<float>(ScalarStuff::VT_JUST_F32, just_f32, 0.0f); - } - void add_maybe_f32(float maybe_f32) { - fbb_.AddElement<float>(ScalarStuff::VT_MAYBE_F32, maybe_f32); - } - void add_default_f32(float default_f32) { - fbb_.AddElement<float>(ScalarStuff::VT_DEFAULT_F32, default_f32, 42.0f); - } - void add_just_f64(double just_f64) { - fbb_.AddElement<double>(ScalarStuff::VT_JUST_F64, just_f64, 0.0); - } - void add_maybe_f64(double maybe_f64) { - fbb_.AddElement<double>(ScalarStuff::VT_MAYBE_F64, maybe_f64); - } - void add_default_f64(double default_f64) { - fbb_.AddElement<double>(ScalarStuff::VT_DEFAULT_F64, default_f64, 42.0); - } - void add_just_bool(bool just_bool) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_JUST_BOOL, static_cast<uint8_t>(just_bool), 0); - } - void add_maybe_bool(bool maybe_bool) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_MAYBE_BOOL, static_cast<uint8_t>(maybe_bool)); - } - void add_default_bool(bool default_bool) { - fbb_.AddElement<uint8_t>(ScalarStuff::VT_DEFAULT_BOOL, static_cast<uint8_t>(default_bool), 1); - } - void add_just_enum(optional_scalars::OptionalByte just_enum) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_ENUM, static_cast<int8_t>(just_enum), 0); - } - void add_maybe_enum(optional_scalars::OptionalByte maybe_enum) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_MAYBE_ENUM, static_cast<int8_t>(maybe_enum)); - } - void add_default_enum(optional_scalars::OptionalByte default_enum) { - fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_ENUM, static_cast<int8_t>(default_enum), 1); - } - explicit ScalarStuffBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<ScalarStuff> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<ScalarStuff>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff( - ::flatbuffers::FlatBufferBuilder &_fbb, - int8_t just_i8 = 0, - ::flatbuffers::Optional<int8_t> maybe_i8 = ::flatbuffers::nullopt, - int8_t default_i8 = 42, - uint8_t just_u8 = 0, - ::flatbuffers::Optional<uint8_t> maybe_u8 = ::flatbuffers::nullopt, - uint8_t default_u8 = 42, - int16_t just_i16 = 0, - ::flatbuffers::Optional<int16_t> maybe_i16 = ::flatbuffers::nullopt, - int16_t default_i16 = 42, - uint16_t just_u16 = 0, - ::flatbuffers::Optional<uint16_t> maybe_u16 = ::flatbuffers::nullopt, - uint16_t default_u16 = 42, - int32_t just_i32 = 0, - ::flatbuffers::Optional<int32_t> maybe_i32 = ::flatbuffers::nullopt, - int32_t default_i32 = 42, - uint32_t just_u32 = 0, - ::flatbuffers::Optional<uint32_t> maybe_u32 = ::flatbuffers::nullopt, - uint32_t default_u32 = 42, - int64_t just_i64 = 0, - ::flatbuffers::Optional<int64_t> maybe_i64 = ::flatbuffers::nullopt, - int64_t default_i64 = 42LL, - uint64_t just_u64 = 0, - ::flatbuffers::Optional<uint64_t> maybe_u64 = ::flatbuffers::nullopt, - uint64_t default_u64 = 42ULL, - float just_f32 = 0.0f, - ::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt, - float default_f32 = 42.0f, - double just_f64 = 0.0, - ::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt, - double default_f64 = 42.0, - bool just_bool = false, - ::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt, - bool default_bool = true, - optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte_None, - ::flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = ::flatbuffers::nullopt, - optional_scalars::OptionalByte default_enum = optional_scalars::OptionalByte_One) { - ScalarStuffBuilder builder_(_fbb); - builder_.add_default_f64(default_f64); - if(maybe_f64) { builder_.add_maybe_f64(*maybe_f64); } - builder_.add_just_f64(just_f64); - builder_.add_default_u64(default_u64); - if(maybe_u64) { builder_.add_maybe_u64(*maybe_u64); } - builder_.add_just_u64(just_u64); - builder_.add_default_i64(default_i64); - if(maybe_i64) { builder_.add_maybe_i64(*maybe_i64); } - builder_.add_just_i64(just_i64); - builder_.add_default_f32(default_f32); - if(maybe_f32) { builder_.add_maybe_f32(*maybe_f32); } - builder_.add_just_f32(just_f32); - builder_.add_default_u32(default_u32); - if(maybe_u32) { builder_.add_maybe_u32(*maybe_u32); } - builder_.add_just_u32(just_u32); - builder_.add_default_i32(default_i32); - if(maybe_i32) { builder_.add_maybe_i32(*maybe_i32); } - builder_.add_just_i32(just_i32); - builder_.add_default_u16(default_u16); - if(maybe_u16) { builder_.add_maybe_u16(*maybe_u16); } - builder_.add_just_u16(just_u16); - builder_.add_default_i16(default_i16); - if(maybe_i16) { builder_.add_maybe_i16(*maybe_i16); } - builder_.add_just_i16(just_i16); - builder_.add_default_enum(default_enum); - if(maybe_enum) { builder_.add_maybe_enum(*maybe_enum); } - builder_.add_just_enum(just_enum); - builder_.add_default_bool(default_bool); - if(maybe_bool) { builder_.add_maybe_bool(*maybe_bool); } - builder_.add_just_bool(just_bool); - builder_.add_default_u8(default_u8); - if(maybe_u8) { builder_.add_maybe_u8(*maybe_u8); } - builder_.add_just_u8(just_u8); - builder_.add_default_i8(default_i8); - if(maybe_i8) { builder_.add_maybe_i8(*maybe_i8); } - builder_.add_just_i8(just_i8); - return builder_.Finish(); -} - -::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs) { - return - (lhs.just_i8 == rhs.just_i8) && - (lhs.maybe_i8 == rhs.maybe_i8) && - (lhs.default_i8 == rhs.default_i8) && - (lhs.just_u8 == rhs.just_u8) && - (lhs.maybe_u8 == rhs.maybe_u8) && - (lhs.default_u8 == rhs.default_u8) && - (lhs.just_i16 == rhs.just_i16) && - (lhs.maybe_i16 == rhs.maybe_i16) && - (lhs.default_i16 == rhs.default_i16) && - (lhs.just_u16 == rhs.just_u16) && - (lhs.maybe_u16 == rhs.maybe_u16) && - (lhs.default_u16 == rhs.default_u16) && - (lhs.just_i32 == rhs.just_i32) && - (lhs.maybe_i32 == rhs.maybe_i32) && - (lhs.default_i32 == rhs.default_i32) && - (lhs.just_u32 == rhs.just_u32) && - (lhs.maybe_u32 == rhs.maybe_u32) && - (lhs.default_u32 == rhs.default_u32) && - (lhs.just_i64 == rhs.just_i64) && - (lhs.maybe_i64 == rhs.maybe_i64) && - (lhs.default_i64 == rhs.default_i64) && - (lhs.just_u64 == rhs.just_u64) && - (lhs.maybe_u64 == rhs.maybe_u64) && - (lhs.default_u64 == rhs.default_u64) && - (lhs.just_f32 == rhs.just_f32) && - (lhs.maybe_f32 == rhs.maybe_f32) && - (lhs.default_f32 == rhs.default_f32) && - (lhs.just_f64 == rhs.just_f64) && - (lhs.maybe_f64 == rhs.maybe_f64) && - (lhs.default_f64 == rhs.default_f64) && - (lhs.just_bool == rhs.just_bool) && - (lhs.maybe_bool == rhs.maybe_bool) && - (lhs.default_bool == rhs.default_bool) && - (lhs.just_enum == rhs.just_enum) && - (lhs.maybe_enum == rhs.maybe_enum) && - (lhs.default_enum == rhs.default_enum); -} - -inline bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs) { - return !(lhs == rhs); -} - - -inline ScalarStuffT *ScalarStuff::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<ScalarStuffT>(new ScalarStuffT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = just_i8(); _o->just_i8 = _e; } - { auto _e = maybe_i8(); _o->maybe_i8 = _e; } - { auto _e = default_i8(); _o->default_i8 = _e; } - { auto _e = just_u8(); _o->just_u8 = _e; } - { auto _e = maybe_u8(); _o->maybe_u8 = _e; } - { auto _e = default_u8(); _o->default_u8 = _e; } - { auto _e = just_i16(); _o->just_i16 = _e; } - { auto _e = maybe_i16(); _o->maybe_i16 = _e; } - { auto _e = default_i16(); _o->default_i16 = _e; } - { auto _e = just_u16(); _o->just_u16 = _e; } - { auto _e = maybe_u16(); _o->maybe_u16 = _e; } - { auto _e = default_u16(); _o->default_u16 = _e; } - { auto _e = just_i32(); _o->just_i32 = _e; } - { auto _e = maybe_i32(); _o->maybe_i32 = _e; } - { auto _e = default_i32(); _o->default_i32 = _e; } - { auto _e = just_u32(); _o->just_u32 = _e; } - { auto _e = maybe_u32(); _o->maybe_u32 = _e; } - { auto _e = default_u32(); _o->default_u32 = _e; } - { auto _e = just_i64(); _o->just_i64 = _e; } - { auto _e = maybe_i64(); _o->maybe_i64 = _e; } - { auto _e = default_i64(); _o->default_i64 = _e; } - { auto _e = just_u64(); _o->just_u64 = _e; } - { auto _e = maybe_u64(); _o->maybe_u64 = _e; } - { auto _e = default_u64(); _o->default_u64 = _e; } - { auto _e = just_f32(); _o->just_f32 = _e; } - { auto _e = maybe_f32(); _o->maybe_f32 = _e; } - { auto _e = default_f32(); _o->default_f32 = _e; } - { auto _e = just_f64(); _o->just_f64 = _e; } - { auto _e = maybe_f64(); _o->maybe_f64 = _e; } - { auto _e = default_f64(); _o->default_f64 = _e; } - { auto _e = just_bool(); _o->just_bool = _e; } - { auto _e = maybe_bool(); _o->maybe_bool = _e; } - { auto _e = default_bool(); _o->default_bool = _e; } - { auto _e = just_enum(); _o->just_enum = _e; } - { auto _e = maybe_enum(); _o->maybe_enum = _e; } - { auto _e = default_enum(); _o->default_enum = _e; } -} - -inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return ScalarStuff::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<ScalarStuff> ScalarStuff::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ScalarStuffT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _just_i8 = _o->just_i8; - auto _maybe_i8 = _o->maybe_i8; - auto _default_i8 = _o->default_i8; - auto _just_u8 = _o->just_u8; - auto _maybe_u8 = _o->maybe_u8; - auto _default_u8 = _o->default_u8; - auto _just_i16 = _o->just_i16; - auto _maybe_i16 = _o->maybe_i16; - auto _default_i16 = _o->default_i16; - auto _just_u16 = _o->just_u16; - auto _maybe_u16 = _o->maybe_u16; - auto _default_u16 = _o->default_u16; - auto _just_i32 = _o->just_i32; - auto _maybe_i32 = _o->maybe_i32; - auto _default_i32 = _o->default_i32; - auto _just_u32 = _o->just_u32; - auto _maybe_u32 = _o->maybe_u32; - auto _default_u32 = _o->default_u32; - auto _just_i64 = _o->just_i64; - auto _maybe_i64 = _o->maybe_i64; - auto _default_i64 = _o->default_i64; - auto _just_u64 = _o->just_u64; - auto _maybe_u64 = _o->maybe_u64; - auto _default_u64 = _o->default_u64; - auto _just_f32 = _o->just_f32; - auto _maybe_f32 = _o->maybe_f32; - auto _default_f32 = _o->default_f32; - auto _just_f64 = _o->just_f64; - auto _maybe_f64 = _o->maybe_f64; - auto _default_f64 = _o->default_f64; - auto _just_bool = _o->just_bool; - auto _maybe_bool = _o->maybe_bool; - auto _default_bool = _o->default_bool; - auto _just_enum = _o->just_enum; - auto _maybe_enum = _o->maybe_enum; - auto _default_enum = _o->default_enum; - return optional_scalars::CreateScalarStuff( - _fbb, - _just_i8, - _maybe_i8, - _default_i8, - _just_u8, - _maybe_u8, - _default_u8, - _just_i16, - _maybe_i16, - _default_i16, - _just_u16, - _maybe_u16, - _default_u16, - _just_i32, - _maybe_i32, - _default_i32, - _just_u32, - _maybe_u32, - _default_u32, - _just_i64, - _maybe_i64, - _default_i64, - _just_u64, - _maybe_u64, - _default_u64, - _just_f32, - _maybe_f32, - _default_f32, - _just_f64, - _maybe_f64, - _default_f64, - _just_bool, - _maybe_bool, - _default_bool, - _just_enum, - _maybe_enum, - _default_enum); -} - -inline const ::flatbuffers::TypeTable *OptionalByteTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_CHAR, 0, 0 }, - { ::flatbuffers::ET_CHAR, 0, 0 }, - { ::flatbuffers::ET_CHAR, 0, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - optional_scalars::OptionalByteTypeTable - }; - static const char * const names[] = { - "None", - "One", - "Two" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_CHAR, 0, -1 }, - { ::flatbuffers::ET_CHAR, 0, -1 }, - { ::flatbuffers::ET_CHAR, 0, -1 }, - { ::flatbuffers::ET_UCHAR, 0, -1 }, - { ::flatbuffers::ET_UCHAR, 0, -1 }, - { ::flatbuffers::ET_UCHAR, 0, -1 }, - { ::flatbuffers::ET_SHORT, 0, -1 }, - { ::flatbuffers::ET_SHORT, 0, -1 }, - { ::flatbuffers::ET_SHORT, 0, -1 }, - { ::flatbuffers::ET_USHORT, 0, -1 }, - { ::flatbuffers::ET_USHORT, 0, -1 }, - { ::flatbuffers::ET_USHORT, 0, -1 }, - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_INT, 0, -1 }, - { ::flatbuffers::ET_UINT, 0, -1 }, - { ::flatbuffers::ET_UINT, 0, -1 }, - { ::flatbuffers::ET_UINT, 0, -1 }, - { ::flatbuffers::ET_LONG, 0, -1 }, - { ::flatbuffers::ET_LONG, 0, -1 }, - { ::flatbuffers::ET_LONG, 0, -1 }, - { ::flatbuffers::ET_ULONG, 0, -1 }, - { ::flatbuffers::ET_ULONG, 0, -1 }, - { ::flatbuffers::ET_ULONG, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_FLOAT, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 0, -1 }, - { ::flatbuffers::ET_DOUBLE, 0, -1 }, - { ::flatbuffers::ET_BOOL, 0, -1 }, - { ::flatbuffers::ET_BOOL, 0, -1 }, - { ::flatbuffers::ET_BOOL, 0, -1 }, - { ::flatbuffers::ET_CHAR, 0, 0 }, - { ::flatbuffers::ET_CHAR, 0, 0 }, - { ::flatbuffers::ET_CHAR, 0, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - optional_scalars::OptionalByteTypeTable - }; - static const char * const names[] = { - "just_i8", - "maybe_i8", - "default_i8", - "just_u8", - "maybe_u8", - "default_u8", - "just_i16", - "maybe_i16", - "default_i16", - "just_u16", - "maybe_u16", - "default_u16", - "just_i32", - "maybe_i32", - "default_i32", - "just_u32", - "maybe_u32", - "default_u32", - "just_i64", - "maybe_i64", - "default_i64", - "just_u64", - "maybe_u64", - "default_u64", - "just_f32", - "maybe_f32", - "default_f32", - "just_f64", - "maybe_f64", - "default_f64", - "just_bool", - "maybe_bool", - "default_bool", - "just_enum", - "maybe_enum", - "default_enum" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const optional_scalars::ScalarStuff *GetScalarStuff(const void *buf) { - return ::flatbuffers::GetRoot<optional_scalars::ScalarStuff>(buf); -} - -inline const optional_scalars::ScalarStuff *GetSizePrefixedScalarStuff(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf); -} - -inline ScalarStuff *GetMutableScalarStuff(void *buf) { - return ::flatbuffers::GetMutableRoot<ScalarStuff>(buf); -} - -inline optional_scalars::ScalarStuff *GetMutableSizePrefixedScalarStuff(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<optional_scalars::ScalarStuff>(buf); -} - -inline const char *ScalarStuffIdentifier() { - return "NULL"; -} - -inline bool ScalarStuffBufferHasIdentifier(const void *buf) { - return ::flatbuffers::BufferHasIdentifier( - buf, ScalarStuffIdentifier()); -} - -inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) { - return ::flatbuffers::BufferHasIdentifier( - buf, ScalarStuffIdentifier(), true); -} - -template <bool B = false> -inline bool VerifyScalarStuffBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier()); -} - -template <bool B = false> -inline bool VerifySizePrefixedScalarStuffBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier()); -} - -inline const char *ScalarStuffExtension() { - return "mon"; -} - -inline void FinishScalarStuffBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<optional_scalars::ScalarStuff> root) { - fbb.Finish(root, ScalarStuffIdentifier()); -} - -inline void FinishSizePrefixedScalarStuffBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<optional_scalars::ScalarStuff> root) { - fbb.FinishSizePrefixed(root, ScalarStuffIdentifier()); -} - -inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<optional_scalars::ScalarStuffT>(GetScalarStuff(buf)->UnPack(res)); -} - -inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res)); -} - -} // namespace optional_scalars - -#endif // FLATBUFFERS_GENERATED_OPTIONALSCALARS_OPTIONAL_SCALARS_H_
diff --git a/tests/optional_scalars_test.cpp b/tests/optional_scalars_test.cpp index 0e1fae3..8897676 100644 --- a/tests/optional_scalars_test.cpp +++ b/tests/optional_scalars_test.cpp
@@ -4,7 +4,7 @@ #include <vector> #include "flatbuffers/idl.h" -#include "optional_scalars_generated.h" +#include "optional_scalars.fbs.h" #include "test_assert.h" namespace flatbuffers {
diff --git a/tests/reflection_test.cpp b/tests/reflection_test.cpp index 1c48918..dead654 100644 --- a/tests/reflection_test.cpp +++ b/tests/reflection_test.cpp
@@ -7,7 +7,7 @@ #include "monster_test.h" #include "monster_test_generated.h" #include "test_assert.h" -#include "tests/arrays_test_generated.h" +#include "tests/arrays_test.fbs.h" namespace flatbuffers { namespace tests {
diff --git a/tests/test.cpp b/tests/test.cpp index c94d215..aea3688 100644 --- a/tests/test.cpp +++ b/tests/test.cpp
@@ -47,15 +47,15 @@ #include "key_field_test.h" #include "monster_test.h" #include "monster_test_generated.h" -#include "native_inline_table_test_generated.h" +#include "native_inline_table_test.fbs.h" #include "optional_scalars_test.h" #include "parser_test.h" #include "proto_test.h" #include "reflection_test.h" -#include "tests/union_vector/union_vector_generated.h" -#include "union_underlying_type_test_generated.h" +#include "tests/union_vector/union_vector.fbs.h" +#include "union_underlying_type_test.fbs.h" #if !defined(_MSC_VER) || _MSC_VER >= 1700 -#include "tests/arrays_test_generated.h" +#include "tests/arrays_test.fbs.h" #endif #if INCLUDE_64_BIT_TESTS #include "tests/64bit/offset64_test.h" @@ -63,7 +63,7 @@ #include "flexbuffers_test.h" #include "is_quiet_nan.h" #include "monster_test_bfbs_generated.h" // Generated using --bfbs-comments --bfbs-builtins --cpp --bfbs-gen-embed -#include "native_type_test_generated.h" +#include "native_type_test.fbs.h" #include "test_assert.h" #include "util_test.h" #include "vector_table_naked_ptr_test.h"
diff --git a/tests/union_underlying_type_test_generated.h b/tests/union_underlying_type_test_generated.h deleted file mode 100644 index 7f7df72..0000000 --- a/tests/union_underlying_type_test_generated.h +++ /dev/null
@@ -1,910 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_UNIONUNDERLYINGTYPETEST_UNIONUNDERLYINGTYPE_H_ -#define FLATBUFFERS_GENERATED_UNIONUNDERLYINGTYPETEST_UNIONUNDERLYINGTYPE_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -namespace UnionUnderlyingType { - -struct A; -struct ABuilder; -struct AT; - -struct B; -struct BBuilder; -struct BT; - -struct C; -struct CBuilder; -struct CT; - -struct D; -struct DBuilder; -struct DT; - -bool operator==(const AT &lhs, const AT &rhs); -bool operator!=(const AT &lhs, const AT &rhs); -bool operator==(const BT &lhs, const BT &rhs); -bool operator!=(const BT &lhs, const BT &rhs); -bool operator==(const CT &lhs, const CT &rhs); -bool operator!=(const CT &lhs, const CT &rhs); -bool operator==(const DT &lhs, const DT &rhs); -bool operator!=(const DT &lhs, const DT &rhs); - -inline const ::flatbuffers::TypeTable *ATypeTable(); - -inline const ::flatbuffers::TypeTable *BTypeTable(); - -inline const ::flatbuffers::TypeTable *CTypeTable(); - -inline const ::flatbuffers::TypeTable *DTypeTable(); - -enum class ABC : int32_t { - NONE = 0, - A = 555, - B = 666, - C = 777, - MIN = NONE, - MAX = C -}; - -inline const ABC (&EnumValuesABC())[4] { - static const ABC values[] = { - ABC::NONE, - ABC::A, - ABC::B, - ABC::C - }; - return values; -} - -inline const char *EnumNameABC(ABC e) { - switch (e) { - case ABC::NONE: return "NONE"; - case ABC::A: return "A"; - case ABC::B: return "B"; - case ABC::C: return "C"; - default: return ""; - } -} - -template<typename T> struct ABCTraits { - static const ABC enum_value = ABC::NONE; -}; - -template<> struct ABCTraits<UnionUnderlyingType::A> { - static const ABC enum_value = ABC::A; -}; - -template<> struct ABCTraits<UnionUnderlyingType::B> { - static const ABC enum_value = ABC::B; -}; - -template<> struct ABCTraits<UnionUnderlyingType::C> { - static const ABC enum_value = ABC::C; -}; - -template<typename T> struct ABCUnionTraits { - static const ABC enum_value = ABC::NONE; -}; - -template<> struct ABCUnionTraits<UnionUnderlyingType::AT> { - static const ABC enum_value = ABC::A; -}; - -template<> struct ABCUnionTraits<UnionUnderlyingType::BT> { - static const ABC enum_value = ABC::B; -}; - -template<> struct ABCUnionTraits<UnionUnderlyingType::CT> { - static const ABC enum_value = ABC::C; -}; - -struct ABCUnion { - ABC type; - void *value; - - ABCUnion() : type(ABC::NONE), value(nullptr) {} - ABCUnion(ABCUnion&& u) FLATBUFFERS_NOEXCEPT : - type(ABC::NONE), value(nullptr) - { std::swap(type, u.type); std::swap(value, u.value); } - ABCUnion(const ABCUnion &); - ABCUnion &operator=(const ABCUnion &u) - { ABCUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } - ABCUnion &operator=(ABCUnion &&u) FLATBUFFERS_NOEXCEPT - { std::swap(type, u.type); std::swap(value, u.value); return *this; } - ~ABCUnion() { Reset(); } - - void Reset(); - - template <typename T> - void Set(T&& val) { - typedef typename std::remove_reference<T>::type RT; - Reset(); - type = ABCUnionTraits<RT>::enum_value; - if (type != ABC::NONE) { - value = new RT(std::forward<T>(val)); - } - } - - static void *UnPack(const void *obj, ABC type, const ::flatbuffers::resolver_function_t *resolver); - ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; - - UnionUnderlyingType::AT *AsA() { - return type == ABC::A ? - reinterpret_cast<UnionUnderlyingType::AT *>(value) : nullptr; - } - const UnionUnderlyingType::AT *AsA() const { - return type == ABC::A ? - reinterpret_cast<const UnionUnderlyingType::AT *>(value) : nullptr; - } - UnionUnderlyingType::BT *AsB() { - return type == ABC::B ? - reinterpret_cast<UnionUnderlyingType::BT *>(value) : nullptr; - } - const UnionUnderlyingType::BT *AsB() const { - return type == ABC::B ? - reinterpret_cast<const UnionUnderlyingType::BT *>(value) : nullptr; - } - UnionUnderlyingType::CT *AsC() { - return type == ABC::C ? - reinterpret_cast<UnionUnderlyingType::CT *>(value) : nullptr; - } - const UnionUnderlyingType::CT *AsC() const { - return type == ABC::C ? - reinterpret_cast<const UnionUnderlyingType::CT *>(value) : nullptr; - } -}; - - -inline bool operator==(const ABCUnion &lhs, const ABCUnion &rhs) { - if (lhs.type != rhs.type) return false; - switch (lhs.type) { - case ABC::NONE: { - return true; - } - case ABC::A: { - return *(reinterpret_cast<const UnionUnderlyingType::AT *>(lhs.value)) == - *(reinterpret_cast<const UnionUnderlyingType::AT *>(rhs.value)); - } - case ABC::B: { - return *(reinterpret_cast<const UnionUnderlyingType::BT *>(lhs.value)) == - *(reinterpret_cast<const UnionUnderlyingType::BT *>(rhs.value)); - } - case ABC::C: { - return *(reinterpret_cast<const UnionUnderlyingType::CT *>(lhs.value)) == - *(reinterpret_cast<const UnionUnderlyingType::CT *>(rhs.value)); - } - default: { - return false; - } - } -} - -inline bool operator!=(const ABCUnion &lhs, const ABCUnion &rhs) { - return !(lhs == rhs); -} - -template <bool B = false> -bool VerifyABC(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, ABC type); -template <bool B = false> -bool VerifyABCVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types); - -struct AT : public ::flatbuffers::NativeTable { - typedef A TableType; - int32_t a = 0; -}; - -struct A FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef AT NativeTableType; - typedef ABuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return ATypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_A = 4 - }; - int32_t a() const { - return GetField<int32_t>(VT_A, 0); - } - bool mutate_a(int32_t _a = 0) { - return SetField<int32_t>(VT_A, _a, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_A, 4) && - verifier.EndTable(); - } - AT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(AT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<A> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct ABuilder { - typedef A Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_a(int32_t a) { - fbb_.AddElement<int32_t>(A::VT_A, a, 0); - } - explicit ABuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<A> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<A>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<A> CreateA( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t a = 0) { - ABuilder builder_(_fbb); - builder_.add_a(a); - return builder_.Finish(); -} - -::flatbuffers::Offset<A> CreateA(::flatbuffers::FlatBufferBuilder &_fbb, const AT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct BT : public ::flatbuffers::NativeTable { - typedef B TableType; - std::string b{}; -}; - -struct B FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef BT NativeTableType; - typedef BBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return BTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_B = 4 - }; - const ::flatbuffers::String *b() const { - return GetPointer<const ::flatbuffers::String *>(VT_B); - } - ::flatbuffers::String *mutable_b() { - return GetPointer<::flatbuffers::String *>(VT_B); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_B) && - verifier.VerifyString(b()) && - verifier.EndTable(); - } - BT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<B> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct BBuilder { - typedef B Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_b(::flatbuffers::Offset<::flatbuffers::String> b) { - fbb_.AddOffset(B::VT_B, b); - } - explicit BBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<B> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<B>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<B> CreateB( - ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<::flatbuffers::String> b = 0) { - BBuilder builder_(_fbb); - builder_.add_b(b); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<B> CreateBDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - const char *b = nullptr) { - auto b__ = b ? _fbb.CreateString(b) : 0; - return UnionUnderlyingType::CreateB( - _fbb, - b__); -} - -::flatbuffers::Offset<B> CreateB(::flatbuffers::FlatBufferBuilder &_fbb, const BT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct CT : public ::flatbuffers::NativeTable { - typedef C TableType; - bool c = false; -}; - -struct C FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef CT NativeTableType; - typedef CBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return CTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_C = 4 - }; - bool c() const { - return GetField<uint8_t>(VT_C, 0) != 0; - } - bool mutate_c(bool _c = 0) { - return SetField<uint8_t>(VT_C, static_cast<uint8_t>(_c), 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<uint8_t>(verifier, VT_C, 1) && - verifier.EndTable(); - } - CT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(CT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<C> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct CBuilder { - typedef C Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_c(bool c) { - fbb_.AddElement<uint8_t>(C::VT_C, static_cast<uint8_t>(c), 0); - } - explicit CBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<C> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<C>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<C> CreateC( - ::flatbuffers::FlatBufferBuilder &_fbb, - bool c = false) { - CBuilder builder_(_fbb); - builder_.add_c(c); - return builder_.Finish(); -} - -::flatbuffers::Offset<C> CreateC(::flatbuffers::FlatBufferBuilder &_fbb, const CT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct DT : public ::flatbuffers::NativeTable { - typedef D TableType; - UnionUnderlyingType::ABCUnion test_union{}; - std::vector<UnionUnderlyingType::ABCUnion> test_vector_of_union{}; -}; - -struct D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef DT NativeTableType; - typedef DBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return DTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TEST_UNION_TYPE = 4, - VT_TEST_UNION = 6, - VT_TEST_VECTOR_OF_UNION_TYPE = 8, - VT_TEST_VECTOR_OF_UNION = 10 - }; - UnionUnderlyingType::ABC test_union_type() const { - return static_cast<UnionUnderlyingType::ABC>(GetField<int32_t>(VT_TEST_UNION_TYPE, 0)); - } - const void *test_union() const { - return GetPointer<const void *>(VT_TEST_UNION); - } - template<typename T> const T *test_union_as() const; - const UnionUnderlyingType::A *test_union_as_A() const { - return test_union_type() == UnionUnderlyingType::ABC::A ? static_cast<const UnionUnderlyingType::A *>(test_union()) : nullptr; - } - const UnionUnderlyingType::B *test_union_as_B() const { - return test_union_type() == UnionUnderlyingType::ABC::B ? static_cast<const UnionUnderlyingType::B *>(test_union()) : nullptr; - } - const UnionUnderlyingType::C *test_union_as_C() const { - return test_union_type() == UnionUnderlyingType::ABC::C ? static_cast<const UnionUnderlyingType::C *>(test_union()) : nullptr; - } - template<typename T> T *mutable_test_union_as(); - UnionUnderlyingType::A *mutable_test_union_as_A() { - return test_union_type() == UnionUnderlyingType::ABC::A ? static_cast<UnionUnderlyingType::A *>(mutable_test_union()) : nullptr; - } - UnionUnderlyingType::B *mutable_test_union_as_B() { - return test_union_type() == UnionUnderlyingType::ABC::B ? static_cast<UnionUnderlyingType::B *>(mutable_test_union()) : nullptr; - } - UnionUnderlyingType::C *mutable_test_union_as_C() { - return test_union_type() == UnionUnderlyingType::ABC::C ? static_cast<UnionUnderlyingType::C *>(mutable_test_union()) : nullptr; - } - void *mutable_test_union() { - return GetPointer<void *>(VT_TEST_UNION); - } - const ::flatbuffers::Vector<UnionUnderlyingType::ABC> *test_vector_of_union_type() const { - return GetPointer<const ::flatbuffers::Vector<UnionUnderlyingType::ABC> *>(VT_TEST_VECTOR_OF_UNION_TYPE); - } - ::flatbuffers::Vector<UnionUnderlyingType::ABC> *mutable_test_vector_of_union_type() { - return GetPointer<::flatbuffers::Vector<UnionUnderlyingType::ABC> *>(VT_TEST_VECTOR_OF_UNION_TYPE); - } - const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *test_vector_of_union() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_TEST_VECTOR_OF_UNION); - } - ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_test_vector_of_union() { - return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_TEST_VECTOR_OF_UNION); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_TEST_UNION_TYPE, 1) && - VerifyOffset(verifier, VT_TEST_UNION) && - VerifyABC(verifier, test_union(), test_union_type()) && - VerifyOffset(verifier, VT_TEST_VECTOR_OF_UNION_TYPE) && - verifier.VerifyVector(test_vector_of_union_type()) && - VerifyOffset(verifier, VT_TEST_VECTOR_OF_UNION) && - verifier.VerifyVector(test_vector_of_union()) && - VerifyABCVector(verifier, test_vector_of_union(), test_vector_of_union_type()) && - verifier.EndTable(); - } - DT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<D> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -template<> inline const UnionUnderlyingType::A *D::test_union_as<UnionUnderlyingType::A>() const { - return test_union_as_A(); -} - -template<> inline UnionUnderlyingType::A *D::mutable_test_union_as<UnionUnderlyingType::A>() { - return mutable_test_union_as_A(); -} - -template<> inline const UnionUnderlyingType::B *D::test_union_as<UnionUnderlyingType::B>() const { - return test_union_as_B(); -} - -template<> inline UnionUnderlyingType::B *D::mutable_test_union_as<UnionUnderlyingType::B>() { - return mutable_test_union_as_B(); -} - -template<> inline const UnionUnderlyingType::C *D::test_union_as<UnionUnderlyingType::C>() const { - return test_union_as_C(); -} - -template<> inline UnionUnderlyingType::C *D::mutable_test_union_as<UnionUnderlyingType::C>() { - return mutable_test_union_as_C(); -} - -struct DBuilder { - typedef D Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_test_union_type(UnionUnderlyingType::ABC test_union_type) { - fbb_.AddElement<int32_t>(D::VT_TEST_UNION_TYPE, static_cast<int32_t>(test_union_type), 0); - } - void add_test_union(::flatbuffers::Offset<void> test_union) { - fbb_.AddOffset(D::VT_TEST_UNION, test_union); - } - void add_test_vector_of_union_type(::flatbuffers::Offset<::flatbuffers::Vector<UnionUnderlyingType::ABC>> test_vector_of_union_type) { - fbb_.AddOffset(D::VT_TEST_VECTOR_OF_UNION_TYPE, test_vector_of_union_type); - } - void add_test_vector_of_union(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> test_vector_of_union) { - fbb_.AddOffset(D::VT_TEST_VECTOR_OF_UNION, test_vector_of_union); - } - explicit DBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<D> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<D>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<D> CreateD( - ::flatbuffers::FlatBufferBuilder &_fbb, - UnionUnderlyingType::ABC test_union_type = UnionUnderlyingType::ABC::NONE, - ::flatbuffers::Offset<void> test_union = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<UnionUnderlyingType::ABC>> test_vector_of_union_type = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> test_vector_of_union = 0) { - DBuilder builder_(_fbb); - builder_.add_test_vector_of_union(test_vector_of_union); - builder_.add_test_vector_of_union_type(test_vector_of_union_type); - builder_.add_test_union(test_union); - builder_.add_test_union_type(test_union_type); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<D> CreateDDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - UnionUnderlyingType::ABC test_union_type = UnionUnderlyingType::ABC::NONE, - ::flatbuffers::Offset<void> test_union = 0, - const std::vector<UnionUnderlyingType::ABC> *test_vector_of_union_type = nullptr, - const std::vector<::flatbuffers::Offset<void>> *test_vector_of_union = nullptr) { - auto test_vector_of_union_type__ = test_vector_of_union_type ? _fbb.CreateVector<UnionUnderlyingType::ABC>(*test_vector_of_union_type) : 0; - auto test_vector_of_union__ = test_vector_of_union ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*test_vector_of_union) : 0; - return UnionUnderlyingType::CreateD( - _fbb, - test_union_type, - test_union, - test_vector_of_union_type__, - test_vector_of_union__); -} - -::flatbuffers::Offset<D> CreateD(::flatbuffers::FlatBufferBuilder &_fbb, const DT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const AT &lhs, const AT &rhs) { - return - (lhs.a == rhs.a); -} - -inline bool operator!=(const AT &lhs, const AT &rhs) { - return !(lhs == rhs); -} - - -inline AT *A::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<AT>(new AT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void A::UnPackTo(AT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = a(); _o->a = _e; } -} - -inline ::flatbuffers::Offset<A> CreateA(::flatbuffers::FlatBufferBuilder &_fbb, const AT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return A::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<A> A::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _a = _o->a; - return UnionUnderlyingType::CreateA( - _fbb, - _a); -} - - -inline bool operator==(const BT &lhs, const BT &rhs) { - return - (lhs.b == rhs.b); -} - -inline bool operator!=(const BT &lhs, const BT &rhs) { - return !(lhs == rhs); -} - - -inline BT *B::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<BT>(new BT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void B::UnPackTo(BT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = b(); if (_e) _o->b = _e->str(); } -} - -inline ::flatbuffers::Offset<B> CreateB(::flatbuffers::FlatBufferBuilder &_fbb, const BT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return B::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<B> B::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _b = _o->b.empty() ? 0 : _fbb.CreateString(_o->b); - return UnionUnderlyingType::CreateB( - _fbb, - _b); -} - - -inline bool operator==(const CT &lhs, const CT &rhs) { - return - (lhs.c == rhs.c); -} - -inline bool operator!=(const CT &lhs, const CT &rhs) { - return !(lhs == rhs); -} - - -inline CT *C::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<CT>(new CT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void C::UnPackTo(CT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = c(); _o->c = _e; } -} - -inline ::flatbuffers::Offset<C> CreateC(::flatbuffers::FlatBufferBuilder &_fbb, const CT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return C::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<C> C::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _c = _o->c; - return UnionUnderlyingType::CreateC( - _fbb, - _c); -} - - -inline bool operator==(const DT &lhs, const DT &rhs) { - return - (lhs.test_union == rhs.test_union) && - (lhs.test_vector_of_union == rhs.test_vector_of_union); -} - -inline bool operator!=(const DT &lhs, const DT &rhs) { - return !(lhs == rhs); -} - - -inline DT *D::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<DT>(new DT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void D::UnPackTo(DT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = test_union_type(); _o->test_union.type = _e; } - { auto _e = test_union(); if (_e) _o->test_union.value = UnionUnderlyingType::ABCUnion::UnPack(_e, test_union_type(), _resolver); } - { auto _e = test_vector_of_union_type(); if (_e) { _o->test_vector_of_union.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test_vector_of_union[_i].type = static_cast<UnionUnderlyingType::ABC>(_e->Get(_i)); } } else { _o->test_vector_of_union.resize(0); } } - { auto _e = test_vector_of_union(); if (_e) { _o->test_vector_of_union.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test_vector_of_union[_i].value = UnionUnderlyingType::ABCUnion::UnPack(_e->Get(_i), test_vector_of_union_type()->GetEnum<ABC>(_i), _resolver); } } else { _o->test_vector_of_union.resize(0); } } -} - -inline ::flatbuffers::Offset<D> CreateD(::flatbuffers::FlatBufferBuilder &_fbb, const DT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return D::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<D> D::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _test_union_type = _o->test_union.type; - auto _test_union = _o->test_union.Pack(_fbb); - auto _test_vector_of_union_type = _o->test_vector_of_union.size() ? _fbb.CreateVector<ABC>(_o->test_vector_of_union.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->test_vector_of_union[i].type; }, &_va) : 0; - auto _test_vector_of_union = _o->test_vector_of_union.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->test_vector_of_union.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->test_vector_of_union[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0; - return UnionUnderlyingType::CreateD( - _fbb, - _test_union_type, - _test_union, - _test_vector_of_union_type, - _test_vector_of_union); -} - -template <bool B> -inline bool VerifyABC(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, ABC type) { - switch (type) { - case ABC::NONE: { - return true; - } - case ABC::A: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::A *>(obj); - return verifier.VerifyTable(ptr); - } - case ABC::B: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::B *>(obj); - return verifier.VerifyTable(ptr); - } - case ABC::C: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::C *>(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -template <bool B> -inline bool VerifyABCVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyABC( - verifier, values->Get(i), types->GetEnum<ABC>(i))) { - return false; - } - } - return true; -} - -inline void *ABCUnion::UnPack(const void *obj, ABC type, const ::flatbuffers::resolver_function_t *resolver) { - (void)resolver; - switch (type) { - case ABC::A: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::A *>(obj); - return ptr->UnPack(resolver); - } - case ABC::B: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::B *>(obj); - return ptr->UnPack(resolver); - } - case ABC::C: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::C *>(obj); - return ptr->UnPack(resolver); - } - default: return nullptr; - } -} - -inline ::flatbuffers::Offset<void> ABCUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { - (void)_rehasher; - switch (type) { - case ABC::A: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::AT *>(value); - return CreateA(_fbb, ptr, _rehasher).Union(); - } - case ABC::B: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::BT *>(value); - return CreateB(_fbb, ptr, _rehasher).Union(); - } - case ABC::C: { - auto ptr = reinterpret_cast<const UnionUnderlyingType::CT *>(value); - return CreateC(_fbb, ptr, _rehasher).Union(); - } - default: return 0; - } -} - -inline ABCUnion::ABCUnion(const ABCUnion &u) : type(u.type), value(nullptr) { - switch (type) { - case ABC::A: { - value = new UnionUnderlyingType::AT(*reinterpret_cast<UnionUnderlyingType::AT *>(u.value)); - break; - } - case ABC::B: { - value = new UnionUnderlyingType::BT(*reinterpret_cast<UnionUnderlyingType::BT *>(u.value)); - break; - } - case ABC::C: { - value = new UnionUnderlyingType::CT(*reinterpret_cast<UnionUnderlyingType::CT *>(u.value)); - break; - } - default: - break; - } -} - -inline void ABCUnion::Reset() { - switch (type) { - case ABC::A: { - auto ptr = reinterpret_cast<UnionUnderlyingType::AT *>(value); - delete ptr; - break; - } - case ABC::B: { - auto ptr = reinterpret_cast<UnionUnderlyingType::BT *>(value); - delete ptr; - break; - } - case ABC::C: { - auto ptr = reinterpret_cast<UnionUnderlyingType::CT *>(value); - delete ptr; - break; - } - default: break; - } - value = nullptr; - type = ABC::NONE; -} - -inline const ::flatbuffers::TypeTable *ABCTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, -1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 2 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - UnionUnderlyingType::ATypeTable, - UnionUnderlyingType::BTypeTable, - UnionUnderlyingType::CTypeTable - }; - static const int64_t values[] = { 0, 555, 666, 777 }; - static const char * const names[] = { - "NONE", - "A", - "B", - "C" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *ATypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const char * const names[] = { - "a" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *BTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_STRING, 0, -1 } - }; - static const char * const names[] = { - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *CTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_BOOL, 0, -1 } - }; - static const char * const names[] = { - "c" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *DTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_UTYPE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_UTYPE, 1, 0 }, - { ::flatbuffers::ET_SEQUENCE, 1, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - UnionUnderlyingType::ABCTypeTable - }; - static const char * const names[] = { - "test_union_type", - "test_union", - "test_vector_of_union_type", - "test_vector_of_union" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -} // namespace UnionUnderlyingType - -#endif // FLATBUFFERS_GENERATED_UNIONUNDERLYINGTYPETEST_UNIONUNDERLYINGTYPE_H_
diff --git a/tests/union_vector/BUILD.bazel b/tests/union_vector/BUILD.bazel new file mode 100644 index 0000000..74fed36 --- /dev/null +++ b/tests/union_vector/BUILD.bazel
@@ -0,0 +1,25 @@ +load("//:build_defs.bzl", "flatbuffer_cc_library") + +package(default_visibility = ["//visibility:public"]) + +flatbuffer_cc_library( + name = "union_vector_cc_fbs", + srcs = ["union_vector.fbs"], + filename_suffix = ".fbs", + flatc_args = [ + "--gen-compare", + "--gen-mutable", + "--gen-object-api", + "--reflect-names", + "--filename-suffix .fbs", + ], +) + +# Data needed by the tests at runtime +filegroup( + name = "test_data", + srcs = [ + "union_vector.fbs", + "union_vector.json", + ], +)
diff --git a/tests/union_vector/union_vector_generated.h b/tests/union_vector/union_vector_generated.h deleted file mode 100644 index d057304..0000000 --- a/tests/union_vector/union_vector_generated.h +++ /dev/null
@@ -1,1332 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_UNIONVECTOR_H_ -#define FLATBUFFERS_GENERATED_UNIONVECTOR_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -struct Attacker; -struct AttackerBuilder; -struct AttackerT; - -struct Rapunzel; - -struct BookReader; - -struct FallingTub; - -struct HandFan; -struct HandFanBuilder; -struct HandFanT; - -struct Movie; -struct MovieBuilder; -struct MovieT; - -bool operator==(const AttackerT &lhs, const AttackerT &rhs); -bool operator!=(const AttackerT &lhs, const AttackerT &rhs); -bool operator==(const Rapunzel &lhs, const Rapunzel &rhs); -bool operator!=(const Rapunzel &lhs, const Rapunzel &rhs); -bool operator==(const BookReader &lhs, const BookReader &rhs); -bool operator!=(const BookReader &lhs, const BookReader &rhs); -bool operator==(const FallingTub &lhs, const FallingTub &rhs); -bool operator!=(const FallingTub &lhs, const FallingTub &rhs); -bool operator==(const HandFanT &lhs, const HandFanT &rhs); -bool operator!=(const HandFanT &lhs, const HandFanT &rhs); -bool operator==(const MovieT &lhs, const MovieT &rhs); -bool operator!=(const MovieT &lhs, const MovieT &rhs); - -inline const ::flatbuffers::TypeTable *AttackerTypeTable(); - -inline const ::flatbuffers::TypeTable *RapunzelTypeTable(); - -inline const ::flatbuffers::TypeTable *BookReaderTypeTable(); - -inline const ::flatbuffers::TypeTable *FallingTubTypeTable(); - -inline const ::flatbuffers::TypeTable *HandFanTypeTable(); - -inline const ::flatbuffers::TypeTable *MovieTypeTable(); - -enum Character : uint8_t { - Character_NONE = 0, - Character_MuLan = 1, - Character_Rapunzel = 2, - Character_Belle = 3, - Character_BookFan = 4, - Character_Other = 5, - Character_Unused = 6, - Character_MIN = Character_NONE, - Character_MAX = Character_Unused -}; - -inline const Character (&EnumValuesCharacter())[7] { - static const Character values[] = { - Character_NONE, - Character_MuLan, - Character_Rapunzel, - Character_Belle, - Character_BookFan, - Character_Other, - Character_Unused - }; - return values; -} - -inline const char * const *EnumNamesCharacter() { - static const char * const names[8] = { - "NONE", - "MuLan", - "Rapunzel", - "Belle", - "BookFan", - "Other", - "Unused", - nullptr - }; - return names; -} - -inline const char *EnumNameCharacter(Character e) { - if (::flatbuffers::IsOutRange(e, Character_NONE, Character_Unused)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesCharacter()[index]; -} - -struct CharacterUnion { - Character type; - void *value; - - CharacterUnion() : type(Character_NONE), value(nullptr) {} - CharacterUnion(CharacterUnion&& u) FLATBUFFERS_NOEXCEPT : - type(Character_NONE), value(nullptr) - { std::swap(type, u.type); std::swap(value, u.value); } - CharacterUnion(const CharacterUnion &); - CharacterUnion &operator=(const CharacterUnion &u) - { CharacterUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } - CharacterUnion &operator=(CharacterUnion &&u) FLATBUFFERS_NOEXCEPT - { std::swap(type, u.type); std::swap(value, u.value); return *this; } - ~CharacterUnion() { Reset(); } - - void Reset(); - - static void *UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver); - ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; - - AttackerT *AsMuLan() { - return type == Character_MuLan ? - reinterpret_cast<AttackerT *>(value) : nullptr; - } - const AttackerT *AsMuLan() const { - return type == Character_MuLan ? - reinterpret_cast<const AttackerT *>(value) : nullptr; - } - Rapunzel *AsRapunzel() { - return type == Character_Rapunzel ? - reinterpret_cast<Rapunzel *>(value) : nullptr; - } - const Rapunzel *AsRapunzel() const { - return type == Character_Rapunzel ? - reinterpret_cast<const Rapunzel *>(value) : nullptr; - } - BookReader *AsBelle() { - return type == Character_Belle ? - reinterpret_cast<BookReader *>(value) : nullptr; - } - const BookReader *AsBelle() const { - return type == Character_Belle ? - reinterpret_cast<const BookReader *>(value) : nullptr; - } - BookReader *AsBookFan() { - return type == Character_BookFan ? - reinterpret_cast<BookReader *>(value) : nullptr; - } - const BookReader *AsBookFan() const { - return type == Character_BookFan ? - reinterpret_cast<const BookReader *>(value) : nullptr; - } - std::string *AsOther() { - return type == Character_Other ? - reinterpret_cast<std::string *>(value) : nullptr; - } - const std::string *AsOther() const { - return type == Character_Other ? - reinterpret_cast<const std::string *>(value) : nullptr; - } - std::string *AsUnused() { - return type == Character_Unused ? - reinterpret_cast<std::string *>(value) : nullptr; - } - const std::string *AsUnused() const { - return type == Character_Unused ? - reinterpret_cast<const std::string *>(value) : nullptr; - } -}; - - -inline bool operator==(const CharacterUnion &lhs, const CharacterUnion &rhs) { - if (lhs.type != rhs.type) return false; - switch (lhs.type) { - case Character_NONE: { - return true; - } - case Character_MuLan: { - return *(reinterpret_cast<const AttackerT *>(lhs.value)) == - *(reinterpret_cast<const AttackerT *>(rhs.value)); - } - case Character_Rapunzel: { - return *(reinterpret_cast<const Rapunzel *>(lhs.value)) == - *(reinterpret_cast<const Rapunzel *>(rhs.value)); - } - case Character_Belle: { - return *(reinterpret_cast<const BookReader *>(lhs.value)) == - *(reinterpret_cast<const BookReader *>(rhs.value)); - } - case Character_BookFan: { - return *(reinterpret_cast<const BookReader *>(lhs.value)) == - *(reinterpret_cast<const BookReader *>(rhs.value)); - } - case Character_Other: { - return *(reinterpret_cast<const std::string *>(lhs.value)) == - *(reinterpret_cast<const std::string *>(rhs.value)); - } - case Character_Unused: { - return *(reinterpret_cast<const std::string *>(lhs.value)) == - *(reinterpret_cast<const std::string *>(rhs.value)); - } - default: { - return false; - } - } -} - -inline bool operator!=(const CharacterUnion &lhs, const CharacterUnion &rhs) { - return !(lhs == rhs); -} - -template <bool B = false> -bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type); -template <bool B = false> -bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types); - -enum Gadget : uint8_t { - Gadget_NONE = 0, - Gadget_FallingTub = 1, - Gadget_HandFan = 2, - Gadget_MIN = Gadget_NONE, - Gadget_MAX = Gadget_HandFan -}; - -inline const Gadget (&EnumValuesGadget())[3] { - static const Gadget values[] = { - Gadget_NONE, - Gadget_FallingTub, - Gadget_HandFan - }; - return values; -} - -inline const char * const *EnumNamesGadget() { - static const char * const names[4] = { - "NONE", - "FallingTub", - "HandFan", - nullptr - }; - return names; -} - -inline const char *EnumNameGadget(Gadget e) { - if (::flatbuffers::IsOutRange(e, Gadget_NONE, Gadget_HandFan)) return ""; - const size_t index = static_cast<size_t>(e); - return EnumNamesGadget()[index]; -} - -template<typename T> struct GadgetTraits { - static const Gadget enum_value = Gadget_NONE; -}; - -template<> struct GadgetTraits<FallingTub> { - static const Gadget enum_value = Gadget_FallingTub; -}; - -template<> struct GadgetTraits<HandFan> { - static const Gadget enum_value = Gadget_HandFan; -}; - -template<typename T> struct GadgetUnionTraits { - static const Gadget enum_value = Gadget_NONE; -}; - -template<> struct GadgetUnionTraits<FallingTub> { - static const Gadget enum_value = Gadget_FallingTub; -}; - -template<> struct GadgetUnionTraits<HandFanT> { - static const Gadget enum_value = Gadget_HandFan; -}; - -struct GadgetUnion { - Gadget type; - void *value; - - GadgetUnion() : type(Gadget_NONE), value(nullptr) {} - GadgetUnion(GadgetUnion&& u) FLATBUFFERS_NOEXCEPT : - type(Gadget_NONE), value(nullptr) - { std::swap(type, u.type); std::swap(value, u.value); } - GadgetUnion(const GadgetUnion &); - GadgetUnion &operator=(const GadgetUnion &u) - { GadgetUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } - GadgetUnion &operator=(GadgetUnion &&u) FLATBUFFERS_NOEXCEPT - { std::swap(type, u.type); std::swap(value, u.value); return *this; } - ~GadgetUnion() { Reset(); } - - void Reset(); - - template <typename T> - void Set(T&& val) { - typedef typename std::remove_reference<T>::type RT; - Reset(); - type = GadgetUnionTraits<RT>::enum_value; - if (type != Gadget_NONE) { - value = new RT(std::forward<T>(val)); - } - } - - static void *UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver); - ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; - - FallingTub *AsFallingTub() { - return type == Gadget_FallingTub ? - reinterpret_cast<FallingTub *>(value) : nullptr; - } - const FallingTub *AsFallingTub() const { - return type == Gadget_FallingTub ? - reinterpret_cast<const FallingTub *>(value) : nullptr; - } - HandFanT *AsHandFan() { - return type == Gadget_HandFan ? - reinterpret_cast<HandFanT *>(value) : nullptr; - } - const HandFanT *AsHandFan() const { - return type == Gadget_HandFan ? - reinterpret_cast<const HandFanT *>(value) : nullptr; - } -}; - - -inline bool operator==(const GadgetUnion &lhs, const GadgetUnion &rhs) { - if (lhs.type != rhs.type) return false; - switch (lhs.type) { - case Gadget_NONE: { - return true; - } - case Gadget_FallingTub: { - return *(reinterpret_cast<const FallingTub *>(lhs.value)) == - *(reinterpret_cast<const FallingTub *>(rhs.value)); - } - case Gadget_HandFan: { - return *(reinterpret_cast<const HandFanT *>(lhs.value)) == - *(reinterpret_cast<const HandFanT *>(rhs.value)); - } - default: { - return false; - } - } -} - -inline bool operator!=(const GadgetUnion &lhs, const GadgetUnion &rhs) { - return !(lhs == rhs); -} - -template <bool B = false> -bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type); -template <bool B = false> -bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types); - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS { - private: - int32_t hair_length_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return RapunzelTypeTable(); - } - Rapunzel() - : hair_length_(0) { - } - Rapunzel(int32_t _hair_length) - : hair_length_(::flatbuffers::EndianScalar(_hair_length)) { - } - int32_t hair_length() const { - return ::flatbuffers::EndianScalar(hair_length_); - } - void mutate_hair_length(int32_t _hair_length) { - ::flatbuffers::WriteScalar(&hair_length_, _hair_length); - } -}; -FLATBUFFERS_STRUCT_END(Rapunzel, 4); - -inline bool operator==(const Rapunzel &lhs, const Rapunzel &rhs) { - return - (lhs.hair_length() == rhs.hair_length()); -} - -inline bool operator!=(const Rapunzel &lhs, const Rapunzel &rhs) { - return !(lhs == rhs); -} - -template <typename H> -inline H AbslHashValue(H h, const Rapunzel &obj) { - return H::combine(std::move(h), obj.hair_length()); -} - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS { - private: - int32_t books_read_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return BookReaderTypeTable(); - } - BookReader() - : books_read_(0) { - } - BookReader(int32_t _books_read) - : books_read_(::flatbuffers::EndianScalar(_books_read)) { - } - int32_t books_read() const { - return ::flatbuffers::EndianScalar(books_read_); - } - void mutate_books_read(int32_t _books_read) { - ::flatbuffers::WriteScalar(&books_read_, _books_read); - } -}; -FLATBUFFERS_STRUCT_END(BookReader, 4); - -inline bool operator==(const BookReader &lhs, const BookReader &rhs) { - return - (lhs.books_read() == rhs.books_read()); -} - -inline bool operator!=(const BookReader &lhs, const BookReader &rhs) { - return !(lhs == rhs); -} - -template <typename H> -inline H AbslHashValue(H h, const BookReader &obj) { - return H::combine(std::move(h), obj.books_read()); -} - -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS { - private: - int32_t weight_; - - public: - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return FallingTubTypeTable(); - } - FallingTub() - : weight_(0) { - } - FallingTub(int32_t _weight) - : weight_(::flatbuffers::EndianScalar(_weight)) { - } - int32_t weight() const { - return ::flatbuffers::EndianScalar(weight_); - } - void mutate_weight(int32_t _weight) { - ::flatbuffers::WriteScalar(&weight_, _weight); - } -}; -FLATBUFFERS_STRUCT_END(FallingTub, 4); - -inline bool operator==(const FallingTub &lhs, const FallingTub &rhs) { - return - (lhs.weight() == rhs.weight()); -} - -inline bool operator!=(const FallingTub &lhs, const FallingTub &rhs) { - return !(lhs == rhs); -} - -template <typename H> -inline H AbslHashValue(H h, const FallingTub &obj) { - return H::combine(std::move(h), obj.weight()); -} - -struct AttackerT : public ::flatbuffers::NativeTable { - typedef Attacker TableType; - int32_t sword_attack_damage = 0; -}; - -struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef AttackerT NativeTableType; - typedef AttackerBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return AttackerTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_SWORD_ATTACK_DAMAGE = 4 - }; - int32_t sword_attack_damage() const { - return GetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, 0); - } - bool mutate_sword_attack_damage(int32_t _sword_attack_damage = 0) { - return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) && - verifier.EndTable(); - } - AttackerT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<Attacker> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct AttackerBuilder { - typedef Attacker Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_sword_attack_damage(int32_t sword_attack_damage) { - fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0); - } - explicit AttackerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<Attacker> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<Attacker>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<Attacker> CreateAttacker( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t sword_attack_damage = 0) { - AttackerBuilder builder_(_fbb); - builder_.add_sword_attack_damage(sword_attack_damage); - return builder_.Finish(); -} - -::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct HandFanT : public ::flatbuffers::NativeTable { - typedef HandFan TableType; - int32_t length = 0; -}; - -struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef HandFanT NativeTableType; - typedef HandFanBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return HandFanTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_LENGTH = 4 - }; - int32_t length() const { - return GetField<int32_t>(VT_LENGTH, 0); - } - bool mutate_length(int32_t _length = 0) { - return SetField<int32_t>(VT_LENGTH, _length, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_LENGTH, 4) && - verifier.EndTable(); - } - HandFanT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<HandFan> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct HandFanBuilder { - typedef HandFan Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_length(int32_t length) { - fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0); - } - explicit HandFanBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<HandFan> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<HandFan>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<HandFan> CreateHandFan( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t length = 0) { - HandFanBuilder builder_(_fbb); - builder_.add_length(length); - return builder_.Finish(); -} - -::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct MovieT : public ::flatbuffers::NativeTable { - typedef Movie TableType; - CharacterUnion main_character{}; - std::vector<CharacterUnion> characters{}; -}; - -struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef MovieT NativeTableType; - typedef MovieBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return MovieTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MAIN_CHARACTER_TYPE = 4, - VT_MAIN_CHARACTER = 6, - VT_CHARACTERS_TYPE = 8, - VT_CHARACTERS = 10 - }; - Character main_character_type() const { - return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0)); - } - const void *main_character() const { - return GetPointer<const void *>(VT_MAIN_CHARACTER); - } - const Attacker *main_character_as_MuLan() const { - return main_character_type() == Character_MuLan ? static_cast<const Attacker *>(main_character()) : nullptr; - } - const Rapunzel *main_character_as_Rapunzel() const { - return main_character_type() == Character_Rapunzel ? static_cast<const Rapunzel *>(main_character()) : nullptr; - } - const BookReader *main_character_as_Belle() const { - return main_character_type() == Character_Belle ? static_cast<const BookReader *>(main_character()) : nullptr; - } - const BookReader *main_character_as_BookFan() const { - return main_character_type() == Character_BookFan ? static_cast<const BookReader *>(main_character()) : nullptr; - } - const ::flatbuffers::String *main_character_as_Other() const { - return main_character_type() == Character_Other ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr; - } - const ::flatbuffers::String *main_character_as_Unused() const { - return main_character_type() == Character_Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr; - } - Attacker *mutable_main_character_as_MuLan() { - return main_character_type() == Character_MuLan ? static_cast<Attacker *>(mutable_main_character()) : nullptr; - } - Rapunzel *mutable_main_character_as_Rapunzel() { - return main_character_type() == Character_Rapunzel ? static_cast<Rapunzel *>(mutable_main_character()) : nullptr; - } - BookReader *mutable_main_character_as_Belle() { - return main_character_type() == Character_Belle ? static_cast<BookReader *>(mutable_main_character()) : nullptr; - } - BookReader *mutable_main_character_as_BookFan() { - return main_character_type() == Character_BookFan ? static_cast<BookReader *>(mutable_main_character()) : nullptr; - } - ::flatbuffers::String *mutable_main_character_as_Other() { - return main_character_type() == Character_Other ? static_cast<::flatbuffers::String *>(mutable_main_character()) : nullptr; - } - ::flatbuffers::String *mutable_main_character_as_Unused() { - return main_character_type() == Character_Unused ? static_cast<::flatbuffers::String *>(mutable_main_character()) : nullptr; - } - void *mutable_main_character() { - return GetPointer<void *>(VT_MAIN_CHARACTER); - } - const ::flatbuffers::Vector<uint8_t> *characters_type() const { - return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE); - } - ::flatbuffers::Vector<uint8_t> *mutable_characters_type() { - return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE); - } - const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *characters() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS); - } - ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() { - return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) && - VerifyOffset(verifier, VT_MAIN_CHARACTER) && - VerifyCharacter(verifier, main_character(), main_character_type()) && - VerifyOffset(verifier, VT_CHARACTERS_TYPE) && - verifier.VerifyVector(characters_type()) && - VerifyOffset(verifier, VT_CHARACTERS) && - verifier.VerifyVector(characters()) && - VerifyCharacterVector(verifier, characters(), characters_type()) && - verifier.EndTable(); - } - MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct MovieBuilder { - typedef Movie Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_main_character_type(Character main_character_type) { - fbb_.AddElement<uint8_t>(Movie::VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(main_character_type), 0); - } - void add_main_character(::flatbuffers::Offset<void> main_character) { - fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character); - } - void add_characters_type(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type) { - fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, characters_type); - } - void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) { - fbb_.AddOffset(Movie::VT_CHARACTERS, characters); - } - explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<Movie> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<Movie>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<Movie> CreateMovie( - ::flatbuffers::FlatBufferBuilder &_fbb, - Character main_character_type = Character_NONE, - ::flatbuffers::Offset<void> main_character = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type = 0, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) { - MovieBuilder builder_(_fbb); - builder_.add_characters(characters); - builder_.add_characters_type(characters_type); - builder_.add_main_character(main_character); - builder_.add_main_character_type(main_character_type); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<Movie> CreateMovieDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - Character main_character_type = Character_NONE, - ::flatbuffers::Offset<void> main_character = 0, - const std::vector<uint8_t> *characters_type = nullptr, - const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) { - auto characters_type__ = characters_type ? _fbb.CreateVector<uint8_t>(*characters_type) : 0; - auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0; - return CreateMovie( - _fbb, - main_character_type, - main_character, - characters_type__, - characters__); -} - -::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const AttackerT &lhs, const AttackerT &rhs) { - return - (lhs.sword_attack_damage == rhs.sword_attack_damage); -} - -inline bool operator!=(const AttackerT &lhs, const AttackerT &rhs) { - return !(lhs == rhs); -} - - -inline AttackerT *Attacker::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<AttackerT>(new AttackerT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void Attacker::UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; } -} - -inline ::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return Attacker::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<Attacker> Attacker::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _sword_attack_damage = _o->sword_attack_damage; - return CreateAttacker( - _fbb, - _sword_attack_damage); -} - - -inline bool operator==(const HandFanT &lhs, const HandFanT &rhs) { - return - (lhs.length == rhs.length); -} - -inline bool operator!=(const HandFanT &lhs, const HandFanT &rhs) { - return !(lhs == rhs); -} - - -inline HandFanT *HandFan::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<HandFanT>(new HandFanT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void HandFan::UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = length(); _o->length = _e; } -} - -inline ::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return HandFan::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<HandFan> HandFan::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _length = _o->length; - return CreateHandFan( - _fbb, - _length); -} - - -inline bool operator==(const MovieT &lhs, const MovieT &rhs) { - return - (lhs.main_character == rhs.main_character) && - (lhs.characters == rhs.characters); -} - -inline bool operator!=(const MovieT &lhs, const MovieT &rhs) { - return !(lhs == rhs); -} - - -inline MovieT *Movie::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<MovieT>(new MovieT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = main_character_type(); _o->main_character.type = _e; } - { auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); } - { auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } } - { auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } } -} - -inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return Movie::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _main_character_type = _o->main_character.type; - auto _main_character = _o->main_character.Pack(_fbb); - auto _characters_type = _o->characters.size() ? _fbb.CreateVector<uint8_t>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return static_cast<uint8_t>(__va->__o->characters[i].type); }, &_va) : 0; - auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0; - return CreateMovie( - _fbb, - _main_character_type, - _main_character, - _characters_type, - _characters); -} - -template <bool B> -inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type) { - switch (type) { - case Character_NONE: { - return true; - } - case Character_MuLan: { - auto ptr = reinterpret_cast<const Attacker *>(obj); - return verifier.VerifyTable(ptr); - } - case Character_Rapunzel: { - return verifier.template VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4); - } - case Character_Belle: { - return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4); - } - case Character_BookFan: { - return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4); - } - case Character_Other: { - auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj); - return verifier.VerifyString(ptr); - } - case Character_Unused: { - auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj); - return verifier.VerifyString(ptr); - } - default: return true; - } -} - -template <bool B> -inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyCharacter( - verifier, values->Get(i), types->GetEnum<Character>(i))) { - return false; - } - } - return true; -} - -inline void *CharacterUnion::UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver) { - (void)resolver; - switch (type) { - case Character_MuLan: { - auto ptr = reinterpret_cast<const Attacker *>(obj); - return ptr->UnPack(resolver); - } - case Character_Rapunzel: { - auto ptr = reinterpret_cast<const Rapunzel *>(obj); - return new Rapunzel(*ptr); - } - case Character_Belle: { - auto ptr = reinterpret_cast<const BookReader *>(obj); - return new BookReader(*ptr); - } - case Character_BookFan: { - auto ptr = reinterpret_cast<const BookReader *>(obj); - return new BookReader(*ptr); - } - case Character_Other: { - auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj); - return new std::string(ptr->c_str(), ptr->size()); - } - case Character_Unused: { - auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj); - return new std::string(ptr->c_str(), ptr->size()); - } - default: return nullptr; - } -} - -inline ::flatbuffers::Offset<void> CharacterUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { - (void)_rehasher; - switch (type) { - case Character_MuLan: { - auto ptr = reinterpret_cast<const AttackerT *>(value); - return CreateAttacker(_fbb, ptr, _rehasher).Union(); - } - case Character_Rapunzel: { - auto ptr = reinterpret_cast<const Rapunzel *>(value); - return _fbb.CreateStruct(*ptr).Union(); - } - case Character_Belle: { - auto ptr = reinterpret_cast<const BookReader *>(value); - return _fbb.CreateStruct(*ptr).Union(); - } - case Character_BookFan: { - auto ptr = reinterpret_cast<const BookReader *>(value); - return _fbb.CreateStruct(*ptr).Union(); - } - case Character_Other: { - auto ptr = reinterpret_cast<const std::string *>(value); - return _fbb.CreateString(*ptr).Union(); - } - case Character_Unused: { - auto ptr = reinterpret_cast<const std::string *>(value); - return _fbb.CreateString(*ptr).Union(); - } - default: return 0; - } -} - -inline CharacterUnion::CharacterUnion(const CharacterUnion &u) : type(u.type), value(nullptr) { - switch (type) { - case Character_MuLan: { - value = new AttackerT(*reinterpret_cast<AttackerT *>(u.value)); - break; - } - case Character_Rapunzel: { - value = new Rapunzel(*reinterpret_cast<Rapunzel *>(u.value)); - break; - } - case Character_Belle: { - value = new BookReader(*reinterpret_cast<BookReader *>(u.value)); - break; - } - case Character_BookFan: { - value = new BookReader(*reinterpret_cast<BookReader *>(u.value)); - break; - } - case Character_Other: { - value = new std::string(*reinterpret_cast<std::string *>(u.value)); - break; - } - case Character_Unused: { - value = new std::string(*reinterpret_cast<std::string *>(u.value)); - break; - } - default: - break; - } -} - -inline void CharacterUnion::Reset() { - switch (type) { - case Character_MuLan: { - auto ptr = reinterpret_cast<AttackerT *>(value); - delete ptr; - break; - } - case Character_Rapunzel: { - auto ptr = reinterpret_cast<Rapunzel *>(value); - delete ptr; - break; - } - case Character_Belle: { - auto ptr = reinterpret_cast<BookReader *>(value); - delete ptr; - break; - } - case Character_BookFan: { - auto ptr = reinterpret_cast<BookReader *>(value); - delete ptr; - break; - } - case Character_Other: { - auto ptr = reinterpret_cast<std::string *>(value); - delete ptr; - break; - } - case Character_Unused: { - auto ptr = reinterpret_cast<std::string *>(value); - delete ptr; - break; - } - default: break; - } - value = nullptr; - type = Character_NONE; -} - -template <bool B> -inline bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type) { - switch (type) { - case Gadget_NONE: { - return true; - } - case Gadget_FallingTub: { - return verifier.template VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4); - } - case Gadget_HandFan: { - auto ptr = reinterpret_cast<const HandFan *>(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -template <bool B> -inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyGadget( - verifier, values->Get(i), types->GetEnum<Gadget>(i))) { - return false; - } - } - return true; -} - -inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver) { - (void)resolver; - switch (type) { - case Gadget_FallingTub: { - auto ptr = reinterpret_cast<const FallingTub *>(obj); - return new FallingTub(*ptr); - } - case Gadget_HandFan: { - auto ptr = reinterpret_cast<const HandFan *>(obj); - return ptr->UnPack(resolver); - } - default: return nullptr; - } -} - -inline ::flatbuffers::Offset<void> GadgetUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { - (void)_rehasher; - switch (type) { - case Gadget_FallingTub: { - auto ptr = reinterpret_cast<const FallingTub *>(value); - return _fbb.CreateStruct(*ptr).Union(); - } - case Gadget_HandFan: { - auto ptr = reinterpret_cast<const HandFanT *>(value); - return CreateHandFan(_fbb, ptr, _rehasher).Union(); - } - default: return 0; - } -} - -inline GadgetUnion::GadgetUnion(const GadgetUnion &u) : type(u.type), value(nullptr) { - switch (type) { - case Gadget_FallingTub: { - value = new FallingTub(*reinterpret_cast<FallingTub *>(u.value)); - break; - } - case Gadget_HandFan: { - value = new HandFanT(*reinterpret_cast<HandFanT *>(u.value)); - break; - } - default: - break; - } -} - -inline void GadgetUnion::Reset() { - switch (type) { - case Gadget_FallingTub: { - auto ptr = reinterpret_cast<FallingTub *>(value); - delete ptr; - break; - } - case Gadget_HandFan: { - auto ptr = reinterpret_cast<HandFanT *>(value); - delete ptr; - break; - } - default: break; - } - value = nullptr; - type = Gadget_NONE; -} - -inline const ::flatbuffers::TypeTable *CharacterTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, -1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 2 }, - { ::flatbuffers::ET_SEQUENCE, 0, 2 }, - { ::flatbuffers::ET_STRING, 0, -1 }, - { ::flatbuffers::ET_STRING, 0, -1 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - AttackerTypeTable, - RapunzelTypeTable, - BookReaderTypeTable - }; - static const char * const names[] = { - "NONE", - "MuLan", - "Rapunzel", - "Belle", - "BookFan", - "Other", - "Unused" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *GadgetTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 0, -1 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 1 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - FallingTubTypeTable, - HandFanTypeTable - }; - static const char * const names[] = { - "NONE", - "FallingTub", - "HandFan" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *AttackerTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const char * const names[] = { - "sword_attack_damage" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *RapunzelTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const int64_t values[] = { 0, 4 }; - static const char * const names[] = { - "hair_length" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *BookReaderTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const int64_t values[] = { 0, 4 }; - static const char * const names[] = { - "books_read" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *FallingTubTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const int64_t values[] = { 0, 4 }; - static const char * const names[] = { - "weight" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *HandFanTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const char * const names[] = { - "length" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *MovieTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_UTYPE, 0, 0 }, - { ::flatbuffers::ET_SEQUENCE, 0, 0 }, - { ::flatbuffers::ET_UTYPE, 1, 0 }, - { ::flatbuffers::ET_SEQUENCE, 1, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - CharacterTypeTable - }; - static const char * const names[] = { - "main_character_type", - "main_character", - "characters_type", - "characters" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const Movie *GetMovie(const void *buf) { - return ::flatbuffers::GetRoot<Movie>(buf); -} - -inline const Movie *GetSizePrefixedMovie(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<Movie>(buf); -} - -inline Movie *GetMutableMovie(void *buf) { - return ::flatbuffers::GetMutableRoot<Movie>(buf); -} - -inline Movie *GetMutableSizePrefixedMovie(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf); -} - -inline const char *MovieIdentifier() { - return "MOVI"; -} - -inline bool MovieBufferHasIdentifier(const void *buf) { - return ::flatbuffers::BufferHasIdentifier( - buf, MovieIdentifier()); -} - -inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) { - return ::flatbuffers::BufferHasIdentifier( - buf, MovieIdentifier(), true); -} - -template <bool B = false> -inline bool VerifyMovieBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<Movie>(MovieIdentifier()); -} - -template <bool B = false> -inline bool VerifySizePrefixedMovieBuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<Movie>(MovieIdentifier()); -} - -inline void FinishMovieBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Movie> root) { - fbb.Finish(root, MovieIdentifier()); -} - -inline void FinishSizePrefixedMovieBuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<Movie> root) { - fbb.FinishSizePrefixed(root, MovieIdentifier()); -} - -inline std::unique_ptr<MovieT> UnPackMovie( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res)); -} - -inline std::unique_ptr<MovieT> UnPackSizePrefixedMovie( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res)); -} - -#endif // FLATBUFFERS_GENERATED_UNIONVECTOR_H_
diff --git a/tests/vector_table_naked_ptr/vector_table_naked_ptr_generated.h b/tests/vector_table_naked_ptr/vector_table_naked_ptr_generated.h deleted file mode 100644 index 49aae76..0000000 --- a/tests/vector_table_naked_ptr/vector_table_naked_ptr_generated.h +++ /dev/null
@@ -1,331 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_VECTORTABLENAKEDPTR_H_ -#define FLATBUFFERS_GENERATED_VECTORTABLENAKEDPTR_H_ - -#include "flatbuffers/flatbuffers.h" - -// Ensure the included flatbuffers.h is the same version as when this file was -// generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && - FLATBUFFERS_VERSION_MINOR == 12 && - FLATBUFFERS_VERSION_REVISION == 19, - "Non-compatible flatbuffers version included"); - -struct B; -struct BBuilder; -struct BT; - -struct A; -struct ABuilder; -struct AT; - -bool operator==(const BT &lhs, const BT &rhs); -bool operator!=(const BT &lhs, const BT &rhs); -bool operator==(const AT &lhs, const AT &rhs); -bool operator!=(const AT &lhs, const AT &rhs); - -inline const ::flatbuffers::TypeTable *BTypeTable(); - -inline const ::flatbuffers::TypeTable *ATypeTable(); - -struct BT : public ::flatbuffers::NativeTable { - typedef B TableType; - int32_t id = 0; -}; - -struct B FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef BT NativeTableType; - typedef BBuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return BTypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ID = 4 - }; - int32_t id() const { - return GetField<int32_t>(VT_ID, 0); - } - bool mutate_id(int32_t _id = 0) { - return SetField<int32_t>(VT_ID, _id, 0); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyField<int32_t>(verifier, VT_ID, 4) && - verifier.EndTable(); - } - BT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<B> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct BBuilder { - typedef B Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_id(int32_t id) { - fbb_.AddElement<int32_t>(B::VT_ID, id, 0); - } - explicit BBuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<B> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<B>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<B> CreateB( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t id = 0) { - BBuilder builder_(_fbb); - builder_.add_id(id); - return builder_.Finish(); -} - -::flatbuffers::Offset<B> CreateB(::flatbuffers::FlatBufferBuilder &_fbb, const BT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - -struct AT : public ::flatbuffers::NativeTable { - typedef A TableType; - std::vector<BT *> b{}; - AT() = default; - AT(const AT &o); - AT(AT&&) FLATBUFFERS_NOEXCEPT = default; - AT &operator=(AT o) FLATBUFFERS_NOEXCEPT; -}; - -struct A FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef AT NativeTableType; - typedef ABuilder Builder; - static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return ATypeTable(); - } - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_B = 4 - }; - const ::flatbuffers::Vector<::flatbuffers::Offset<B>> *b() const { - return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<B>> *>(VT_B); - } - ::flatbuffers::Vector<::flatbuffers::Offset<B>> *mutable_b() { - return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<B>> *>(VT_B); - } - template <bool B = false> - bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_B) && - verifier.VerifyVector(b()) && - verifier.VerifyVectorOfTables(b()) && - verifier.EndTable(); - } - AT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(AT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset<A> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -}; - -struct ABuilder { - typedef A Table; - ::flatbuffers::FlatBufferBuilder &fbb_; - ::flatbuffers::uoffset_t start_; - void add_b(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<B>>> b) { - fbb_.AddOffset(A::VT_B, b); - } - explicit ABuilder(::flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - ::flatbuffers::Offset<A> Finish() { - const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset<A>(end); - return o; - } -}; - -inline ::flatbuffers::Offset<A> CreateA( - ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<B>>> b = 0) { - ABuilder builder_(_fbb); - builder_.add_b(b); - return builder_.Finish(); -} - -inline ::flatbuffers::Offset<A> CreateADirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - const std::vector<::flatbuffers::Offset<B>> *b = nullptr) { - auto b__ = b ? _fbb.CreateVector<::flatbuffers::Offset<B>>(*b) : 0; - return CreateA( - _fbb, - b__); -} - -::flatbuffers::Offset<A> CreateA(::flatbuffers::FlatBufferBuilder &_fbb, const AT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); - - -inline bool operator==(const BT &lhs, const BT &rhs) { - return - (lhs.id == rhs.id); -} - -inline bool operator!=(const BT &lhs, const BT &rhs) { - return !(lhs == rhs); -} - - -inline BT *B::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<BT>(new BT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void B::UnPackTo(BT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = id(); _o->id = _e; } -} - -inline ::flatbuffers::Offset<B> CreateB(::flatbuffers::FlatBufferBuilder &_fbb, const BT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return B::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<B> B::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _id = _o->id; - return CreateB( - _fbb, - _id); -} - - -inline bool operator==(const AT &lhs, const AT &rhs) { - return - (lhs.b.size() == rhs.b.size() && std::equal(lhs.b.cbegin(), lhs.b.cend(), rhs.b.cbegin(), [](BT * const &a, BT * const &b) { return (a == b) || (a && b && *a == *b); })); -} - -inline bool operator!=(const AT &lhs, const AT &rhs) { - return !(lhs == rhs); -} - - -inline AT::AT(const AT &o) { - b.reserve(o.b.size()); - for (const auto &b_ : o.b) { b.emplace_back((b_) ? new BT(*b_) : nullptr); } -} - -inline AT &AT::operator=(AT o) FLATBUFFERS_NOEXCEPT { - std::swap(b, o.b); - return *this; -} - -inline AT *A::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr<AT>(new AT()); - UnPackTo(_o.get(), _resolver); - return _o.release(); -} - -inline void A::UnPackTo(AT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { - (void)_o; - (void)_resolver; - { auto _e = b(); if (_e) { _o->b.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->b[_i]) { _e->Get(_i)->UnPackTo(_o->b[_i], _resolver); } else { _o->b[_i] = (_e->Get(_i)->UnPack(_resolver)); } } } else { _o->b.resize(0); } } -} - -inline ::flatbuffers::Offset<A> CreateA(::flatbuffers::FlatBufferBuilder &_fbb, const AT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return A::Pack(_fbb, _o, _rehasher); -} - -inline ::flatbuffers::Offset<A> A::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - (void)_rehasher; - (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _b = _o->b.size() ? _fbb.CreateVector<::flatbuffers::Offset<B>> (_o->b.size(), [](size_t i, _VectorArgs *__va) { return CreateB(*__va->__fbb, __va->__o->b[i], __va->__rehasher); }, &_va ) : 0; - return CreateA( - _fbb, - _b); -} - -inline const ::flatbuffers::TypeTable *BTypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_INT, 0, -1 } - }; - static const char * const names[] = { - "id" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names - }; - return &tt; -} - -inline const ::flatbuffers::TypeTable *ATypeTable() { - static const ::flatbuffers::TypeCode type_codes[] = { - { ::flatbuffers::ET_SEQUENCE, 1, 0 } - }; - static const ::flatbuffers::TypeFunction type_refs[] = { - BTypeTable - }; - static const char * const names[] = { - "b" - }; - static const ::flatbuffers::TypeTable tt = { - ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names - }; - return &tt; -} - -inline const A *GetA(const void *buf) { - return ::flatbuffers::GetRoot<A>(buf); -} - -inline const A *GetSizePrefixedA(const void *buf) { - return ::flatbuffers::GetSizePrefixedRoot<A>(buf); -} - -inline A *GetMutableA(void *buf) { - return ::flatbuffers::GetMutableRoot<A>(buf); -} - -inline A *GetMutableSizePrefixedA(void *buf) { - return ::flatbuffers::GetMutableSizePrefixedRoot<A>(buf); -} - -template <bool B = false> -inline bool VerifyABuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifyBuffer<A>(nullptr); -} - -template <bool B = false> -inline bool VerifySizePrefixedABuffer( - ::flatbuffers::VerifierTemplate<B> &verifier) { - return verifier.template VerifySizePrefixedBuffer<A>(nullptr); -} - -inline void FinishABuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<A> root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedABuffer( - ::flatbuffers::FlatBufferBuilder &fbb, - ::flatbuffers::Offset<A> root) { - fbb.FinishSizePrefixed(root); -} - -inline AT * UnPackA( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return (GetA(buf)->UnPack(res)); -} - -inline AT * UnPackSizePrefixedA( - const void *buf, - const ::flatbuffers::resolver_function_t *res = nullptr) { - return (GetSizePrefixedA(buf)->UnPack(res)); -} - -#endif // FLATBUFFERS_GENERATED_VECTORTABLENAKEDPTR_H_
diff --git a/tests/vector_table_naked_ptr_test.cpp b/tests/vector_table_naked_ptr_test.cpp index 98c56aa..98c529e 100644 --- a/tests/vector_table_naked_ptr_test.cpp +++ b/tests/vector_table_naked_ptr_test.cpp
@@ -1,7 +1,7 @@ #include "vector_table_naked_ptr_test.h" #include "test_assert.h" -#include "vector_table_naked_ptr/vector_table_naked_ptr_generated.h" +#include "vector_table_naked_ptr.fbs.h" namespace flatbuffers { namespace tests {