Remove generated .h files from repo

CMakeLists.txt

@@ -515,13 +515,13 @@ function(compile_schema SRC_FBS OPT SUFFIX OUT_GEN_FILE)
 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 @@ if(FLATBUFFERS_BUILD_TESTS)
   # 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_TESTS)
   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()

scripts/generate_code.py

@@ -240,12 +240,6 @@ flatc(
     ],
 )
 
-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",
@@ -362,7 +356,13 @@ flatc(
 )
 
 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",
 )
 

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",
+    ],
+)

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",
+    ],
+)

tests/64bit/evolution/v1_generated.h

@@ -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_

tests/64bit/evolution/v2_generated.h

@@ -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_

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 {

tests/64bit/test_64bit_generated.h

@@ -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_

tests/BUILD.bazel

@@ -24,21 +24,12 @@ cc_test(
     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 @@ cc_test(
         "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 @@ cc_test(
         "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 @@ cc_test(
         ":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 @@ cc_test(
         ":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 @@ cc_test(
         ":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 @@ cc_test(
         ":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 @@ cc_library(
     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 @@ cc_library(
 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 @@ flatbuffer_cc_library(
         "--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 @@ flatbuffer_cc_library(
         "--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",
+    ],
 )

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 {

tests/cpp17/generated_cpp17/optional_scalars2_generated.h

@@ -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_

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;

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"
 

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",
+    ],
+)

tests/evolution_test/evolution_v1_generated.h

@@ -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_

tests/evolution_test/evolution_v2_generated.h

@@ -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_

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"

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 {

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",
+    ],
+)

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 {

tests/monster_extra_generated.h

@@ -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_

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"
 

tests/namespace_test/namespace_test1_generated.h

@@ -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_

tests/namespace_test/namespace_test2_generated.h

@@ -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_

tests/native_inline_table_test_generated.h

@@ -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_

tests/native_type_test_generated.h

@@ -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_

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) {

tests/optional_scalars_generated.h

@@ -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_

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 {

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 {

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"

tests/union_underlying_type_test_generated.h

@@ -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_

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",
+    ],
+)

tests/vector_table_naked_ptr/vector_table_naked_ptr_generated.h

@@ -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_

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 {