mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-01 19:58:15 +00:00
remove and auto-generate arrays_test_generated.h
This commit is contained in:
Derek Bailey
@@ -518,7 +518,15 @@ endfunction()
|
||||
if(FLATBUFFERS_BUILD_TESTS)
|
||||
add_executable(flattests ${FlatBuffers_Tests_SRCS})
|
||||
target_link_libraries(flattests PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
|
||||
target_include_directories(flattests PUBLIC src tests)
|
||||
target_include_directories(flattests 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
|
||||
)
|
||||
|
||||
# Have tests load data from the source directory, not the build directory.
|
||||
add_definitions(-DFLATBUFFERS_TEST_PATH_PREFIX=${CMAKE_CURRENT_SOURCE_DIR}/)
|
||||
@@ -528,6 +536,7 @@ if(FLATBUFFERS_BUILD_TESTS)
|
||||
SET(FLATC_OPT_COMP ${FLATC_OPT};--gen-compare)
|
||||
|
||||
compile_schema_for_test(tests/alignment_test.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/arrays_test.fbs "${FLATC_OPT_COMP};--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}")
|
||||
compile_schema_for_test(tests/key_field/key_field_sample.fbs "${FLATC_OPT_COMP}")
|
||||
|
||||
@@ -7,15 +7,14 @@
|
||||
#include <limits>
|
||||
#include <ostream>
|
||||
|
||||
#include "evolution/v1_generated.h"
|
||||
#include "evolution/v2_generated.h"
|
||||
#include "flatbuffers/base.h"
|
||||
#include "flatbuffers/buffer.h"
|
||||
#include "flatbuffers/flatbuffer_builder.h"
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
#include "test_64bit_generated.h"
|
||||
#include "test_assert.h"
|
||||
|
||||
#include "tests/64bit/evolution/v1_generated.h"
|
||||
#include "tests/64bit/evolution/v2_generated.h"
|
||||
#include "tests/64bit/test_64bit_generated.h"
|
||||
#include "tests/test_assert.h"
|
||||
|
||||
namespace flatbuffers {
|
||||
namespace tests {
|
||||
|
||||
@@ -1,539 +0,0 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_ARRAYSTEST_MYGAME_EXAMPLE_H_
|
||||
#define FLATBUFFERS_GENERATED_ARRAYSTEST_MYGAME_EXAMPLE_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 == 23 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 5 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 9,
|
||||
"Non-compatible flatbuffers version included");
|
||||
|
||||
namespace MyGame {
|
||||
namespace Example {
|
||||
|
||||
struct NestedStruct;
|
||||
|
||||
struct ArrayStruct;
|
||||
|
||||
struct ArrayTable;
|
||||
struct ArrayTableBuilder;
|
||||
struct ArrayTableT;
|
||||
|
||||
bool operator==(const NestedStruct &lhs, const NestedStruct &rhs);
|
||||
bool operator!=(const NestedStruct &lhs, const NestedStruct &rhs);
|
||||
bool operator==(const ArrayStruct &lhs, const ArrayStruct &rhs);
|
||||
bool operator!=(const ArrayStruct &lhs, const ArrayStruct &rhs);
|
||||
bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs);
|
||||
bool operator!=(const ArrayTableT &lhs, const ArrayTableT &rhs);
|
||||
|
||||
inline const ::flatbuffers::TypeTable *NestedStructTypeTable();
|
||||
|
||||
inline const ::flatbuffers::TypeTable *ArrayStructTypeTable();
|
||||
|
||||
inline const ::flatbuffers::TypeTable *ArrayTableTypeTable();
|
||||
|
||||
enum class TestEnum : int8_t {
|
||||
A = 0,
|
||||
B = 1,
|
||||
C = 2,
|
||||
MIN = A,
|
||||
MAX = C
|
||||
};
|
||||
|
||||
inline const TestEnum (&EnumValuesTestEnum())[3] {
|
||||
static const TestEnum values[] = {
|
||||
TestEnum::A,
|
||||
TestEnum::B,
|
||||
TestEnum::C
|
||||
};
|
||||
return values;
|
||||
}
|
||||
|
||||
inline const char * const *EnumNamesTestEnum() {
|
||||
static const char * const names[4] = {
|
||||
"A",
|
||||
"B",
|
||||
"C",
|
||||
nullptr
|
||||
};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameTestEnum(TestEnum e) {
|
||||
if (::flatbuffers::IsOutRange(e, TestEnum::A, TestEnum::C)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesTestEnum()[index];
|
||||
}
|
||||
|
||||
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS {
|
||||
private:
|
||||
int32_t a_[2];
|
||||
int8_t b_;
|
||||
int8_t c_[2];
|
||||
int8_t padding0__; int32_t padding1__;
|
||||
int64_t d_[2];
|
||||
|
||||
public:
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return NestedStructTypeTable();
|
||||
}
|
||||
NestedStruct()
|
||||
: a_(),
|
||||
b_(0),
|
||||
c_(),
|
||||
padding0__(0),
|
||||
padding1__(0),
|
||||
d_() {
|
||||
(void)padding0__;
|
||||
(void)padding1__;
|
||||
}
|
||||
NestedStruct(MyGame::Example::TestEnum _b)
|
||||
: a_(),
|
||||
b_(::flatbuffers::EndianScalar(static_cast<int8_t>(_b))),
|
||||
c_(),
|
||||
padding0__(0),
|
||||
padding1__(0),
|
||||
d_() {
|
||||
(void)padding0__;
|
||||
(void)padding1__;
|
||||
}
|
||||
NestedStruct(::flatbuffers::span<const int32_t, 2> _a, MyGame::Example::TestEnum _b, ::flatbuffers::span<const MyGame::Example::TestEnum, 2> _c, ::flatbuffers::span<const int64_t, 2> _d)
|
||||
: b_(::flatbuffers::EndianScalar(static_cast<int8_t>(_b))),
|
||||
padding0__(0),
|
||||
padding1__(0) {
|
||||
::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
|
||||
::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_).CopyFromSpan(_c);
|
||||
(void)padding0__;
|
||||
(void)padding1__;
|
||||
::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
|
||||
}
|
||||
const ::flatbuffers::Array<int32_t, 2> *a() const {
|
||||
return &::flatbuffers::CastToArray(a_);
|
||||
}
|
||||
::flatbuffers::Array<int32_t, 2> *mutable_a() {
|
||||
return &::flatbuffers::CastToArray(a_);
|
||||
}
|
||||
MyGame::Example::TestEnum b() const {
|
||||
return static_cast<MyGame::Example::TestEnum>(::flatbuffers::EndianScalar(b_));
|
||||
}
|
||||
void mutate_b(MyGame::Example::TestEnum _b) {
|
||||
::flatbuffers::WriteScalar(&b_, static_cast<int8_t>(_b));
|
||||
}
|
||||
const ::flatbuffers::Array<MyGame::Example::TestEnum, 2> *c() const {
|
||||
return &::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_);
|
||||
}
|
||||
::flatbuffers::Array<MyGame::Example::TestEnum, 2> *mutable_c() {
|
||||
return &::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_);
|
||||
}
|
||||
const ::flatbuffers::Array<int64_t, 2> *d() const {
|
||||
return &::flatbuffers::CastToArray(d_);
|
||||
}
|
||||
::flatbuffers::Array<int64_t, 2> *mutable_d() {
|
||||
return &::flatbuffers::CastToArray(d_);
|
||||
}
|
||||
};
|
||||
FLATBUFFERS_STRUCT_END(NestedStruct, 32);
|
||||
|
||||
inline bool operator==(const NestedStruct &lhs, const NestedStruct &rhs) {
|
||||
return
|
||||
(*lhs.a() == *rhs.a()) &&
|
||||
(lhs.b() == rhs.b()) &&
|
||||
(*lhs.c() == *rhs.c()) &&
|
||||
(*lhs.d() == *rhs.d());
|
||||
}
|
||||
|
||||
inline bool operator!=(const NestedStruct &lhs, const NestedStruct &rhs) {
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
|
||||
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS {
|
||||
private:
|
||||
float a_;
|
||||
int32_t b_[15];
|
||||
int8_t c_;
|
||||
int8_t padding0__; int16_t padding1__; int32_t padding2__;
|
||||
MyGame::Example::NestedStruct d_[2];
|
||||
int32_t e_;
|
||||
int32_t padding3__;
|
||||
int64_t f_[2];
|
||||
|
||||
public:
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return ArrayStructTypeTable();
|
||||
}
|
||||
ArrayStruct()
|
||||
: a_(0),
|
||||
b_(),
|
||||
c_(0),
|
||||
padding0__(0),
|
||||
padding1__(0),
|
||||
padding2__(0),
|
||||
d_(),
|
||||
e_(0),
|
||||
padding3__(0),
|
||||
f_() {
|
||||
(void)padding0__;
|
||||
(void)padding1__;
|
||||
(void)padding2__;
|
||||
(void)padding3__;
|
||||
}
|
||||
ArrayStruct(float _a, int8_t _c, int32_t _e)
|
||||
: a_(::flatbuffers::EndianScalar(_a)),
|
||||
b_(),
|
||||
c_(::flatbuffers::EndianScalar(_c)),
|
||||
padding0__(0),
|
||||
padding1__(0),
|
||||
padding2__(0),
|
||||
d_(),
|
||||
e_(::flatbuffers::EndianScalar(_e)),
|
||||
padding3__(0),
|
||||
f_() {
|
||||
(void)padding0__;
|
||||
(void)padding1__;
|
||||
(void)padding2__;
|
||||
(void)padding3__;
|
||||
}
|
||||
ArrayStruct(float _a, ::flatbuffers::span<const int32_t, 15> _b, int8_t _c, ::flatbuffers::span<const MyGame::Example::NestedStruct, 2> _d, int32_t _e, ::flatbuffers::span<const int64_t, 2> _f)
|
||||
: a_(::flatbuffers::EndianScalar(_a)),
|
||||
c_(::flatbuffers::EndianScalar(_c)),
|
||||
padding0__(0),
|
||||
padding1__(0),
|
||||
padding2__(0),
|
||||
e_(::flatbuffers::EndianScalar(_e)),
|
||||
padding3__(0) {
|
||||
::flatbuffers::CastToArray(b_).CopyFromSpan(_b);
|
||||
(void)padding0__;
|
||||
(void)padding1__;
|
||||
(void)padding2__;
|
||||
::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
|
||||
(void)padding3__;
|
||||
::flatbuffers::CastToArray(f_).CopyFromSpan(_f);
|
||||
}
|
||||
float a() const {
|
||||
return ::flatbuffers::EndianScalar(a_);
|
||||
}
|
||||
void mutate_a(float _a) {
|
||||
::flatbuffers::WriteScalar(&a_, _a);
|
||||
}
|
||||
const ::flatbuffers::Array<int32_t, 15> *b() const {
|
||||
return &::flatbuffers::CastToArray(b_);
|
||||
}
|
||||
::flatbuffers::Array<int32_t, 15> *mutable_b() {
|
||||
return &::flatbuffers::CastToArray(b_);
|
||||
}
|
||||
int8_t c() const {
|
||||
return ::flatbuffers::EndianScalar(c_);
|
||||
}
|
||||
void mutate_c(int8_t _c) {
|
||||
::flatbuffers::WriteScalar(&c_, _c);
|
||||
}
|
||||
const ::flatbuffers::Array<MyGame::Example::NestedStruct, 2> *d() const {
|
||||
return &::flatbuffers::CastToArray(d_);
|
||||
}
|
||||
::flatbuffers::Array<MyGame::Example::NestedStruct, 2> *mutable_d() {
|
||||
return &::flatbuffers::CastToArray(d_);
|
||||
}
|
||||
int32_t e() const {
|
||||
return ::flatbuffers::EndianScalar(e_);
|
||||
}
|
||||
void mutate_e(int32_t _e) {
|
||||
::flatbuffers::WriteScalar(&e_, _e);
|
||||
}
|
||||
const ::flatbuffers::Array<int64_t, 2> *f() const {
|
||||
return &::flatbuffers::CastToArray(f_);
|
||||
}
|
||||
::flatbuffers::Array<int64_t, 2> *mutable_f() {
|
||||
return &::flatbuffers::CastToArray(f_);
|
||||
}
|
||||
};
|
||||
FLATBUFFERS_STRUCT_END(ArrayStruct, 160);
|
||||
|
||||
inline bool operator==(const ArrayStruct &lhs, const ArrayStruct &rhs) {
|
||||
return
|
||||
(lhs.a() == rhs.a()) &&
|
||||
(*lhs.b() == *rhs.b()) &&
|
||||
(lhs.c() == rhs.c()) &&
|
||||
(*lhs.d() == *rhs.d()) &&
|
||||
(lhs.e() == rhs.e()) &&
|
||||
(*lhs.f() == *rhs.f());
|
||||
}
|
||||
|
||||
inline bool operator!=(const ArrayStruct &lhs, const ArrayStruct &rhs) {
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
|
||||
struct ArrayTableT : public ::flatbuffers::NativeTable {
|
||||
typedef ArrayTable TableType;
|
||||
std::unique_ptr<MyGame::Example::ArrayStruct> a{};
|
||||
ArrayTableT() = default;
|
||||
ArrayTableT(const ArrayTableT &o);
|
||||
ArrayTableT(ArrayTableT&&) FLATBUFFERS_NOEXCEPT = default;
|
||||
ArrayTableT &operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT;
|
||||
};
|
||||
|
||||
struct ArrayTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef ArrayTableT NativeTableType;
|
||||
typedef ArrayTableBuilder Builder;
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return ArrayTableTypeTable();
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
VT_A = 4
|
||||
};
|
||||
const MyGame::Example::ArrayStruct *a() const {
|
||||
return GetStruct<const MyGame::Example::ArrayStruct *>(VT_A);
|
||||
}
|
||||
MyGame::Example::ArrayStruct *mutable_a() {
|
||||
return GetStruct<MyGame::Example::ArrayStruct *>(VT_A);
|
||||
}
|
||||
bool Verify(::flatbuffers::Verifier &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<MyGame::Example::ArrayStruct>(verifier, VT_A, 8) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
ArrayTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(ArrayTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<ArrayTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct ArrayTableBuilder {
|
||||
typedef ArrayTable Table;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_a(const MyGame::Example::ArrayStruct *a) {
|
||||
fbb_.AddStruct(ArrayTable::VT_A, a);
|
||||
}
|
||||
explicit ArrayTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
::flatbuffers::Offset<ArrayTable> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = ::flatbuffers::Offset<ArrayTable>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline ::flatbuffers::Offset<ArrayTable> CreateArrayTable(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
const MyGame::Example::ArrayStruct *a = nullptr) {
|
||||
ArrayTableBuilder builder_(_fbb);
|
||||
builder_.add_a(a);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
::flatbuffers::Offset<ArrayTable> CreateArrayTable(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
|
||||
inline bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs) {
|
||||
return
|
||||
((lhs.a == rhs.a) || (lhs.a && rhs.a && *lhs.a == *rhs.a));
|
||||
}
|
||||
|
||||
inline bool operator!=(const ArrayTableT &lhs, const ArrayTableT &rhs) {
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
|
||||
inline ArrayTableT::ArrayTableT(const ArrayTableT &o)
|
||||
: a((o.a) ? new MyGame::Example::ArrayStruct(*o.a) : nullptr) {
|
||||
}
|
||||
|
||||
inline ArrayTableT &ArrayTableT::operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT {
|
||||
std::swap(a, o.a);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline ArrayTableT *ArrayTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::unique_ptr<ArrayTableT>(new ArrayTableT());
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void ArrayTable::UnPackTo(ArrayTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = a(); if (_e) _o->a = std::unique_ptr<MyGame::Example::ArrayStruct>(new MyGame::Example::ArrayStruct(*_e)); }
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<ArrayTable> ArrayTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return CreateArrayTable(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<ArrayTable> CreateArrayTable(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ArrayTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _a = _o->a ? _o->a.get() : nullptr;
|
||||
return MyGame::Example::CreateArrayTable(
|
||||
_fbb,
|
||||
_a);
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *TestEnumTypeTable() {
|
||||
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[] = {
|
||||
MyGame::Example::TestEnumTypeTable
|
||||
};
|
||||
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 *NestedStructTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_INT, 1, -1 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 1, 0 },
|
||||
{ ::flatbuffers::ET_LONG, 1, -1 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
MyGame::Example::TestEnumTypeTable
|
||||
};
|
||||
static const int16_t array_sizes[] = { 2, 2, 2, };
|
||||
static const int64_t values[] = { 0, 8, 9, 16, 32 };
|
||||
static const char * const names[] = {
|
||||
"a",
|
||||
"b",
|
||||
"c",
|
||||
"d"
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_STRUCT, 4, type_codes, type_refs, array_sizes, values, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *ArrayStructTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_FLOAT, 0, -1 },
|
||||
{ ::flatbuffers::ET_INT, 1, -1 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, -1 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 1, 0 },
|
||||
{ ::flatbuffers::ET_INT, 0, -1 },
|
||||
{ ::flatbuffers::ET_LONG, 1, -1 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
MyGame::Example::NestedStructTypeTable
|
||||
};
|
||||
static const int16_t array_sizes[] = { 15, 2, 2, };
|
||||
static const int64_t values[] = { 0, 4, 64, 72, 136, 144, 160 };
|
||||
static const char * const names[] = {
|
||||
"a",
|
||||
"b",
|
||||
"c",
|
||||
"d",
|
||||
"e",
|
||||
"f"
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_STRUCT, 6, type_codes, type_refs, array_sizes, values, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *ArrayTableTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 0 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
MyGame::Example::ArrayStructTypeTable
|
||||
};
|
||||
static const char * const names[] = {
|
||||
"a"
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const MyGame::Example::ArrayTable *GetArrayTable(const void *buf) {
|
||||
return ::flatbuffers::GetRoot<MyGame::Example::ArrayTable>(buf);
|
||||
}
|
||||
|
||||
inline const MyGame::Example::ArrayTable *GetSizePrefixedArrayTable(const void *buf) {
|
||||
return ::flatbuffers::GetSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
|
||||
}
|
||||
|
||||
inline ArrayTable *GetMutableArrayTable(void *buf) {
|
||||
return ::flatbuffers::GetMutableRoot<ArrayTable>(buf);
|
||||
}
|
||||
|
||||
inline MyGame::Example::ArrayTable *GetMutableSizePrefixedArrayTable(void *buf) {
|
||||
return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
|
||||
}
|
||||
|
||||
inline const char *ArrayTableIdentifier() {
|
||||
return "ARRT";
|
||||
}
|
||||
|
||||
inline bool ArrayTableBufferHasIdentifier(const void *buf) {
|
||||
return ::flatbuffers::BufferHasIdentifier(
|
||||
buf, ArrayTableIdentifier());
|
||||
}
|
||||
|
||||
inline bool SizePrefixedArrayTableBufferHasIdentifier(const void *buf) {
|
||||
return ::flatbuffers::BufferHasIdentifier(
|
||||
buf, ArrayTableIdentifier(), true);
|
||||
}
|
||||
|
||||
inline bool VerifyArrayTableBuffer(
|
||||
::flatbuffers::Verifier &verifier) {
|
||||
return verifier.VerifyBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
|
||||
}
|
||||
|
||||
inline bool VerifySizePrefixedArrayTableBuffer(
|
||||
::flatbuffers::Verifier &verifier) {
|
||||
return verifier.VerifySizePrefixedBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
|
||||
}
|
||||
|
||||
inline const char *ArrayTableExtension() {
|
||||
return "mon";
|
||||
}
|
||||
|
||||
inline void FinishArrayTableBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<MyGame::Example::ArrayTable> root) {
|
||||
fbb.Finish(root, ArrayTableIdentifier());
|
||||
}
|
||||
|
||||
inline void FinishSizePrefixedArrayTableBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<MyGame::Example::ArrayTable> root) {
|
||||
fbb.FinishSizePrefixed(root, ArrayTableIdentifier());
|
||||
}
|
||||
|
||||
inline std::unique_ptr<MyGame::Example::ArrayTableT> UnPackArrayTable(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return std::unique_ptr<MyGame::Example::ArrayTableT>(GetArrayTable(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
inline std::unique_ptr<MyGame::Example::ArrayTableT> UnPackSizePrefixedArrayTable(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return std::unique_ptr<MyGame::Example::ArrayTableT>(GetSizePrefixedArrayTable(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
} // namespace Example
|
||||
} // namespace MyGame
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_ARRAYSTEST_MYGAME_EXAMPLE_H_
|
||||
Reference in New Issue
Block a user