BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-10 23:17:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

emit global scoped ::flatbuffers in c++ (#7764)

Browse Source
This commit is contained in:
Derek Bailey
2023-01-07 12:17:07 -08:00
committed by GitHub
parent c95cf661af
commit 75af533e95
22 changed files with 5236 additions and 5235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
tests/alignment_test_generated.h
View File

@@ -34,13 +34,13 @@ bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs);
bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable();
inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable();
inline const flatbuffers::TypeTable *BadAlignmentLargeTypeTable();
inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable();
inline const flatbuffers::TypeTable *OuterLargeTypeTable();
inline const ::flatbuffers::TypeTable *OuterLargeTypeTable();
inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable();
inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable();
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS {
private:
@@ -49,7 +49,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS
uint32_t var_2_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BadAlignmentSmallTypeTable();
}
BadAlignmentSmall()
@@ -58,27 +58,27 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS
var_2_(0) {
}
BadAlignmentSmall(uint32_t _var_0, uint32_t _var_1, uint32_t _var_2)
: var_0_(flatbuffers::EndianScalar(_var_0)),
var_1_(flatbuffers::EndianScalar(_var_1)),
var_2_(flatbuffers::EndianScalar(_var_2)) {
: var_0_(::flatbuffers::EndianScalar(_var_0)),
var_1_(::flatbuffers::EndianScalar(_var_1)),
var_2_(::flatbuffers::EndianScalar(_var_2)) {
}
uint32_t var_0() const {
return flatbuffers::EndianScalar(var_0_);
return ::flatbuffers::EndianScalar(var_0_);
}
void mutate_var_0(uint32_t _var_0) {
flatbuffers::WriteScalar(&var_0_, _var_0);
::flatbuffers::WriteScalar(&var_0_, _var_0);
}
uint32_t var_1() const {
return flatbuffers::EndianScalar(var_1_);
return ::flatbuffers::EndianScalar(var_1_);
}
void mutate_var_1(uint32_t _var_1) {
flatbuffers::WriteScalar(&var_1_, _var_1);
::flatbuffers::WriteScalar(&var_1_, _var_1);
}
uint32_t var_2() const {
return flatbuffers::EndianScalar(var_2_);
return ::flatbuffers::EndianScalar(var_2_);
}
void mutate_var_2(uint32_t _var_2) {
flatbuffers::WriteScalar(&var_2_, _var_2);
::flatbuffers::WriteScalar(&var_2_, _var_2);
}
};
FLATBUFFERS_STRUCT_END(BadAlignmentSmall, 12);
@@ -100,20 +100,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) BadAlignmentLarge FLATBUFFERS_FINAL_CLASS
uint64_t var_0_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BadAlignmentLargeTypeTable();
}
BadAlignmentLarge()
: var_0_(0) {
}
BadAlignmentLarge(uint64_t _var_0)
: var_0_(flatbuffers::EndianScalar(_var_0)) {
: var_0_(::flatbuffers::EndianScalar(_var_0)) {
}
uint64_t var_0() const {
return flatbuffers::EndianScalar(var_0_);
return ::flatbuffers::EndianScalar(var_0_);
}
void mutate_var_0(uint64_t _var_0) {
flatbuffers::WriteScalar(&var_0_, _var_0);
::flatbuffers::WriteScalar(&var_0_, _var_0);
}
};
FLATBUFFERS_STRUCT_END(BadAlignmentLarge, 8);
@@ -128,7 +128,7 @@ inline bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rh
}
struct OuterLargeT : public flatbuffers::NativeTable {
struct OuterLargeT : public ::flatbuffers::NativeTable {
typedef OuterLarge TableType;
flatbuffers::unique_ptr<BadAlignmentLarge> large{};
OuterLargeT() = default;
@@ -137,10 +137,10 @@ struct OuterLargeT : public flatbuffers::NativeTable {
OuterLargeT &operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT;
};
struct OuterLarge FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct OuterLarge FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef OuterLargeT NativeTableType;
typedef OuterLargeBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return OuterLargeTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -152,45 +152,45 @@ struct OuterLarge FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
BadAlignmentLarge *mutable_large() {
return GetStruct<BadAlignmentLarge *>(VT_LARGE);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<BadAlignmentLarge>(verifier, VT_LARGE, 8) &&
verifier.EndTable();
}
OuterLargeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(OuterLargeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<OuterLarge> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
OuterLargeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(OuterLargeT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<OuterLarge> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct OuterLargeBuilder {
typedef OuterLarge Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_large(const BadAlignmentLarge *large) {
fbb_.AddStruct(OuterLarge::VT_LARGE, large);
}
explicit OuterLargeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit OuterLargeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<OuterLarge> Finish() {
::flatbuffers::Offset<OuterLarge> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<OuterLarge>(end);
auto o = ::flatbuffers::Offset<OuterLarge>(end);
return o;
}
};
inline flatbuffers::Offset<OuterLarge> CreateOuterLarge(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
::flatbuffers::FlatBufferBuilder &_fbb,
const BadAlignmentLarge *large = nullptr) {
OuterLargeBuilder builder_(_fbb);
builder_.add_large(large);
return builder_.Finish();
}
flatbuffers::Offset<OuterLarge> CreateOuterLarge(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct BadAlignmentRootT : public flatbuffers::NativeTable {
struct BadAlignmentRootT : public ::flatbuffers::NativeTable {
typedef BadAlignmentRoot TableType;
flatbuffers::unique_ptr<OuterLargeT> large{};
std::vector<BadAlignmentSmall> small{};
@@ -200,10 +200,10 @@ struct BadAlignmentRootT : public flatbuffers::NativeTable {
BadAlignmentRootT &operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT;
};
struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BadAlignmentRootT NativeTableType;
typedef BadAlignmentRootBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BadAlignmentRootTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -216,13 +216,13 @@ struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
OuterLarge *mutable_large() {
return GetPointer<OuterLarge *>(VT_LARGE);
}
const flatbuffers::Vector<const BadAlignmentSmall *> *small() const {
return GetPointer<const flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
const ::flatbuffers::Vector<const BadAlignmentSmall *> *small() const {
return GetPointer<const ::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
}
flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small() {
return GetPointer<flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
::flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small() {
return GetPointer<::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_LARGE) &&
verifier.VerifyTable(large()) &&
@@ -230,45 +230,45 @@ struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(small()) &&
verifier.EndTable();
}
BadAlignmentRootT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(BadAlignmentRootT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<BadAlignmentRoot> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
BadAlignmentRootT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(BadAlignmentRootT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<BadAlignmentRoot> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct BadAlignmentRootBuilder {
typedef BadAlignmentRoot Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_large(flatbuffers::Offset<OuterLarge> large) {
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_large(::flatbuffers::Offset<OuterLarge> large) {
fbb_.AddOffset(BadAlignmentRoot::VT_LARGE, large);
}
void add_small(flatbuffers::Offset<flatbuffers::Vector<const BadAlignmentSmall *>> small) {
void add_small(::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small) {
fbb_.AddOffset(BadAlignmentRoot::VT_SMALL, small);
}
explicit BadAlignmentRootBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit BadAlignmentRootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<BadAlignmentRoot> Finish() {
::flatbuffers::Offset<BadAlignmentRoot> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<BadAlignmentRoot>(end);
auto o = ::flatbuffers::Offset<BadAlignmentRoot>(end);
return o;
}
};
inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<OuterLarge> large = 0,
flatbuffers::Offset<flatbuffers::Vector<const BadAlignmentSmall *>> small = 0) {
inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<OuterLarge> large = 0,
::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small = 0) {
BadAlignmentRootBuilder builder_(_fbb);
builder_.add_small(small);
builder_.add_large(large);
return builder_.Finish();
}
inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<OuterLarge> large = 0,
inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<OuterLarge> large = 0,
const std::vector<BadAlignmentSmall> *small = nullptr) {
auto small__ = small ? _fbb.CreateVectorOfStructs<BadAlignmentSmall>(*small) : 0;
return CreateBadAlignmentRoot(
@@ -277,7 +277,7 @@ inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
small__);
}
flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs) {
@@ -299,26 +299,26 @@ inline OuterLargeT &OuterLargeT::operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT {
return *this;
}
inline OuterLargeT *OuterLarge::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline OuterLargeT *OuterLarge::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<OuterLargeT>(new OuterLargeT());
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void OuterLarge::UnPackTo(OuterLargeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void OuterLarge::UnPackTo(OuterLargeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = large(); if (_e) _o->large = flatbuffers::unique_ptr<BadAlignmentLarge>(new BadAlignmentLarge(*_e)); }
}
inline flatbuffers::Offset<OuterLarge> OuterLarge::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<OuterLarge> OuterLarge::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateOuterLarge(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<OuterLarge> CreateOuterLarge(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OuterLargeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const OuterLargeT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _large = _o->large ? _o->large.get() : nullptr;
return CreateOuterLarge(
_fbb,
@@ -348,27 +348,27 @@ inline BadAlignmentRootT &BadAlignmentRootT::operator=(BadAlignmentRootT o) FLAT
return *this;
}
inline BadAlignmentRootT *BadAlignmentRoot::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline BadAlignmentRootT *BadAlignmentRoot::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<BadAlignmentRootT>(new BadAlignmentRootT());
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = large(); if (_e) { if(_o->large) { _e->UnPackTo(_o->large.get(), _resolver); } else { _o->large = flatbuffers::unique_ptr<OuterLargeT>(_e->UnPack(_resolver)); } } else if (_o->large) { _o->large.reset(); } }
{ auto _e = small(); if (_e) { _o->small.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->small[_i] = *_e->Get(_i); } } else { _o->small.resize(0); } }
{ auto _e = small(); if (_e) { _o->small.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->small[_i] = *_e->Get(_i); } } else { _o->small.resize(0); } }
}
inline flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBadAlignmentRoot(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BadAlignmentRootT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BadAlignmentRootT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _large = _o->large ? CreateOuterLarge(_fbb, _o->large.get(), _rehasher) : 0;
auto _small = _o->small.size() ? _fbb.CreateVectorOfStructs(_o->small) : 0;
return CreateBadAlignmentRoot(
@@ -377,11 +377,11 @@ inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers:
_small);
}
inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UINT, 0, -1 },
{ flatbuffers::ET_UINT, 0, -1 },
{ flatbuffers::ET_UINT, 0, -1 }
inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_UINT, 0, -1 },
{ ::flatbuffers::ET_UINT, 0, -1 },
{ ::flatbuffers::ET_UINT, 0, -1 }
};
static const int64_t values[] = { 0, 4, 8, 12 };
static const char * const names[] = {
@@ -389,48 +389,48 @@ inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable() {
"var_1",
"var_2"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *BadAlignmentLargeTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_ULONG, 0, -1 }
inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_ULONG, 0, -1 }
};
static const int64_t values[] = { 0, 8 };
static const char * const names[] = {
"var_0"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *OuterLargeTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 }
inline const ::flatbuffers::TypeTable *OuterLargeTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, 0 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
BadAlignmentLargeTypeTable
};
static const char * const names[] = {
"large"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 1 }
inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 1, 1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
OuterLargeTypeTable,
BadAlignmentSmallTypeTable
};
@@ -438,59 +438,59 @@ inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable() {
"large",
"small"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const BadAlignmentRoot *GetBadAlignmentRoot(const void *buf) {
return flatbuffers::GetRoot<BadAlignmentRoot>(buf);
return ::flatbuffers::GetRoot<BadAlignmentRoot>(buf);
}
inline const BadAlignmentRoot *GetSizePrefixedBadAlignmentRoot(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<BadAlignmentRoot>(buf);
return ::flatbuffers::GetSizePrefixedRoot<BadAlignmentRoot>(buf);
}
inline BadAlignmentRoot *GetMutableBadAlignmentRoot(void *buf) {
return flatbuffers::GetMutableRoot<BadAlignmentRoot>(buf);
return ::flatbuffers::GetMutableRoot<BadAlignmentRoot>(buf);
}
inline BadAlignmentRoot *GetMutableSizePrefixedBadAlignmentRoot(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<BadAlignmentRoot>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<BadAlignmentRoot>(buf);
}
inline bool VerifyBadAlignmentRootBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<BadAlignmentRoot>(nullptr);
}
inline bool VerifySizePrefixedBadAlignmentRootBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<BadAlignmentRoot>(nullptr);
}
inline void FinishBadAlignmentRootBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<BadAlignmentRoot> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<BadAlignmentRoot> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedBadAlignmentRootBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<BadAlignmentRoot> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<BadAlignmentRoot> root) {
fbb.FinishSizePrefixed(root);
}
inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackBadAlignmentRoot(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<BadAlignmentRootT>(GetBadAlignmentRoot(buf)->UnPack(res));
}
inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackSizePrefixedBadAlignmentRoot(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<BadAlignmentRootT>(GetSizePrefixedBadAlignmentRoot(buf)->UnPack(res));
}

244
tests/arrays_test_generated.h
View File

@@ -31,11 +31,11 @@ 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 *NestedStructTypeTable();
inline const flatbuffers::TypeTable *ArrayStructTypeTable();
inline const ::flatbuffers::TypeTable *ArrayStructTypeTable();
inline const flatbuffers::TypeTable *ArrayTableTypeTable();
inline const ::flatbuffers::TypeTable *ArrayTableTypeTable();
enum class TestEnum : int8_t {
A = 0,
@@ -65,7 +65,7 @@ inline const char * const *EnumNamesTestEnum() {
}
inline const char *EnumNameTestEnum(TestEnum e) {
if (flatbuffers::IsOutRange(e, TestEnum::A, TestEnum::C)) return "";
if (::flatbuffers::IsOutRange(e, TestEnum::A, TestEnum::C)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesTestEnum()[index];
}
@@ -79,7 +79,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS {
int64_t d_[2];
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return NestedStructTypeTable();
}
NestedStruct()
@@ -94,7 +94,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS {
}
NestedStruct(MyGame::Example::TestEnum _b)
: a_(),
b_(flatbuffers::EndianScalar(static_cast<int8_t>(_b))),
b_(::flatbuffers::EndianScalar(static_cast<int8_t>(_b))),
c_(),
padding0__(0),
padding1__(0),
@@ -102,39 +102,39 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS {
(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))),
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);
::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_).CopyFromSpan(_c);
(void)padding0__;
(void)padding1__;
flatbuffers::CastToArray(d_).CopyFromSpan(_d);
::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
}
const flatbuffers::Array<int32_t, 2> *a() const {
return &flatbuffers::CastToArray(a_);
const ::flatbuffers::Array<int32_t, 2> *a() const {
return &::flatbuffers::CastToArray(a_);
}
flatbuffers::Array<int32_t, 2> *mutable_a() {
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_));
return static_cast<MyGame::Example::TestEnum>(::flatbuffers::EndianScalar(b_));
}
void mutate_b(MyGame::Example::TestEnum _b) {
flatbuffers::WriteScalar(&b_, static_cast<int8_t>(_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_);
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_);
::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_);
const ::flatbuffers::Array<int64_t, 2> *d() const {
return &::flatbuffers::CastToArray(d_);
}
flatbuffers::Array<int64_t, 2> *mutable_d() {
return &flatbuffers::CastToArray(d_);
::flatbuffers::Array<int64_t, 2> *mutable_d() {
return &::flatbuffers::CastToArray(d_);
}
};
FLATBUFFERS_STRUCT_END(NestedStruct, 32);
@@ -164,7 +164,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS {
int64_t f_[2];
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ArrayStructTypeTable();
}
ArrayStruct()
@@ -184,14 +184,14 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS {
(void)padding3__;
}
ArrayStruct(float _a, int8_t _c, int32_t _e)
: a_(flatbuffers::EndianScalar(_a)),
: a_(::flatbuffers::EndianScalar(_a)),
b_(),
c_(flatbuffers::EndianScalar(_c)),
c_(::flatbuffers::EndianScalar(_c)),
padding0__(0),
padding1__(0),
padding2__(0),
d_(),
e_(flatbuffers::EndianScalar(_e)),
e_(::flatbuffers::EndianScalar(_e)),
padding3__(0),
f_() {
(void)padding0__;
@@ -199,57 +199,57 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS {
(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)),
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)),
e_(::flatbuffers::EndianScalar(_e)),
padding3__(0) {
flatbuffers::CastToArray(b_).CopyFromSpan(_b);
::flatbuffers::CastToArray(b_).CopyFromSpan(_b);
(void)padding0__;
(void)padding1__;
(void)padding2__;
flatbuffers::CastToArray(d_).CopyFromSpan(_d);
::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
(void)padding3__;
flatbuffers::CastToArray(f_).CopyFromSpan(_f);
::flatbuffers::CastToArray(f_).CopyFromSpan(_f);
}
float a() const {
return flatbuffers::EndianScalar(a_);
return ::flatbuffers::EndianScalar(a_);
}
void mutate_a(float _a) {
flatbuffers::WriteScalar(&a_, _a);
::flatbuffers::WriteScalar(&a_, _a);
}
const flatbuffers::Array<int32_t, 15> *b() const {
return &flatbuffers::CastToArray(b_);
const ::flatbuffers::Array<int32_t, 15> *b() const {
return &::flatbuffers::CastToArray(b_);
}
flatbuffers::Array<int32_t, 15> *mutable_b() {
return &flatbuffers::CastToArray(b_);
::flatbuffers::Array<int32_t, 15> *mutable_b() {
return &::flatbuffers::CastToArray(b_);
}
int8_t c() const {
return flatbuffers::EndianScalar(c_);
return ::flatbuffers::EndianScalar(c_);
}
void mutate_c(int8_t _c) {
flatbuffers::WriteScalar(&c_, _c);
::flatbuffers::WriteScalar(&c_, _c);
}
const flatbuffers::Array<MyGame::Example::NestedStruct, 2> *d() const {
return &flatbuffers::CastToArray(d_);
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_);
::flatbuffers::Array<MyGame::Example::NestedStruct, 2> *mutable_d() {
return &::flatbuffers::CastToArray(d_);
}
int32_t e() const {
return flatbuffers::EndianScalar(e_);
return ::flatbuffers::EndianScalar(e_);
}
void mutate_e(int32_t _e) {
flatbuffers::WriteScalar(&e_, _e);
::flatbuffers::WriteScalar(&e_, _e);
}
const flatbuffers::Array<int64_t, 2> *f() const {
return &flatbuffers::CastToArray(f_);
const ::flatbuffers::Array<int64_t, 2> *f() const {
return &::flatbuffers::CastToArray(f_);
}
flatbuffers::Array<int64_t, 2> *mutable_f() {
return &flatbuffers::CastToArray(f_);
::flatbuffers::Array<int64_t, 2> *mutable_f() {
return &::flatbuffers::CastToArray(f_);
}
};
FLATBUFFERS_STRUCT_END(ArrayStruct, 160);
@@ -269,7 +269,7 @@ inline bool operator!=(const ArrayStruct &lhs, const ArrayStruct &rhs) {
}
struct ArrayTableT : public flatbuffers::NativeTable {
struct ArrayTableT : public ::flatbuffers::NativeTable {
typedef ArrayTable TableType;
flatbuffers::unique_ptr<MyGame::Example::ArrayStruct> a{};
ArrayTableT() = default;
@@ -278,10 +278,10 @@ struct ArrayTableT : public flatbuffers::NativeTable {
ArrayTableT &operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT;
};
struct ArrayTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ArrayTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ArrayTableT NativeTableType;
typedef ArrayTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ArrayTableTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -293,43 +293,43 @@ struct ArrayTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
MyGame::Example::ArrayStruct *mutable_a() {
return GetStruct<MyGame::Example::ArrayStruct *>(VT_A);
}
bool Verify(flatbuffers::Verifier &verifier) const {
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);
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_;
::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)
explicit ArrayTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<ArrayTable> Finish() {
::flatbuffers::Offset<ArrayTable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ArrayTable>(end);
auto o = ::flatbuffers::Offset<ArrayTable>(end);
return o;
}
};
inline flatbuffers::Offset<ArrayTable> CreateArrayTable(
flatbuffers::FlatBufferBuilder &_fbb,
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);
::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) {
@@ -351,39 +351,39 @@ inline ArrayTableT &ArrayTableT::operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT {
return *this;
}
inline ArrayTableT *ArrayTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
inline void ArrayTable::UnPackTo(ArrayTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = a(); if (_e) _o->a = flatbuffers::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) {
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) {
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;
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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::TestEnumTypeTable
};
static const char * const names[] = {
@@ -391,20 +391,20 @@ inline const flatbuffers::TypeTable *TestEnumTypeTable() {
"B",
"C"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::TestEnumTypeTable
};
static const int16_t array_sizes[] = { 2, 2, 2, };
@@ -415,22 +415,22 @@ inline const flatbuffers::TypeTable *NestedStructTypeTable() {
"c",
"d"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 4, type_codes, type_refs, array_sizes, values, names
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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::NestedStructTypeTable
};
static const int16_t array_sizes[] = { 15, 2, 2, };
@@ -443,42 +443,42 @@ inline const flatbuffers::TypeTable *ArrayStructTypeTable() {
"e",
"f"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 6, type_codes, type_refs, array_sizes, values, names
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 }
inline const ::flatbuffers::TypeTable *ArrayTableTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, 0 }
};
static const flatbuffers::TypeFunction type_refs[] = {
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
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);
return ::flatbuffers::GetRoot<MyGame::Example::ArrayTable>(buf);
}
inline const MyGame::Example::ArrayTable *GetSizePrefixedArrayTable(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
return ::flatbuffers::GetSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
}
inline ArrayTable *GetMutableArrayTable(void *buf) {
return flatbuffers::GetMutableRoot<ArrayTable>(buf);
return ::flatbuffers::GetMutableRoot<ArrayTable>(buf);
}
inline MyGame::Example::ArrayTable *GetMutableSizePrefixedArrayTable(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
}
inline const char *ArrayTableIdentifier() {
@@ -486,22 +486,22 @@ inline const char *ArrayTableIdentifier() {
}
inline bool ArrayTableBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, ArrayTableIdentifier());
}
inline bool SizePrefixedArrayTableBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, ArrayTableIdentifier(), true);
}
inline bool VerifyArrayTableBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
}
inline bool VerifySizePrefixedArrayTableBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
}
@@ -510,26 +510,26 @@ inline const char *ArrayTableExtension() {
}
inline void FinishArrayTableBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::Example::ArrayTable> root) {
::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) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<MyGame::Example::ArrayTable> root) {
fbb.FinishSizePrefixed(root, ArrayTableIdentifier());
}
inline flatbuffers::unique_ptr<MyGame::Example::ArrayTableT> UnPackArrayTable(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::Example::ArrayTableT>(GetArrayTable(buf)->UnPack(res));
}
inline flatbuffers::unique_ptr<MyGame::Example::ArrayTableT> UnPackSizePrefixedArrayTable(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::Example::ArrayTableT>(GetSizePrefixedArrayTable(buf)->UnPack(res));
}

1258
tests/cpp17/generated_cpp17/monster_test_generated.h
View File

File diff suppressed because it is too large Load Diff

242
tests/cpp17/generated_cpp17/optional_scalars_generated.h
View File

@@ -19,7 +19,7 @@ struct ScalarStuff;
struct ScalarStuffBuilder;
struct ScalarStuffT;
inline const flatbuffers::TypeTable *ScalarStuffTypeTable();
inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable();
enum class OptionalByte : int8_t {
None = 0,
@@ -49,56 +49,56 @@ inline const char * const *EnumNamesOptionalByte() {
}
inline const char *EnumNameOptionalByte(OptionalByte e) {
if (flatbuffers::IsOutRange(e, OptionalByte::None, OptionalByte::Two)) return "";
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 {
struct ScalarStuffT : public ::flatbuffers::NativeTable {
typedef ScalarStuff TableType;
int8_t just_i8 = 0;
flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt;
::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;
::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;
::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;
::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;
::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;
::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;
::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;
::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;
::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt;
float default_f32 = 42.0f;
double just_f64 = 0.0;
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt;
::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt;
double default_f64 = 42.0;
bool just_bool = false;
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt;
::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;
::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 {
struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ScalarStuffT NativeTableType;
typedef ScalarStuffBuilder Builder;
struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ScalarStuffTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -145,7 +145,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int8_t> maybe_i8() const {
return GetOptional<int8_t, int8_t>(VT_MAYBE_I8);
}
bool mutate_maybe_i8(int8_t _maybe_i8) {
@@ -163,7 +163,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint8_t> maybe_u8() const {
return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8);
}
bool mutate_maybe_u8(uint8_t _maybe_u8) {
@@ -181,7 +181,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int16_t> maybe_i16() const {
return GetOptional<int16_t, int16_t>(VT_MAYBE_I16);
}
bool mutate_maybe_i16(int16_t _maybe_i16) {
@@ -199,7 +199,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint16_t> maybe_u16() const {
return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16);
}
bool mutate_maybe_u16(uint16_t _maybe_u16) {
@@ -217,7 +217,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int32_t> maybe_i32() const {
return GetOptional<int32_t, int32_t>(VT_MAYBE_I32);
}
bool mutate_maybe_i32(int32_t _maybe_i32) {
@@ -235,7 +235,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint32_t> maybe_u32() const {
return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32);
}
bool mutate_maybe_u32(uint32_t _maybe_u32) {
@@ -253,7 +253,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int64_t> maybe_i64() const {
return GetOptional<int64_t, int64_t>(VT_MAYBE_I64);
}
bool mutate_maybe_i64(int64_t _maybe_i64) {
@@ -271,7 +271,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint64_t> maybe_u64() const {
return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64);
}
bool mutate_maybe_u64(uint64_t _maybe_u64) {
@@ -289,7 +289,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<float> maybe_f32() const {
return GetOptional<float, float>(VT_MAYBE_F32);
}
bool mutate_maybe_f32(float _maybe_f32) {
@@ -307,7 +307,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<double> maybe_f64() const {
return GetOptional<double, double>(VT_MAYBE_F64);
}
bool mutate_maybe_f64(double _maybe_f64) {
@@ -325,7 +325,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<bool> maybe_bool() const {
return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL);
}
bool mutate_maybe_bool(bool _maybe_bool) {
@@ -343,7 +343,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::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) {
@@ -395,7 +395,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
else if constexpr (Index == 35) return default_enum();
else static_assert(Index != Index, "Invalid Field Index");
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@@ -435,15 +435,15 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
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_;
::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);
}
@@ -552,54 +552,54 @@ struct ScalarStuffBuilder {
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)
explicit ScalarStuffBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<ScalarStuff> Finish() {
::flatbuffers::Offset<ScalarStuff> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ScalarStuff>(end);
auto o = ::flatbuffers::Offset<ScalarStuff>(end);
return o;
}
};
inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
::flatbuffers::FlatBufferBuilder &_fbb,
int8_t just_i8 = 0,
flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt,
::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,
::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,
::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,
::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,
::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,
::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,
::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,
::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,
::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt,
float default_f32 = 42.0f,
double just_f64 = 0.0,
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt,
::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt,
double default_f64 = 42.0,
bool just_bool = false,
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt,
::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,
::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);
@@ -689,15 +689,15 @@ struct ScalarStuff::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>());
};
flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::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 {
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 {
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; }
@@ -738,14 +738,14 @@ inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_
{ 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) {
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) {
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;
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;
@@ -822,13 +822,13 @@ inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBuffe
_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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
optional_scalars::OptionalByteTypeTable
};
static const char * const names[] = {
@@ -836,52 +836,52 @@ inline const flatbuffers::TypeTable *OptionalByteTypeTable() {
"One",
"Two"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
optional_scalars::OptionalByteTypeTable
};
static const char * const names[] = {
@@ -922,26 +922,26 @@ inline const flatbuffers::TypeTable *ScalarStuffTypeTable() {
"maybe_enum",
"default_enum"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names
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);
return ::flatbuffers::GetRoot<optional_scalars::ScalarStuff>(buf);
}
inline const optional_scalars::ScalarStuff *GetSizePrefixedScalarStuff(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
return ::flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
}
inline ScalarStuff *GetMutableScalarStuff(void *buf) {
return flatbuffers::GetMutableRoot<ScalarStuff>(buf);
return ::flatbuffers::GetMutableRoot<ScalarStuff>(buf);
}
inline optional_scalars::ScalarStuff *GetMutableSizePrefixedScalarStuff(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
}
inline const char *ScalarStuffIdentifier() {
@@ -949,22 +949,22 @@ inline const char *ScalarStuffIdentifier() {
}
inline bool ScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier());
}
inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier(), true);
}
inline bool VerifyScalarStuffBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
}
inline bool VerifySizePrefixedScalarStuffBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
}
@@ -973,26 +973,26 @@ inline const char *ScalarStuffExtension() {
}
inline void FinishScalarStuffBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
::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) {
::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) {
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) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res));
}

392
tests/cpp17/generated_cpp17/union_vector_generated.h
View File

@@ -31,17 +31,17 @@ struct Movie;
struct MovieBuilder;
struct MovieT;
inline const flatbuffers::TypeTable *AttackerTypeTable();
inline const ::flatbuffers::TypeTable *AttackerTypeTable();
inline const flatbuffers::TypeTable *RapunzelTypeTable();
inline const ::flatbuffers::TypeTable *RapunzelTypeTable();
inline const flatbuffers::TypeTable *BookReaderTypeTable();
inline const ::flatbuffers::TypeTable *BookReaderTypeTable();
inline const flatbuffers::TypeTable *FallingTubTypeTable();
inline const ::flatbuffers::TypeTable *FallingTubTypeTable();
inline const flatbuffers::TypeTable *HandFanTypeTable();
inline const ::flatbuffers::TypeTable *HandFanTypeTable();
inline const flatbuffers::TypeTable *MovieTypeTable();
inline const ::flatbuffers::TypeTable *MovieTypeTable();
enum class Character : uint8_t {
NONE = 0,
@@ -83,7 +83,7 @@ inline const char * const *EnumNamesCharacter() {
}
inline const char *EnumNameCharacter(Character e) {
if (flatbuffers::IsOutRange(e, Character::NONE, Character::Unused)) return "";
if (::flatbuffers::IsOutRange(e, Character::NONE, Character::Unused)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesCharacter()[index];
}
@@ -105,8 +105,8 @@ struct CharacterUnion {
void Reset();
static void *UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
static void *UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver);
::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
AttackerT *AsMuLan() {
return type == Character::MuLan ?
@@ -158,8 +158,8 @@ struct CharacterUnion {
}
};
bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type);
bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Character> *types);
bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
enum class Gadget : uint8_t {
NONE = 0,
@@ -189,7 +189,7 @@ inline const char * const *EnumNamesGadget() {
}
inline const char *EnumNameGadget(Gadget e) {
if (flatbuffers::IsOutRange(e, Gadget::NONE, Gadget::HandFan)) return "";
if (::flatbuffers::IsOutRange(e, Gadget::NONE, Gadget::HandFan)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesGadget()[index];
}
@@ -245,8 +245,8 @@ struct GadgetUnion {
}
}
static void *UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
static void *UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver);
::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
FallingTub *AsFallingTub() {
return type == Gadget::FallingTub ?
@@ -266,8 +266,8 @@ struct GadgetUnion {
}
};
bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type);
bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Gadget> *types);
bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
private:
@@ -275,20 +275,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
public:
struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return RapunzelTypeTable();
}
Rapunzel()
: hair_length_(0) {
}
Rapunzel(int32_t _hair_length)
: hair_length_(flatbuffers::EndianScalar(_hair_length)) {
: hair_length_(::flatbuffers::EndianScalar(_hair_length)) {
}
int32_t hair_length() const {
return flatbuffers::EndianScalar(hair_length_);
return ::flatbuffers::EndianScalar(hair_length_);
}
void mutate_hair_length(int32_t _hair_length) {
flatbuffers::WriteScalar(&hair_length_, _hair_length);
::flatbuffers::WriteScalar(&hair_length_, _hair_length);
}
template<size_t Index>
auto get_field() const {
@@ -316,20 +316,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
public:
struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BookReaderTypeTable();
}
BookReader()
: books_read_(0) {
}
BookReader(int32_t _books_read)
: books_read_(flatbuffers::EndianScalar(_books_read)) {
: books_read_(::flatbuffers::EndianScalar(_books_read)) {
}
int32_t books_read() const {
return flatbuffers::EndianScalar(books_read_);
return ::flatbuffers::EndianScalar(books_read_);
}
void mutate_books_read(int32_t _books_read) {
flatbuffers::WriteScalar(&books_read_, _books_read);
::flatbuffers::WriteScalar(&books_read_, _books_read);
}
template<size_t Index>
auto get_field() const {
@@ -357,20 +357,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS {
public:
struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return FallingTubTypeTable();
}
FallingTub()
: weight_(0) {
}
FallingTub(int32_t _weight)
: weight_(flatbuffers::EndianScalar(_weight)) {
: weight_(::flatbuffers::EndianScalar(_weight)) {
}
int32_t weight() const {
return flatbuffers::EndianScalar(weight_);
return ::flatbuffers::EndianScalar(weight_);
}
void mutate_weight(int32_t _weight) {
flatbuffers::WriteScalar(&weight_, _weight);
::flatbuffers::WriteScalar(&weight_, _weight);
}
template<size_t Index>
auto get_field() const {
@@ -392,16 +392,16 @@ struct FallingTub::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>());
};
struct AttackerT : public flatbuffers::NativeTable {
struct AttackerT : public ::flatbuffers::NativeTable {
typedef Attacker TableType;
int32_t sword_attack_damage = 0;
};
struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef AttackerT NativeTableType;
typedef AttackerBuilder Builder;
struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return AttackerTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -418,36 +418,36 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
if constexpr (Index == 0) return sword_attack_damage();
else static_assert(Index != Index, "Invalid Field Index");
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
verifier.EndTable();
}
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Attacker> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
AttackerT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<Attacker> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct AttackerBuilder {
typedef Attacker Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_sword_attack_damage(int32_t sword_attack_damage) {
fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0);
}
explicit AttackerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit AttackerBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Attacker> Finish() {
::flatbuffers::Offset<Attacker> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Attacker>(end);
auto o = ::flatbuffers::Offset<Attacker>(end);
return o;
}
};
inline flatbuffers::Offset<Attacker> CreateAttacker(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<Attacker> CreateAttacker(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t sword_attack_damage = 0) {
AttackerBuilder builder_(_fbb);
builder_.add_sword_attack_damage(sword_attack_damage);
@@ -467,18 +467,18 @@ struct Attacker::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>());
};
flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct HandFanT : public flatbuffers::NativeTable {
struct HandFanT : public ::flatbuffers::NativeTable {
typedef HandFan TableType;
int32_t length = 0;
};
struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef HandFanT NativeTableType;
typedef HandFanBuilder Builder;
struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return HandFanTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -495,36 +495,36 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
if constexpr (Index == 0) return length();
else static_assert(Index != Index, "Invalid Field Index");
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
verifier.EndTable();
}
HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<HandFan> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
HandFanT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<HandFan> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct HandFanBuilder {
typedef HandFan Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_length(int32_t length) {
fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0);
}
explicit HandFanBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit HandFanBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<HandFan> Finish() {
::flatbuffers::Offset<HandFan> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<HandFan>(end);
auto o = ::flatbuffers::Offset<HandFan>(end);
return o;
}
};
inline flatbuffers::Offset<HandFan> CreateHandFan(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<HandFan> CreateHandFan(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t length = 0) {
HandFanBuilder builder_(_fbb);
builder_.add_length(length);
@@ -544,19 +544,19 @@ struct HandFan::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>());
};
flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MovieT : public flatbuffers::NativeTable {
struct MovieT : public ::flatbuffers::NativeTable {
typedef Movie TableType;
CharacterUnion main_character{};
std::vector<CharacterUnion> characters{};
};
struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MovieT NativeTableType;
typedef MovieBuilder Builder;
struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MovieTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -583,26 +583,26 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const BookReader *main_character_as_BookFan() const {
return main_character_type() == Character::BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
}
const flatbuffers::String *main_character_as_Other() const {
return main_character_type() == Character::Other ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
const ::flatbuffers::String *main_character_as_Other() const {
return main_character_type() == Character::Other ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
}
const flatbuffers::String *main_character_as_Unused() const {
return main_character_type() == Character::Unused ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
const ::flatbuffers::String *main_character_as_Unused() const {
return main_character_type() == Character::Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
}
void *mutable_main_character() {
return GetPointer<void *>(VT_MAIN_CHARACTER);
}
const flatbuffers::Vector<Character> *characters_type() const {
return GetPointer<const flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
const ::flatbuffers::Vector<Character> *characters_type() const {
return GetPointer<const ::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
}
flatbuffers::Vector<Character> *mutable_characters_type() {
return GetPointer<flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
::flatbuffers::Vector<Character> *mutable_characters_type() {
return GetPointer<::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
}
const flatbuffers::Vector<flatbuffers::Offset<void>> *characters() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *characters() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
flatbuffers::Vector<flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
template<size_t Index>
auto get_field() const {
@@ -612,7 +612,7 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
else if constexpr (Index == 3) return characters();
else static_assert(Index != Index, "Invalid Field Index");
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -624,44 +624,44 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyCharacterVector(verifier, characters(), characters_type()) &&
verifier.EndTable();
}
MovieT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Movie> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MovieBuilder {
typedef Movie Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_main_character_type(Character main_character_type) {
fbb_.AddElement<uint8_t>(Movie::VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(main_character_type), 0);
}
void add_main_character(flatbuffers::Offset<void> main_character) {
void add_main_character(::flatbuffers::Offset<void> main_character) {
fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character);
}
void add_characters_type(flatbuffers::Offset<flatbuffers::Vector<Character>> characters_type) {
void add_characters_type(::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type) {
fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, characters_type);
}
void add_characters(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters) {
void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
}
explicit MovieBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Movie> Finish() {
::flatbuffers::Offset<Movie> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Movie>(end);
auto o = ::flatbuffers::Offset<Movie>(end);
return o;
}
};
inline flatbuffers::Offset<Movie> CreateMovie(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<Movie> CreateMovie(
::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character::NONE,
flatbuffers::Offset<void> main_character = 0,
flatbuffers::Offset<flatbuffers::Vector<Character>> characters_type = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters = 0) {
::flatbuffers::Offset<void> main_character = 0,
::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
MovieBuilder builder_(_fbb);
builder_.add_characters(characters);
builder_.add_characters_type(characters_type);
@@ -686,14 +686,14 @@ struct Movie::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>());
};
inline flatbuffers::Offset<Movie> CreateMovieDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character::NONE,
flatbuffers::Offset<void> main_character = 0,
::flatbuffers::Offset<void> main_character = 0,
const std::vector<Character> *characters_type = nullptr,
const std::vector<flatbuffers::Offset<void>> *characters = nullptr) {
const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) {
auto characters_type__ = characters_type ? _fbb.CreateVector<Character>(*characters_type) : 0;
auto characters__ = characters ? _fbb.CreateVector<flatbuffers::Offset<void>>(*characters) : 0;
auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
return CreateMovie(
_fbb,
main_character_type,
@@ -702,87 +702,87 @@ inline flatbuffers::Offset<Movie> CreateMovieDirect(
characters__);
}
flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline AttackerT *Attacker::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline AttackerT *Attacker::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<AttackerT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Attacker::UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void Attacker::UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; }
}
inline flatbuffers::Offset<Attacker> Attacker::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Attacker> Attacker::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateAttacker(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _sword_attack_damage = _o->sword_attack_damage;
return CreateAttacker(
_fbb,
_sword_attack_damage);
}
inline HandFanT *HandFan::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline HandFanT *HandFan::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<HandFanT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void HandFan::UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void HandFan::UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = length(); _o->length = _e; }
}
inline flatbuffers::Offset<HandFan> HandFan::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<HandFan> HandFan::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateHandFan(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _length = _o->length;
return CreateHandFan(
_fbb,
_length);
}
inline MovieT *Movie::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline MovieT *Movie::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<MovieT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Movie::UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = main_character_type(); _o->main_character.type = _e; }
{ auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
}
inline flatbuffers::Offset<Movie> Movie::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMovie(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _main_character_type = _o->main_character.type;
auto _main_character = _o->main_character.Pack(_fbb);
auto _characters_type = _o->characters.size() ? _fbb.CreateVector<Character>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].type; }, &_va) : 0;
auto _characters = _o->characters.size() ? _fbb.CreateVector<flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
return CreateMovie(
_fbb,
_main_character_type,
@@ -791,7 +791,7 @@ inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_f
_characters);
}
inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type) {
inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type) {
switch (type) {
case Character::NONE: {
return true;
@@ -810,21 +810,21 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character::Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr);
}
case Character::Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr);
}
default: return true;
}
}
inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Character> *types) {
inline bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyCharacter(
verifier, values->Get(i), types->GetEnum<Character>(i))) {
return false;
@@ -833,7 +833,7 @@ inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuf
return true;
}
inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver) {
inline void *CharacterUnion::UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver) {
(void)resolver;
switch (type) {
case Character::MuLan: {
@@ -853,18 +853,18 @@ inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatb
return new BookReader(*ptr);
}
case Character::Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return new std::string(ptr->c_str(), ptr->size());
}
case Character::Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return new std::string(ptr->c_str(), ptr->size());
}
default: return nullptr;
}
}
inline flatbuffers::Offset<void> CharacterUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
inline ::flatbuffers::Offset<void> CharacterUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case Character::MuLan: {
@@ -964,7 +964,7 @@ inline void CharacterUnion::Reset() {
type = Character::NONE;
}
inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
switch (type) {
case Gadget::NONE: {
return true;
@@ -980,10 +980,10 @@ inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadge
}
}
inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Gadget> *types) {
inline bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyGadget(
verifier, values->Get(i), types->GetEnum<Gadget>(i))) {
return false;
@@ -992,7 +992,7 @@ inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffer
return true;
}
inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver) {
inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver) {
(void)resolver;
switch (type) {
case Gadget::FallingTub: {
@@ -1007,7 +1007,7 @@ inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const flatbuffers
}
}
inline flatbuffers::Offset<void> GadgetUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
inline ::flatbuffers::Offset<void> GadgetUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case Gadget::FallingTub: {
@@ -1055,17 +1055,17 @@ inline void GadgetUnion::Reset() {
type = Gadget::NONE;
}
inline const flatbuffers::TypeTable *CharacterTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 },
{ flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_STRING, 0, -1 }
inline const ::flatbuffers::TypeTable *CharacterTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ ::flatbuffers::ET_STRING, 0, -1 },
{ ::flatbuffers::ET_STRING, 0, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
AttackerTypeTable,
RapunzelTypeTable,
BookReaderTypeTable
@@ -1079,19 +1079,19 @@ inline const flatbuffers::TypeTable *CharacterTypeTable() {
"Other",
"Unused"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *GadgetTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 }
inline const ::flatbuffers::TypeTable *GadgetTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
FallingTubTypeTable,
HandFanTypeTable
};
@@ -1100,88 +1100,88 @@ inline const flatbuffers::TypeTable *GadgetTypeTable() {
"FallingTub",
"HandFan"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *AttackerTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *AttackerTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const char * const names[] = {
"sword_attack_damage"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *RapunzelTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *RapunzelTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const int64_t values[] = { 0, 4 };
static const char * const names[] = {
"hair_length"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *BookReaderTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *BookReaderTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const int64_t values[] = { 0, 4 };
static const char * const names[] = {
"books_read"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *FallingTubTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *FallingTubTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const int64_t values[] = { 0, 4 };
static const char * const names[] = {
"weight"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *HandFanTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *HandFanTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const char * const names[] = {
"length"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *MovieTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UTYPE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_UTYPE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 0 }
inline const ::flatbuffers::TypeTable *MovieTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_UTYPE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_UTYPE, 1, 0 },
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
CharacterTypeTable
};
static const char * const names[] = {
@@ -1190,26 +1190,26 @@ inline const flatbuffers::TypeTable *MovieTypeTable() {
"characters_type",
"characters"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const Movie *GetMovie(const void *buf) {
return flatbuffers::GetRoot<Movie>(buf);
return ::flatbuffers::GetRoot<Movie>(buf);
}
inline const Movie *GetSizePrefixedMovie(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Movie>(buf);
return ::flatbuffers::GetSizePrefixedRoot<Movie>(buf);
}
inline Movie *GetMutableMovie(void *buf) {
return flatbuffers::GetMutableRoot<Movie>(buf);
return ::flatbuffers::GetMutableRoot<Movie>(buf);
}
inline Movie *GetMutableSizePrefixedMovie(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
}
inline const char *MovieIdentifier() {
@@ -1217,46 +1217,46 @@ inline const char *MovieIdentifier() {
}
inline bool MovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier());
}
inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier(), true);
}
inline bool VerifyMovieBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Movie>(MovieIdentifier());
}
inline bool VerifySizePrefixedMovieBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
}
inline void FinishMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Movie> root) {
fbb.Finish(root, MovieIdentifier());
}
inline void FinishSizePrefixedMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Movie> root) {
fbb.FinishSizePrefixed(root, MovieIdentifier());
}
inline std::unique_ptr<MovieT> UnPackMovie(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
}
inline std::unique_ptr<MovieT> UnPackSizePrefixedMovie(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res));
}

134
tests/evolution_test/evolution_v1_generated.h
View File

@@ -52,7 +52,7 @@ inline const char * const *EnumNamesEnum() {
}
inline const char *EnumNameEnum(Enum e) {
if (flatbuffers::IsOutRange(e, Enum::King, Enum::Queen)) return "";
if (::flatbuffers::IsOutRange(e, Enum::King, Enum::Queen)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesEnum()[index];
}
@@ -85,7 +85,7 @@ inline const char * const *EnumNamesUnion() {
}
inline const char *EnumNameUnion(Union e) {
if (flatbuffers::IsOutRange(e, Union::NONE, Union::TableB)) return "";
if (::flatbuffers::IsOutRange(e, Union::NONE, Union::TableB)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesUnion()[index];
}
@@ -102,8 +102,8 @@ template<> struct UnionTraits<Evolution::V1::TableB> {
static const Union enum_value = Union::TableB;
};
bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type);
bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types);
bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type);
bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
private:
@@ -119,16 +119,16 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
(void)padding0__;
}
Struct(int32_t _a, double _b)
: a_(flatbuffers::EndianScalar(_a)),
: a_(::flatbuffers::EndianScalar(_a)),
padding0__(0),
b_(flatbuffers::EndianScalar(_b)) {
b_(::flatbuffers::EndianScalar(_b)) {
(void)padding0__;
}
int32_t a() const {
return flatbuffers::EndianScalar(a_);
return ::flatbuffers::EndianScalar(a_);
}
double b() const {
return flatbuffers::EndianScalar(b_);
return ::flatbuffers::EndianScalar(b_);
}
};
FLATBUFFERS_STRUCT_END(Struct, 16);
@@ -144,7 +144,7 @@ inline bool operator!=(const Struct &lhs, const Struct &rhs) {
}
struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableABuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4,
@@ -156,7 +156,7 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t b() const {
return GetField<int32_t>(VT_B, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -166,27 +166,27 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableABuilder {
typedef TableA Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::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)
explicit TableABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableA> Finish() {
::flatbuffers::Offset<TableA> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableA>(end);
auto o = ::flatbuffers::Offset<TableA>(end);
return o;
}
};
inline flatbuffers::Offset<TableA> CreateTableA(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<TableA> CreateTableA(
::flatbuffers::FlatBufferBuilder &_fbb,
float a = 0.0f,
int32_t b = 0) {
TableABuilder builder_(_fbb);
@@ -195,7 +195,7 @@ inline flatbuffers::Offset<TableA> CreateTableA(
return builder_.Finish();
}
struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableBBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4
@@ -203,7 +203,7 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t a() const {
return GetField<int32_t>(VT_A, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) &&
verifier.EndTable();
@@ -212,31 +212,31 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableBBuilder {
typedef TableB Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::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)
explicit TableBBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableB> Finish() {
::flatbuffers::Offset<TableB> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableB>(end);
auto o = ::flatbuffers::Offset<TableB>(end);
return o;
}
};
inline flatbuffers::Offset<TableB> CreateTableB(
flatbuffers::FlatBufferBuilder &_fbb,
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 {
struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RootBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4,
@@ -280,11 +280,11 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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<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);
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);
@@ -302,7 +302,7 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const Evolution::V1::TableB *j_as_TableB() const {
return j_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(j()) : nullptr;
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) &&
VerifyField<uint8_t>(verifier, VT_B, 1) &&
@@ -344,8 +344,8 @@ template<> inline const Evolution::V1::TableB *Root::j_as<Evolution::V1::TableB>
struct RootBuilder {
typedef Root Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_a(int32_t a) {
fbb_.AddElement<int32_t>(Root::VT_A, a, 0);
}
@@ -355,22 +355,22 @@ struct RootBuilder {
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) {
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) {
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) {
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) {
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) {
@@ -379,34 +379,34 @@ struct RootBuilder {
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) {
void add_j(::flatbuffers::Offset<void> j) {
fbb_.AddOffset(Root::VT_J, j);
}
explicit RootBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit RootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Root> Finish() {
::flatbuffers::Offset<Root> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Root>(end);
auto o = ::flatbuffers::Offset<Root>(end);
return o;
}
};
inline flatbuffers::Offset<Root> CreateRoot(
flatbuffers::FlatBufferBuilder &_fbb,
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,
::flatbuffers::Offset<void> c = 0,
Evolution::V1::Enum d = Evolution::V1::Enum::King,
flatbuffers::Offset<Evolution::V1::TableA> e = 0,
::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,
::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) {
::flatbuffers::Offset<void> j = 0) {
RootBuilder builder_(_fbb);
builder_.add_j(j);
builder_.add_i(i);
@@ -423,22 +423,22 @@ inline flatbuffers::Offset<Root> CreateRoot(
return builder_.Finish();
}
inline flatbuffers::Offset<Root> CreateRootDirect(
flatbuffers::FlatBufferBuilder &_fbb,
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,
::flatbuffers::Offset<void> c = 0,
Evolution::V1::Enum d = Evolution::V1::Enum::King,
flatbuffers::Offset<Evolution::V1::TableA> e = 0,
::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,
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) {
::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;
auto h__ = h ? _fbb.CreateVector<::flatbuffers::Offset<Evolution::V1::TableB>>(*h) : 0;
return Evolution::V1::CreateRoot(
_fbb,
a,
@@ -455,7 +455,7 @@ inline flatbuffers::Offset<Root> CreateRootDirect(
j);
}
inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type) {
inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type) {
switch (type) {
case Union::NONE: {
return true;
@@ -472,10 +472,10 @@ inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union
}
}
inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types) {
inline bool VerifyUnionVector(::flatbuffers::Verifier &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) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyUnion(
verifier, values->Get(i), types->GetEnum<Union>(i))) {
return false;
@@ -485,32 +485,32 @@ inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers
}
inline const Evolution::V1::Root *GetRoot(const void *buf) {
return flatbuffers::GetRoot<Evolution::V1::Root>(buf);
return ::flatbuffers::GetRoot<Evolution::V1::Root>(buf);
}
inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf);
return ::flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf);
}
inline bool VerifyRootBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Evolution::V1::Root>(nullptr);
}
inline bool VerifySizePrefixedRootBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr);
}
inline void FinishRootBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V1::Root> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Evolution::V1::Root> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedRootBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V1::Root> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Evolution::V1::Root> root) {
fbb.FinishSizePrefixed(root);
}

176
tests/evolution_test/evolution_v2_generated.h
View File

@@ -61,7 +61,7 @@ inline const char * const *EnumNamesEnum() {
}
inline const char *EnumNameEnum(Enum e) {
if (flatbuffers::IsOutRange(e, Enum::King, Enum::Bishop)) return "";
if (::flatbuffers::IsOutRange(e, Enum::King, Enum::Bishop)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesEnum()[index];
}
@@ -97,7 +97,7 @@ inline const char * const *EnumNamesUnion() {
}
inline const char *EnumNameUnion(Union e) {
if (flatbuffers::IsOutRange(e, Union::NONE, Union::TableC)) return "";
if (::flatbuffers::IsOutRange(e, Union::NONE, Union::TableC)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesUnion()[index];
}
@@ -118,8 +118,8 @@ template<> struct UnionTraits<Evolution::V2::TableC> {
static const Union enum_value = Union::TableC;
};
bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type);
bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types);
bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type);
bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
private:
@@ -135,16 +135,16 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
(void)padding0__;
}
Struct(int32_t _a, double _b)
: a_(flatbuffers::EndianScalar(_a)),
: a_(::flatbuffers::EndianScalar(_a)),
padding0__(0),
b_(flatbuffers::EndianScalar(_b)) {
b_(::flatbuffers::EndianScalar(_b)) {
(void)padding0__;
}
int32_t a() const {
return flatbuffers::EndianScalar(a_);
return ::flatbuffers::EndianScalar(a_);
}
double b() const {
return flatbuffers::EndianScalar(b_);
return ::flatbuffers::EndianScalar(b_);
}
};
FLATBUFFERS_STRUCT_END(Struct, 16);
@@ -160,7 +160,7 @@ inline bool operator!=(const Struct &lhs, const Struct &rhs) {
}
struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableABuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4,
@@ -173,10 +173,10 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t b() const {
return GetField<int32_t>(VT_B, 0);
}
const flatbuffers::String *c() const {
return GetPointer<const flatbuffers::String *>(VT_C);
const ::flatbuffers::String *c() const {
return GetPointer<const ::flatbuffers::String *>(VT_C);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -188,33 +188,33 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableABuilder {
typedef TableA Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::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) {
void add_c(::flatbuffers::Offset<::flatbuffers::String> c) {
fbb_.AddOffset(TableA::VT_C, c);
}
explicit TableABuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit TableABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableA> Finish() {
::flatbuffers::Offset<TableA> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableA>(end);
auto o = ::flatbuffers::Offset<TableA>(end);
return o;
}
};
inline flatbuffers::Offset<TableA> CreateTableA(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<TableA> CreateTableA(
::flatbuffers::FlatBufferBuilder &_fbb,
float a = 0.0f,
int32_t b = 0,
flatbuffers::Offset<flatbuffers::String> c = 0) {
::flatbuffers::Offset<::flatbuffers::String> c = 0) {
TableABuilder builder_(_fbb);
builder_.add_c(c);
builder_.add_b(b);
@@ -222,8 +222,8 @@ inline flatbuffers::Offset<TableA> CreateTableA(
return builder_.Finish();
}
inline flatbuffers::Offset<TableA> CreateTableADirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<TableA> CreateTableADirect(
::flatbuffers::FlatBufferBuilder &_fbb,
float a = 0.0f,
int32_t b = 0,
const char *c = nullptr) {
@@ -235,7 +235,7 @@ inline flatbuffers::Offset<TableA> CreateTableADirect(
c__);
}
struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableBBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4
@@ -243,7 +243,7 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t a() const {
return GetField<int32_t>(VT_A, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) &&
verifier.EndTable();
@@ -252,31 +252,31 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableBBuilder {
typedef TableB Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::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)
explicit TableBBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableB> Finish() {
::flatbuffers::Offset<TableB> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableB>(end);
auto o = ::flatbuffers::Offset<TableB>(end);
return o;
}
};
inline flatbuffers::Offset<TableB> CreateTableB(
flatbuffers::FlatBufferBuilder &_fbb,
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 {
struct TableC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableCBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4,
@@ -285,10 +285,10 @@ struct TableC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
double a() const {
return GetField<double>(VT_A, 0.0);
}
const flatbuffers::String *b() const {
return GetPointer<const flatbuffers::String *>(VT_B);
const ::flatbuffers::String *b() const {
return GetPointer<const ::flatbuffers::String *>(VT_B);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_A, 8) &&
VerifyOffset(verifier, VT_B) &&
@@ -299,37 +299,37 @@ struct TableC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableCBuilder {
typedef TableC Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::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) {
void add_b(::flatbuffers::Offset<::flatbuffers::String> b) {
fbb_.AddOffset(TableC::VT_B, b);
}
explicit TableCBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit TableCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableC> Finish() {
::flatbuffers::Offset<TableC> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableC>(end);
auto o = ::flatbuffers::Offset<TableC>(end);
return o;
}
};
inline flatbuffers::Offset<TableC> CreateTableC(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<TableC> CreateTableC(
::flatbuffers::FlatBufferBuilder &_fbb,
double a = 0.0,
flatbuffers::Offset<flatbuffers::String> b = 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,
inline ::flatbuffers::Offset<TableC> CreateTableCDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
double a = 0.0,
const char *b = nullptr) {
auto b__ = b ? _fbb.CreateString(b) : 0;
@@ -339,7 +339,7 @@ inline flatbuffers::Offset<TableC> CreateTableCDirect(
b__);
}
struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RootBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_B = 6,
@@ -382,11 +382,11 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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<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);
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);
@@ -397,7 +397,7 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint8_t l() const {
return GetField<uint8_t>(VT_L, 56);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_B, 1) &&
VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) &&
@@ -434,64 +434,64 @@ template<> inline const Evolution::V2::TableC *Root::c_as<Evolution::V2::TableC>
struct RootBuilder {
typedef Root Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::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) {
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) {
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) {
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) {
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) {
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)
explicit RootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Root> Finish() {
::flatbuffers::Offset<Root> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Root>(end);
auto o = ::flatbuffers::Offset<Root>(end);
return o;
}
};
inline flatbuffers::Offset<Root> CreateRoot(
flatbuffers::FlatBufferBuilder &_fbb,
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,
::flatbuffers::Offset<void> c = 0,
Evolution::V2::Enum d = Evolution::V2::Enum::King,
flatbuffers::Offset<Evolution::V2::TableA> e = 0,
::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,
::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,
::flatbuffers::Offset<Evolution::V2::TableC> k = 0,
uint8_t l = 56) {
RootBuilder builder_(_fbb);
builder_.add_k(k);
@@ -508,21 +508,21 @@ inline flatbuffers::Offset<Root> CreateRoot(
return builder_.Finish();
}
inline flatbuffers::Offset<Root> CreateRootDirect(
flatbuffers::FlatBufferBuilder &_fbb,
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,
::flatbuffers::Offset<void> c = 0,
Evolution::V2::Enum d = Evolution::V2::Enum::King,
flatbuffers::Offset<Evolution::V2::TableA> e = 0,
::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,
const std::vector<::flatbuffers::Offset<Evolution::V2::TableB>> *h = nullptr,
uint32_t i = 1234,
flatbuffers::Offset<Evolution::V2::TableC> k = 0,
::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;
auto h__ = h ? _fbb.CreateVector<::flatbuffers::Offset<Evolution::V2::TableB>>(*h) : 0;
return Evolution::V2::CreateRoot(
_fbb,
b,
@@ -538,7 +538,7 @@ inline flatbuffers::Offset<Root> CreateRootDirect(
l);
}
inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type) {
inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type) {
switch (type) {
case Union::NONE: {
return true;
@@ -559,10 +559,10 @@ inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union
}
}
inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types) {
inline bool VerifyUnionVector(::flatbuffers::Verifier &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) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyUnion(
verifier, values->Get(i), types->GetEnum<Union>(i))) {
return false;
@@ -572,32 +572,32 @@ inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers
}
inline const Evolution::V2::Root *GetRoot(const void *buf) {
return flatbuffers::GetRoot<Evolution::V2::Root>(buf);
return ::flatbuffers::GetRoot<Evolution::V2::Root>(buf);
}
inline const Evolution::V2::Root *GetSizePrefixedRoot(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf);
return ::flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf);
}
inline bool VerifyRootBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Evolution::V2::Root>(nullptr);
}
inline bool VerifySizePrefixedRootBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr);
}
inline void FinishRootBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V2::Root> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Evolution::V2::Root> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedRootBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V2::Root> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Evolution::V2::Root> root) {
fbb.FinishSizePrefixed(root);
}

214
tests/key_field/key_field_sample_generated.h
View File

@@ -31,11 +31,11 @@ bool operator!=(const Bar &lhs, const Bar &rhs);
bool operator==(const FooTableT &lhs, const FooTableT &rhs);
bool operator!=(const FooTableT &lhs, const FooTableT &rhs);
inline const flatbuffers::TypeTable *BazTypeTable();
inline const ::flatbuffers::TypeTable *BazTypeTable();
inline const flatbuffers::TypeTable *BarTypeTable();
inline const ::flatbuffers::TypeTable *BarTypeTable();
inline const flatbuffers::TypeTable *FooTableTypeTable();
inline const ::flatbuffers::TypeTable *FooTableTypeTable();
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
private:
@@ -43,7 +43,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
uint8_t b_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BazTypeTable();
}
Baz()
@@ -52,24 +52,24 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
}
Baz(uint8_t _b)
: a_(),
b_(flatbuffers::EndianScalar(_b)) {
b_(::flatbuffers::EndianScalar(_b)) {
}
Baz(flatbuffers::span<const uint8_t, 4> _a, uint8_t _b)
: b_(flatbuffers::EndianScalar(_b)) {
flatbuffers::CastToArray(a_).CopyFromSpan(_a);
Baz(::flatbuffers::span<const uint8_t, 4> _a, uint8_t _b)
: b_(::flatbuffers::EndianScalar(_b)) {
::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
}
const flatbuffers::Array<uint8_t, 4> *a() const {
return &flatbuffers::CastToArray(a_);
const ::flatbuffers::Array<uint8_t, 4> *a() const {
return &::flatbuffers::CastToArray(a_);
}
flatbuffers::Array<uint8_t, 4> *mutable_a() {
return &flatbuffers::CastToArray(a_);
::flatbuffers::Array<uint8_t, 4> *mutable_a() {
return &::flatbuffers::CastToArray(a_);
}
bool KeyCompareLessThan(const Baz * const o) const {
return KeyCompareWithValue(o->a()) < 0;
}
int KeyCompareWithValue(const flatbuffers::Array<uint8_t, 4> *_a) const {
const flatbuffers::Array<uint8_t, 4> *curr_a = a();
for (flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
int KeyCompareWithValue(const ::flatbuffers::Array<uint8_t, 4> *_a) const {
const ::flatbuffers::Array<uint8_t, 4> *curr_a = a();
for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
const auto lhs = curr_a->Get(i);
const auto rhs = _a->Get(i);
if(lhs != rhs)
@@ -78,10 +78,10 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
return 0;
}
uint8_t b() const {
return flatbuffers::EndianScalar(b_);
return ::flatbuffers::EndianScalar(b_);
}
void mutate_b(uint8_t _b) {
flatbuffers::WriteScalar(&b_, _b);
::flatbuffers::WriteScalar(&b_, _b);
}
};
FLATBUFFERS_STRUCT_END(Baz, 5);
@@ -104,7 +104,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS {
int8_t padding0__; int16_t padding1__;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BarTypeTable();
}
Bar()
@@ -117,32 +117,32 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS {
}
Bar(uint8_t _b)
: a_(),
b_(flatbuffers::EndianScalar(_b)),
b_(::flatbuffers::EndianScalar(_b)),
padding0__(0),
padding1__(0) {
(void)padding0__;
(void)padding1__;
}
Bar(flatbuffers::span<const float, 3> _a, uint8_t _b)
: b_(flatbuffers::EndianScalar(_b)),
Bar(::flatbuffers::span<const float, 3> _a, uint8_t _b)
: b_(::flatbuffers::EndianScalar(_b)),
padding0__(0),
padding1__(0) {
flatbuffers::CastToArray(a_).CopyFromSpan(_a);
::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
(void)padding0__;
(void)padding1__;
}
const flatbuffers::Array<float, 3> *a() const {
return &flatbuffers::CastToArray(a_);
const ::flatbuffers::Array<float, 3> *a() const {
return &::flatbuffers::CastToArray(a_);
}
flatbuffers::Array<float, 3> *mutable_a() {
return &flatbuffers::CastToArray(a_);
::flatbuffers::Array<float, 3> *mutable_a() {
return &::flatbuffers::CastToArray(a_);
}
bool KeyCompareLessThan(const Bar * const o) const {
return KeyCompareWithValue(o->a()) < 0;
}
int KeyCompareWithValue(const flatbuffers::Array<float, 3> *_a) const {
const flatbuffers::Array<float, 3> *curr_a = a();
for (flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
int KeyCompareWithValue(const ::flatbuffers::Array<float, 3> *_a) const {
const ::flatbuffers::Array<float, 3> *curr_a = a();
for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
const auto lhs = curr_a->Get(i);
const auto rhs = _a->Get(i);
if(lhs != rhs)
@@ -151,10 +151,10 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS {
return 0;
}
uint8_t b() const {
return flatbuffers::EndianScalar(b_);
return ::flatbuffers::EndianScalar(b_);
}
void mutate_b(uint8_t _b) {
flatbuffers::WriteScalar(&b_, _b);
::flatbuffers::WriteScalar(&b_, _b);
}
};
FLATBUFFERS_STRUCT_END(Bar, 16);
@@ -170,7 +170,7 @@ inline bool operator!=(const Bar &lhs, const Bar &rhs) {
}
struct FooTableT : public flatbuffers::NativeTable {
struct FooTableT : public ::flatbuffers::NativeTable {
typedef FooTable TableType;
int32_t a = 0;
int32_t b = 0;
@@ -179,10 +179,10 @@ struct FooTableT : public flatbuffers::NativeTable {
std::vector<keyfield::sample::Bar> e{};
};
struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct FooTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef FooTableT NativeTableType;
typedef FooTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return FooTableTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -204,11 +204,11 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_b(int32_t _b = 0) {
return SetField<int32_t>(VT_B, _b, 0);
}
const flatbuffers::String *c() const {
return GetPointer<const flatbuffers::String *>(VT_C);
const ::flatbuffers::String *c() const {
return GetPointer<const ::flatbuffers::String *>(VT_C);
}
flatbuffers::String *mutable_c() {
return GetPointer<flatbuffers::String *>(VT_C);
::flatbuffers::String *mutable_c() {
return GetPointer<::flatbuffers::String *>(VT_C);
}
bool KeyCompareLessThan(const FooTable * const o) const {
return *c() < *o->c();
@@ -216,19 +216,19 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int KeyCompareWithValue(const char *_c) const {
return strcmp(c()->c_str(), _c);
}
const flatbuffers::Vector<const keyfield::sample::Baz *> *d() const {
return GetPointer<const flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
const ::flatbuffers::Vector<const keyfield::sample::Baz *> *d() const {
return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
}
flatbuffers::Vector<const keyfield::sample::Baz *> *mutable_d() {
return GetPointer<flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
::flatbuffers::Vector<const keyfield::sample::Baz *> *mutable_d() {
return GetPointer<::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
}
const flatbuffers::Vector<const keyfield::sample::Bar *> *e() const {
return GetPointer<const flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
const ::flatbuffers::Vector<const keyfield::sample::Bar *> *e() const {
return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
}
flatbuffers::Vector<const keyfield::sample::Bar *> *mutable_e() {
return GetPointer<flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
::flatbuffers::Vector<const keyfield::sample::Bar *> *mutable_e() {
return GetPointer<::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -240,49 +240,49 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(e()) &&
verifier.EndTable();
}
FooTableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FooTableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<FooTable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
FooTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<FooTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FooTableBuilder {
typedef FooTable Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_a(int32_t a) {
fbb_.AddElement<int32_t>(FooTable::VT_A, a, 0);
}
void add_b(int32_t b) {
fbb_.AddElement<int32_t>(FooTable::VT_B, b, 0);
}
void add_c(flatbuffers::Offset<flatbuffers::String> c) {
void add_c(::flatbuffers::Offset<::flatbuffers::String> c) {
fbb_.AddOffset(FooTable::VT_C, c);
}
void add_d(flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Baz *>> d) {
void add_d(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d) {
fbb_.AddOffset(FooTable::VT_D, d);
}
void add_e(flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Bar *>> e) {
void add_e(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e) {
fbb_.AddOffset(FooTable::VT_E, e);
}
explicit FooTableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit FooTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<FooTable> Finish() {
::flatbuffers::Offset<FooTable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FooTable>(end);
auto o = ::flatbuffers::Offset<FooTable>(end);
fbb_.Required(o, FooTable::VT_C);
return o;
}
};
inline flatbuffers::Offset<FooTable> CreateFooTable(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<FooTable> CreateFooTable(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0,
int32_t b = 0,
flatbuffers::Offset<flatbuffers::String> c = 0,
flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Baz *>> d = 0,
flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Bar *>> e = 0) {
::flatbuffers::Offset<::flatbuffers::String> c = 0,
::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d = 0,
::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e = 0) {
FooTableBuilder builder_(_fbb);
builder_.add_e(e);
builder_.add_d(d);
@@ -292,8 +292,8 @@ inline flatbuffers::Offset<FooTable> CreateFooTable(
return builder_.Finish();
}
inline flatbuffers::Offset<FooTable> CreateFooTableDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<FooTable> CreateFooTableDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0,
int32_t b = 0,
const char *c = nullptr,
@@ -311,7 +311,7 @@ inline flatbuffers::Offset<FooTable> CreateFooTableDirect(
e__);
}
flatbuffers::Offset<FooTable> CreateFooTable(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const FooTableT &lhs, const FooTableT &rhs) {
@@ -328,30 +328,30 @@ inline bool operator!=(const FooTableT &lhs, const FooTableT &rhs) {
}
inline FooTableT *FooTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline FooTableT *FooTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<FooTableT>(new FooTableT());
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void FooTable::UnPackTo(FooTableT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void FooTable::UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = a(); _o->a = _e; }
{ auto _e = b(); _o->b = _e; }
{ auto _e = c(); if (_e) _o->c = _e->str(); }
{ auto _e = d(); if (_e) { _o->d.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->d[_i] = *_e->Get(_i); } } else { _o->d.resize(0); } }
{ auto _e = e(); if (_e) { _o->e.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->e[_i] = *_e->Get(_i); } } else { _o->e.resize(0); } }
{ auto _e = d(); if (_e) { _o->d.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->d[_i] = *_e->Get(_i); } } else { _o->d.resize(0); } }
{ auto _e = e(); if (_e) { _o->e.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->e[_i] = *_e->Get(_i); } } else { _o->e.resize(0); } }
}
inline flatbuffers::Offset<FooTable> FooTable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<FooTable> FooTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateFooTable(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<FooTable> CreateFooTable(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FooTableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FooTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _a = _o->a;
auto _b = _o->b;
auto _c = _fbb.CreateString(_o->c);
@@ -366,10 +366,10 @@ inline flatbuffers::Offset<FooTable> CreateFooTable(flatbuffers::FlatBufferBuild
_e);
}
inline const flatbuffers::TypeTable *BazTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UCHAR, 1, -1 },
{ flatbuffers::ET_UCHAR, 0, -1 }
inline const ::flatbuffers::TypeTable *BazTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_UCHAR, 1, -1 },
{ ::flatbuffers::ET_UCHAR, 0, -1 }
};
static const int16_t array_sizes[] = { 4, };
static const int64_t values[] = { 0, 4, 5 };
@@ -377,16 +377,16 @@ inline const flatbuffers::TypeTable *BazTypeTable() {
"a",
"b"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *BarTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_FLOAT, 1, -1 },
{ flatbuffers::ET_UCHAR, 0, -1 }
inline const ::flatbuffers::TypeTable *BarTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_FLOAT, 1, -1 },
{ ::flatbuffers::ET_UCHAR, 0, -1 }
};
static const int16_t array_sizes[] = { 3, };
static const int64_t values[] = { 0, 12, 16 };
@@ -394,21 +394,21 @@ inline const flatbuffers::TypeTable *BarTypeTable() {
"a",
"b"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *FooTableTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 },
{ flatbuffers::ET_INT, 0, -1 },
{ flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 1 }
inline const ::flatbuffers::TypeTable *FooTableTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 },
{ ::flatbuffers::ET_INT, 0, -1 },
{ ::flatbuffers::ET_STRING, 0, -1 },
{ ::flatbuffers::ET_SEQUENCE, 1, 0 },
{ ::flatbuffers::ET_SEQUENCE, 1, 1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
keyfield::sample::BazTypeTable,
keyfield::sample::BarTypeTable
};
@@ -419,59 +419,59 @@ inline const flatbuffers::TypeTable *FooTableTypeTable() {
"d",
"e"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const keyfield::sample::FooTable *GetFooTable(const void *buf) {
return flatbuffers::GetRoot<keyfield::sample::FooTable>(buf);
return ::flatbuffers::GetRoot<keyfield::sample::FooTable>(buf);
}
inline const keyfield::sample::FooTable *GetSizePrefixedFooTable(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<keyfield::sample::FooTable>(buf);
return ::flatbuffers::GetSizePrefixedRoot<keyfield::sample::FooTable>(buf);
}
inline FooTable *GetMutableFooTable(void *buf) {
return flatbuffers::GetMutableRoot<FooTable>(buf);
return ::flatbuffers::GetMutableRoot<FooTable>(buf);
}
inline keyfield::sample::FooTable *GetMutableSizePrefixedFooTable(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf);
}
inline bool VerifyFooTableBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<keyfield::sample::FooTable>(nullptr);
}
inline bool VerifySizePrefixedFooTableBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr);
}
inline void FinishFooTableBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<keyfield::sample::FooTable> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<keyfield::sample::FooTable> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedFooTableBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<keyfield::sample::FooTable> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<keyfield::sample::FooTable> root) {
fbb.FinishSizePrefixed(root);
}
inline flatbuffers::unique_ptr<keyfield::sample::FooTableT> UnPackFooTable(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<keyfield::sample::FooTableT>(GetFooTable(buf)->UnPack(res));
}
inline flatbuffers::unique_ptr<keyfield::sample::FooTableT> UnPackSizePrefixedFooTable(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<keyfield::sample::FooTableT>(GetSizePrefixedFooTable(buf)->UnPack(res));
}

132
tests/monster_extra_generated.h
View File

@@ -22,9 +22,9 @@ struct MonsterExtraT;
bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs);
bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs);
inline const flatbuffers::TypeTable *MonsterExtraTypeTable();
inline const ::flatbuffers::TypeTable *MonsterExtraTypeTable();
struct MonsterExtraT : public flatbuffers::NativeTable {
struct MonsterExtraT : public ::flatbuffers::NativeTable {
typedef MonsterExtra TableType;
double d0 = std::numeric_limits<double>::quiet_NaN();
double d1 = std::numeric_limits<double>::quiet_NaN();
@@ -38,10 +38,10 @@ struct MonsterExtraT : public flatbuffers::NativeTable {
std::vector<float> fvec{};
};
struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MonsterExtraT NativeTableType;
typedef MonsterExtraBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MonsterExtraTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -104,19 +104,19 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
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);
::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);
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);
::flatbuffers::Vector<float> *mutable_fvec() {
return GetPointer<::flatbuffers::Vector<float> *>(VT_FVEC);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_D0, 8) &&
VerifyField<double>(verifier, VT_D1, 8) &&
@@ -132,15 +132,15 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
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_;
::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());
}
@@ -165,25 +165,25 @@ struct MonsterExtraBuilder {
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) {
void add_dvec(::flatbuffers::Offset<::flatbuffers::Vector<double>> dvec) {
fbb_.AddOffset(MonsterExtra::VT_DVEC, dvec);
}
void add_fvec(flatbuffers::Offset<flatbuffers::Vector<float>> fvec) {
void add_fvec(::flatbuffers::Offset<::flatbuffers::Vector<float>> fvec) {
fbb_.AddOffset(MonsterExtra::VT_FVEC, fvec);
}
explicit MonsterExtraBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit MonsterExtraBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<MonsterExtra> Finish() {
::flatbuffers::Offset<MonsterExtra> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<MonsterExtra>(end);
auto o = ::flatbuffers::Offset<MonsterExtra>(end);
return o;
}
};
inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(
flatbuffers::FlatBufferBuilder &_fbb,
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(),
@@ -192,8 +192,8 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(
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) {
::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);
@@ -208,8 +208,8 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(
return builder_.Finish();
}
inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtraDirect(
flatbuffers::FlatBufferBuilder &_fbb,
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(),
@@ -236,7 +236,7 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtraDirect(
fvec__);
}
flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::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) {
@@ -258,13 +258,13 @@ inline bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs) {
}
inline MonsterExtraT *MonsterExtra::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
inline void MonsterExtra::UnPackTo(MonsterExtraT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = d0(); _o->d0 = _e; }
@@ -275,18 +275,18 @@ inline void MonsterExtra::UnPackTo(MonsterExtraT *_o, const flatbuffers::resolve
{ 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); } }
{ 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> MonsterExtra::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<MonsterExtra> MonsterExtra::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMonsterExtra(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(::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;
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;
@@ -311,19 +311,19 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBuf
_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 }
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",
@@ -338,26 +338,26 @@ inline const flatbuffers::TypeTable *MonsterExtraTypeTable() {
"fvec",
"deprec"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 11, type_codes, nullptr, nullptr, nullptr, names
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);
return ::flatbuffers::GetRoot<MyGame::MonsterExtra>(buf);
}
inline const MyGame::MonsterExtra *GetSizePrefixedMonsterExtra(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<MyGame::MonsterExtra>(buf);
return ::flatbuffers::GetSizePrefixedRoot<MyGame::MonsterExtra>(buf);
}
inline MonsterExtra *GetMutableMonsterExtra(void *buf) {
return flatbuffers::GetMutableRoot<MonsterExtra>(buf);
return ::flatbuffers::GetMutableRoot<MonsterExtra>(buf);
}
inline MyGame::MonsterExtra *GetMutableSizePrefixedMonsterExtra(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<MyGame::MonsterExtra>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::MonsterExtra>(buf);
}
inline const char *MonsterExtraIdentifier() {
@@ -365,22 +365,22 @@ inline const char *MonsterExtraIdentifier() {
}
inline bool MonsterExtraBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, MonsterExtraIdentifier());
}
inline bool SizePrefixedMonsterExtraBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, MonsterExtraIdentifier(), true);
}
inline bool VerifyMonsterExtraBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
}
inline bool VerifySizePrefixedMonsterExtraBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
}
@@ -389,26 +389,26 @@ inline const char *MonsterExtraExtension() {
}
inline void FinishMonsterExtraBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::MonsterExtra> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<MyGame::MonsterExtra> root) {
fbb.Finish(root, MonsterExtraIdentifier());
}
inline void FinishSizePrefixedMonsterExtraBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::MonsterExtra> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<MyGame::MonsterExtra> root) {
fbb.FinishSizePrefixed(root, MonsterExtraIdentifier());
}
inline flatbuffers::unique_ptr<MyGame::MonsterExtraT> UnPackMonsterExtra(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::MonsterExtraT>(GetMonsterExtra(buf)->UnPack(res));
}
inline flatbuffers::unique_ptr<MyGame::MonsterExtraT> UnPackSizePrefixedMonsterExtra(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::MonsterExtraT>(GetSizePrefixedMonsterExtra(buf)->UnPack(res));
}

1260
tests/monster_test_generated.h
View File

File diff suppressed because it is too large Load Diff

1260
tests/monster_test_suffix/ext_only/monster_test_generated.hpp
View File

File diff suppressed because it is too large Load Diff

1260
tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
View File

File diff suppressed because it is too large Load Diff

1260
tests/monster_test_suffix/monster_test_suffix.hpp
View File

File diff suppressed because it is too large Load Diff

132
tests/namespace_test/namespace_test1_generated.h
View File

@@ -27,9 +27,9 @@ 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 *TableInNestedNSTypeTable();
inline const flatbuffers::TypeTable *StructInNestedNSTypeTable();
inline const ::flatbuffers::TypeTable *StructInNestedNSTypeTable();
enum UnionInNestedNS : uint8_t {
UnionInNestedNS_NONE = 0,
@@ -56,7 +56,7 @@ inline const char * const *EnumNamesUnionInNestedNS() {
}
inline const char *EnumNameUnionInNestedNS(UnionInNestedNS e) {
if (flatbuffers::IsOutRange(e, UnionInNestedNS_NONE, UnionInNestedNS_TableInNestedNS)) return "";
if (::flatbuffers::IsOutRange(e, UnionInNestedNS_NONE, UnionInNestedNS_TableInNestedNS)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesUnionInNestedNS()[index];
}
@@ -104,8 +104,8 @@ struct UnionInNestedNSUnion {
}
}
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;
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 ?
@@ -138,8 +138,8 @@ inline bool operator!=(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUni
return !(lhs == rhs);
}
bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type);
bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
bool VerifyUnionInNestedNS(::flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type);
bool VerifyUnionInNestedNSVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum EnumInNestedNS : int8_t {
EnumInNestedNS_A = 0,
@@ -169,7 +169,7 @@ inline const char * const *EnumNamesEnumInNestedNS() {
}
inline const char *EnumNameEnumInNestedNS(EnumInNestedNS e) {
if (flatbuffers::IsOutRange(e, EnumInNestedNS_A, EnumInNestedNS_C)) return "";
if (::flatbuffers::IsOutRange(e, EnumInNestedNS_A, EnumInNestedNS_C)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesEnumInNestedNS()[index];
}
@@ -180,7 +180,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS
int32_t b_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return StructInNestedNSTypeTable();
}
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -191,20 +191,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS
b_(0) {
}
StructInNestedNS(int32_t _a, int32_t _b)
: a_(flatbuffers::EndianScalar(_a)),
b_(flatbuffers::EndianScalar(_b)) {
: a_(::flatbuffers::EndianScalar(_a)),
b_(::flatbuffers::EndianScalar(_b)) {
}
int32_t a() const {
return flatbuffers::EndianScalar(a_);
return ::flatbuffers::EndianScalar(a_);
}
void mutate_a(int32_t _a) {
flatbuffers::WriteScalar(&a_, _a);
::flatbuffers::WriteScalar(&a_, _a);
}
int32_t b() const {
return flatbuffers::EndianScalar(b_);
return ::flatbuffers::EndianScalar(b_);
}
void mutate_b(int32_t _b) {
flatbuffers::WriteScalar(&b_, _b);
::flatbuffers::WriteScalar(&b_, _b);
}
};
FLATBUFFERS_STRUCT_END(StructInNestedNS, 8);
@@ -220,7 +220,7 @@ inline bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs)
}
struct TableInNestedNST : public flatbuffers::NativeTable {
struct TableInNestedNST : public ::flatbuffers::NativeTable {
typedef TableInNestedNS TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceA.NamespaceB.TableInNestedNST";
@@ -228,10 +228,10 @@ struct TableInNestedNST : public flatbuffers::NativeTable {
int32_t foo = 0;
};
struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableInNestedNST NativeTableType;
typedef TableInNestedNSBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInNestedNSTypeTable();
}
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -246,43 +246,43 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_foo(int32_t _foo = 0) {
return SetField<int32_t>(VT_FOO, _foo, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &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);
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_;
::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)
explicit TableInNestedNSBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableInNestedNS> Finish() {
::flatbuffers::Offset<TableInNestedNS> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableInNestedNS>(end);
auto o = ::flatbuffers::Offset<TableInNestedNS>(end);
return o;
}
};
inline flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(
flatbuffers::FlatBufferBuilder &_fbb,
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);
::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) {
@@ -295,33 +295,33 @@ inline bool operator!=(const TableInNestedNST &lhs, const TableInNestedNST &rhs)
}
inline TableInNestedNST *TableInNestedNS::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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> TableInNestedNS::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TableInNestedNS> TableInNestedNS::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInNestedNS(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(::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;
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);
}
inline bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type) {
inline bool VerifyUnionInNestedNS(::flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type) {
switch (type) {
case UnionInNestedNS_NONE: {
return true;
@@ -334,10 +334,10 @@ inline bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *o
}
}
inline bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
inline bool VerifyUnionInNestedNSVector(::flatbuffers::Verifier &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) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyUnionInNestedNS(
verifier, values->Get(i), types->GetEnum<UnionInNestedNS>(i))) {
return false;
@@ -346,7 +346,7 @@ inline bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const f
return true;
}
inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type, const flatbuffers::resolver_function_t *resolver) {
inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type, const ::flatbuffers::resolver_function_t *resolver) {
(void)resolver;
switch (type) {
case UnionInNestedNS_TableInNestedNS: {
@@ -357,7 +357,7 @@ inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type,
}
}
inline flatbuffers::Offset<void> UnionInNestedNSUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
inline ::flatbuffers::Offset<void> UnionInNestedNSUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case UnionInNestedNS_TableInNestedNS: {
@@ -392,31 +392,31 @@ inline void UnionInNestedNSUnion::Reset() {
type = UnionInNestedNS_NONE;
}
inline const flatbuffers::TypeTable *UnionInNestedNSTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 }
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[] = {
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
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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
NamespaceA::NamespaceB::EnumInNestedNSTypeTable
};
static const char * const names[] = {
@@ -424,37 +424,37 @@ inline const flatbuffers::TypeTable *EnumInNestedNSTypeTable() {
"B",
"C"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
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 }
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
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 }
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
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
};
return &tt;
}

192
tests/namespace_test/namespace_test2_generated.h
View File

@@ -50,21 +50,21 @@ namespace NamespaceA {
bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
inline const flatbuffers::TypeTable *TableInFirstNSTypeTable();
inline const ::flatbuffers::TypeTable *TableInFirstNSTypeTable();
} // namespace NamespaceA
namespace NamespaceC {
inline const flatbuffers::TypeTable *TableInCTypeTable();
inline const ::flatbuffers::TypeTable *TableInCTypeTable();
} // namespace NamespaceC
namespace NamespaceA {
inline const flatbuffers::TypeTable *SecondTableInATypeTable();
inline const ::flatbuffers::TypeTable *SecondTableInATypeTable();
struct TableInFirstNST : public flatbuffers::NativeTable {
struct TableInFirstNST : public ::flatbuffers::NativeTable {
typedef TableInFirstNS TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceA.TableInFirstNST";
@@ -79,10 +79,10 @@ struct TableInFirstNST : public flatbuffers::NativeTable {
TableInFirstNST &operator=(TableInFirstNST o) FLATBUFFERS_NOEXCEPT;
};
struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableInFirstNST NativeTableType;
typedef TableInFirstNSBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInFirstNSTypeTable();
}
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -126,7 +126,7 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() {
return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_FOO_TABLE) &&
verifier.VerifyTable(foo_table()) &&
@@ -137,9 +137,9 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
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 {
@@ -148,9 +148,9 @@ template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS:
struct TableInFirstNSBuilder {
typedef TableInFirstNS Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_foo_table(flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_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) {
@@ -159,29 +159,29 @@ struct TableInFirstNSBuilder {
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) {
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)
explicit TableInFirstNSBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableInFirstNS> Finish() {
::flatbuffers::Offset<TableInFirstNS> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableInFirstNS>(end);
auto o = ::flatbuffers::Offset<TableInFirstNS>(end);
return o;
}
};
inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table = 0,
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,
::flatbuffers::Offset<void> foo_union = 0,
const NamespaceA::NamespaceB::StructInNestedNS *foo_struct = nullptr) {
TableInFirstNSBuilder builder_(_fbb);
builder_.add_foo_struct(foo_struct);
@@ -192,13 +192,13 @@ inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(
return builder_.Finish();
}
flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::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 {
struct TableInCT : public ::flatbuffers::NativeTable {
typedef TableInC TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceC.TableInCT";
@@ -211,10 +211,10 @@ struct TableInCT : public flatbuffers::NativeTable {
TableInCT &operator=(TableInCT o) FLATBUFFERS_NOEXCEPT;
};
struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableInC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableInCT NativeTableType;
typedef TableInCBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInCTypeTable();
}
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -236,7 +236,7 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
NamespaceA::SecondTableInA *mutable_refer_to_a2() {
return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_REFER_TO_A1) &&
verifier.VerifyTable(refer_to_a1()) &&
@@ -244,49 +244,49 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
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) {
::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) {
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)
explicit TableInCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TableInC> Finish() {
::flatbuffers::Offset<TableInC> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableInC>(end);
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) {
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);
::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 {
struct SecondTableInAT : public ::flatbuffers::NativeTable {
typedef SecondTableInA TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceA.SecondTableInAT";
@@ -298,10 +298,10 @@ struct SecondTableInAT : public flatbuffers::NativeTable {
SecondTableInAT &operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT;
};
struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SecondTableInAT NativeTableType;
typedef SecondTableInABuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return SecondTableInATypeTable();
}
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -316,44 +316,44 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
NamespaceC::TableInC *mutable_refer_to_c() {
return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &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);
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) {
::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)
explicit SecondTableInABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<SecondTableInA> Finish() {
::flatbuffers::Offset<SecondTableInA> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SecondTableInA>(end);
auto o = ::flatbuffers::Offset<SecondTableInA>(end);
return o;
}
};
inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<NamespaceC::TableInC> refer_to_c = 0) {
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);
::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) {
@@ -384,13 +384,13 @@ inline TableInFirstNST &TableInFirstNST::operator=(TableInFirstNST o) FLATBUFFER
return *this;
}
inline TableInFirstNST *TableInFirstNS::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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 = flatbuffers::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST>(_e->UnPack(_resolver)); } } else if (_o->foo_table) { _o->foo_table.reset(); } }
@@ -400,14 +400,14 @@ inline void TableInFirstNS::UnPackTo(TableInFirstNST *_o, const flatbuffers::res
{ auto _e = foo_struct(); if (_e) _o->foo_struct = flatbuffers::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS>(new NamespaceA::NamespaceB::StructInNestedNS(*_e)); }
}
inline flatbuffers::Offset<TableInFirstNS> TableInFirstNS::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TableInFirstNS> TableInFirstNS::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInFirstNS(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(::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;
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;
@@ -449,27 +449,27 @@ inline TableInCT &TableInCT::operator=(TableInCT o) FLATBUFFERS_NOEXCEPT {
return *this;
}
inline TableInCT *TableInC::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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 = flatbuffers::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 = flatbuffers::unique_ptr<NamespaceA::SecondTableInAT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a2) { _o->refer_to_a2.reset(); } }
}
inline flatbuffers::Offset<TableInC> TableInC::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TableInC> TableInC::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInC(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TableInC> CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TableInC> CreateTableInC(::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;
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(
@@ -502,41 +502,41 @@ inline SecondTableInAT &SecondTableInAT::operator=(SecondTableInAT o) FLATBUFFER
return *this;
}
inline SecondTableInAT *SecondTableInA::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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 = flatbuffers::unique_ptr<NamespaceC::TableInCT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_c) { _o->refer_to_c.reset(); } }
}
inline flatbuffers::Offset<SecondTableInA> SecondTableInA::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<SecondTableInA> SecondTableInA::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSecondTableInA(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(::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;
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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
NamespaceA::NamespaceB::TableInNestedNSTypeTable,
NamespaceA::NamespaceB::EnumInNestedNSTypeTable,
NamespaceA::NamespaceB::UnionInNestedNSTypeTable,
@@ -549,8 +549,8 @@ inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() {
"foo_union",
"foo_struct"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
@@ -559,12 +559,12 @@ inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() {
namespace NamespaceC {
inline const flatbuffers::TypeTable *TableInCTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
NamespaceA::TableInFirstNSTypeTable,
NamespaceA::SecondTableInATypeTable
};
@@ -572,8 +572,8 @@ inline const flatbuffers::TypeTable *TableInCTypeTable() {
"refer_to_a1",
"refer_to_a2"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
@@ -582,18 +582,18 @@ inline const flatbuffers::TypeTable *TableInCTypeTable() {
namespace NamespaceA {
inline const flatbuffers::TypeTable *SecondTableInATypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 }
inline const ::flatbuffers::TypeTable *SecondTableInATypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, 0 }
};
static const flatbuffers::TypeFunction type_refs[] = {
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
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

130
tests/native_inline_table_test_generated.h
View File

@@ -26,19 +26,19 @@ 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 *NativeInlineTableTypeTable();
inline const flatbuffers::TypeTable *TestNativeInlineTableTypeTable();
inline const ::flatbuffers::TypeTable *TestNativeInlineTableTypeTable();
struct NativeInlineTableT : public flatbuffers::NativeTable {
struct NativeInlineTableT : public ::flatbuffers::NativeTable {
typedef NativeInlineTable TableType;
int32_t a = 0;
};
struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef NativeInlineTableT NativeTableType;
typedef NativeInlineTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return NativeInlineTableTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -50,112 +50,112 @@ struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_a(int32_t _a = 0) {
return SetField<int32_t>(VT_A, _a, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &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);
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_;
::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)
explicit NativeInlineTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<NativeInlineTable> Finish() {
::flatbuffers::Offset<NativeInlineTable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<NativeInlineTable>(end);
auto o = ::flatbuffers::Offset<NativeInlineTable>(end);
return o;
}
};
inline flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(
flatbuffers::FlatBufferBuilder &_fbb,
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);
::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct TestNativeInlineTableT : public flatbuffers::NativeTable {
struct TestNativeInlineTableT : public ::flatbuffers::NativeTable {
typedef TestNativeInlineTable TableType;
std::vector<NativeInlineTableT> t{};
};
struct TestNativeInlineTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TestNativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TestNativeInlineTableT NativeTableType;
typedef TestNativeInlineTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
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);
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);
::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *mutable_t() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *>(VT_T);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &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);
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) {
::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)
explicit TestNativeInlineTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<TestNativeInlineTable> Finish() {
::flatbuffers::Offset<TestNativeInlineTable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TestNativeInlineTable>(end);
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) {
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;
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);
::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) {
@@ -168,26 +168,26 @@ inline bool operator!=(const NativeInlineTableT &lhs, const NativeInlineTableT &
}
inline NativeInlineTableT *NativeInlineTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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> NativeInlineTable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<NativeInlineTable> NativeInlineTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateNativeInlineTable(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(::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;
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,
@@ -205,57 +205,57 @@ inline bool operator!=(const TestNativeInlineTableT &lhs, const TestNativeInline
}
inline TestNativeInlineTableT *TestNativeInlineTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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] = *flatbuffers::unique_ptr<NativeInlineTableT>(_e->Get(_i)->UnPack(_resolver)); } } else { _o->t.resize(0); } }
{ auto _e = t(); if (_e) { _o->t.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->t[_i] = *flatbuffers::unique_ptr<NativeInlineTableT>(_e->Get(_i)->UnPack(_resolver)); } } else { _o->t.resize(0); } }
}
inline flatbuffers::Offset<TestNativeInlineTable> TestNativeInlineTable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TestNativeInlineTable> TestNativeInlineTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTestNativeInlineTable(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(::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;
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 }
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
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 }
inline const ::flatbuffers::TypeTable *TestNativeInlineTableTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
};
static const flatbuffers::TypeFunction type_refs[] = {
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
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

186
tests/native_type_test_generated.h
View File

@@ -25,11 +25,11 @@ struct ApplicationData;
struct ApplicationDataBuilder;
struct ApplicationDataT;
inline const flatbuffers::TypeTable *Vector3DTypeTable();
inline const ::flatbuffers::TypeTable *Vector3DTypeTable();
inline const flatbuffers::TypeTable *Vector3DAltTypeTable();
inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable();
inline const flatbuffers::TypeTable *ApplicationDataTypeTable();
inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable();
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
private:
@@ -38,7 +38,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
float z_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return Vector3DTypeTable();
}
Vector3D()
@@ -47,27 +47,27 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
z_(0) {
}
Vector3D(float _x, float _y, float _z)
: x_(flatbuffers::EndianScalar(_x)),
y_(flatbuffers::EndianScalar(_y)),
z_(flatbuffers::EndianScalar(_z)) {
: x_(::flatbuffers::EndianScalar(_x)),
y_(::flatbuffers::EndianScalar(_y)),
z_(::flatbuffers::EndianScalar(_z)) {
}
float x() const {
return flatbuffers::EndianScalar(x_);
return ::flatbuffers::EndianScalar(x_);
}
void mutate_x(float _x) {
flatbuffers::WriteScalar(&x_, _x);
::flatbuffers::WriteScalar(&x_, _x);
}
float y() const {
return flatbuffers::EndianScalar(y_);
return ::flatbuffers::EndianScalar(y_);
}
void mutate_y(float _y) {
flatbuffers::WriteScalar(&y_, _y);
::flatbuffers::WriteScalar(&y_, _y);
}
float z() const {
return flatbuffers::EndianScalar(z_);
return ::flatbuffers::EndianScalar(z_);
}
void mutate_z(float _z) {
flatbuffers::WriteScalar(&z_, _z);
::flatbuffers::WriteScalar(&z_, _z);
}
};
FLATBUFFERS_STRUCT_END(Vector3D, 12);
@@ -79,7 +79,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
float c_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return Vector3DAltTypeTable();
}
Vector3DAlt()
@@ -88,60 +88,60 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
c_(0) {
}
Vector3DAlt(float _a, float _b, float _c)
: a_(flatbuffers::EndianScalar(_a)),
b_(flatbuffers::EndianScalar(_b)),
c_(flatbuffers::EndianScalar(_c)) {
: a_(::flatbuffers::EndianScalar(_a)),
b_(::flatbuffers::EndianScalar(_b)),
c_(::flatbuffers::EndianScalar(_c)) {
}
float a() const {
return flatbuffers::EndianScalar(a_);
return ::flatbuffers::EndianScalar(a_);
}
void mutate_a(float _a) {
flatbuffers::WriteScalar(&a_, _a);
::flatbuffers::WriteScalar(&a_, _a);
}
float b() const {
return flatbuffers::EndianScalar(b_);
return ::flatbuffers::EndianScalar(b_);
}
void mutate_b(float _b) {
flatbuffers::WriteScalar(&b_, _b);
::flatbuffers::WriteScalar(&b_, _b);
}
float c() const {
return flatbuffers::EndianScalar(c_);
return ::flatbuffers::EndianScalar(c_);
}
void mutate_c(float _c) {
flatbuffers::WriteScalar(&c_, _c);
::flatbuffers::WriteScalar(&c_, _c);
}
};
FLATBUFFERS_STRUCT_END(Vector3DAlt, 12);
struct ApplicationDataT : public flatbuffers::NativeTable {
struct ApplicationDataT : public ::flatbuffers::NativeTable {
typedef ApplicationData TableType;
std::vector<Native::Vector3D> vectors{};
std::vector<Native::Vector3D> vectors_alt{};
};
struct ApplicationData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ApplicationDataT NativeTableType;
typedef ApplicationDataBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ApplicationDataTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VECTORS = 4,
VT_VECTORS_ALT = 6
};
const flatbuffers::Vector<const Geometry::Vector3D *> *vectors() const {
return GetPointer<const flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS);
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);
::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);
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);
::flatbuffers::Vector<const Geometry::Vector3DAlt *> *mutable_vectors_alt() {
return GetPointer<::flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_VECTORS) &&
verifier.VerifyVector(vectors()) &&
@@ -149,44 +149,44 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(vectors_alt()) &&
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);
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) {
::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) {
void add_vectors_alt(::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt) {
fbb_.AddOffset(ApplicationData::VT_VECTORS_ALT, vectors_alt);
}
explicit ApplicationDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit ApplicationDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<ApplicationData> Finish() {
::flatbuffers::Offset<ApplicationData> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ApplicationData>(end);
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) {
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) {
ApplicationDataBuilder builder_(_fbb);
builder_.add_vectors_alt(vectors_alt);
builder_.add_vectors(vectors);
return builder_.Finish();
}
inline flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<Geometry::Vector3D> *vectors = nullptr,
const std::vector<Geometry::Vector3DAlt> *vectors_alt = nullptr) {
auto vectors__ = vectors ? _fbb.CreateVectorOfStructs<Geometry::Vector3D>(*vectors) : 0;
@@ -197,42 +197,42 @@ inline flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
vectors_alt__);
}
flatbuffers::Offset<ApplicationData> CreateApplicationData(flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline ApplicationDataT *ApplicationData::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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 = 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); } }
}
inline flatbuffers::Offset<ApplicationData> ApplicationData::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<ApplicationData> ApplicationData::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateApplicationData(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ApplicationData> CreateApplicationData(flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData(::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;
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 _vectors_alt = _o->vectors_alt.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3DAlt, Native::Vector3D>(_o->vectors_alt, ::flatbuffers::PackVector3DAlt) : 0;
return Geometry::CreateApplicationData(
_fbb,
_vectors,
_vectors_alt);
}
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 }
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[] = {
@@ -240,17 +240,17 @@ inline const flatbuffers::TypeTable *Vector3DTypeTable() {
"y",
"z"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
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 }
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[] = {
@@ -258,18 +258,18 @@ inline const flatbuffers::TypeTable *Vector3DAltTypeTable() {
"b",
"c"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *ApplicationDataTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 1 }
inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 1, 0 },
{ ::flatbuffers::ET_SEQUENCE, 1, 1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
Geometry::Vector3DTypeTable,
Geometry::Vector3DAltTypeTable
};
@@ -277,59 +277,59 @@ inline const flatbuffers::TypeTable *ApplicationDataTypeTable() {
"vectors",
"vectors_alt"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const Geometry::ApplicationData *GetApplicationData(const void *buf) {
return flatbuffers::GetRoot<Geometry::ApplicationData>(buf);
return ::flatbuffers::GetRoot<Geometry::ApplicationData>(buf);
}
inline const Geometry::ApplicationData *GetSizePrefixedApplicationData(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Geometry::ApplicationData>(buf);
return ::flatbuffers::GetSizePrefixedRoot<Geometry::ApplicationData>(buf);
}
inline ApplicationData *GetMutableApplicationData(void *buf) {
return flatbuffers::GetMutableRoot<ApplicationData>(buf);
return ::flatbuffers::GetMutableRoot<ApplicationData>(buf);
}
inline Geometry::ApplicationData *GetMutableSizePrefixedApplicationData(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf);
}
inline bool VerifyApplicationDataBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Geometry::ApplicationData>(nullptr);
}
inline bool VerifySizePrefixedApplicationDataBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr);
}
inline void FinishApplicationDataBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Geometry::ApplicationData> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Geometry::ApplicationData> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedApplicationDataBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Geometry::ApplicationData> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Geometry::ApplicationData> root) {
fbb.FinishSizePrefixed(root);
}
inline flatbuffers::unique_ptr<Geometry::ApplicationDataT> UnPackApplicationData(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<Geometry::ApplicationDataT>(GetApplicationData(buf)->UnPack(res));
}
inline flatbuffers::unique_ptr<Geometry::ApplicationDataT> UnPackSizePrefixedApplicationData(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<Geometry::ApplicationDataT>(GetSizePrefixedApplicationData(buf)->UnPack(res));
}

242
tests/optional_scalars_generated.h
View File

@@ -22,7 +22,7 @@ struct ScalarStuffT;
bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs);
bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs);
inline const flatbuffers::TypeTable *ScalarStuffTypeTable();
inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable();
enum OptionalByte : int8_t {
OptionalByte_None = 0,
@@ -52,55 +52,55 @@ inline const char * const *EnumNamesOptionalByte() {
}
inline const char *EnumNameOptionalByte(OptionalByte e) {
if (flatbuffers::IsOutRange(e, OptionalByte_None, OptionalByte_Two)) return "";
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 {
struct ScalarStuffT : public ::flatbuffers::NativeTable {
typedef ScalarStuff TableType;
int8_t just_i8 = 0;
flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt;
::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;
::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;
::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;
::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;
::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;
::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;
::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;
::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;
::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt;
float default_f32 = 42.0f;
double just_f64 = 0.0;
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt;
::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt;
double default_f64 = 42.0;
bool just_bool = false;
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt;
::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;
::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 {
struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ScalarStuffT NativeTableType;
typedef ScalarStuffBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ScalarStuffTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -147,7 +147,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int8_t> maybe_i8() const {
return GetOptional<int8_t, int8_t>(VT_MAYBE_I8);
}
bool mutate_maybe_i8(int8_t _maybe_i8) {
@@ -165,7 +165,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint8_t> maybe_u8() const {
return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8);
}
bool mutate_maybe_u8(uint8_t _maybe_u8) {
@@ -183,7 +183,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int16_t> maybe_i16() const {
return GetOptional<int16_t, int16_t>(VT_MAYBE_I16);
}
bool mutate_maybe_i16(int16_t _maybe_i16) {
@@ -201,7 +201,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint16_t> maybe_u16() const {
return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16);
}
bool mutate_maybe_u16(uint16_t _maybe_u16) {
@@ -219,7 +219,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int32_t> maybe_i32() const {
return GetOptional<int32_t, int32_t>(VT_MAYBE_I32);
}
bool mutate_maybe_i32(int32_t _maybe_i32) {
@@ -237,7 +237,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint32_t> maybe_u32() const {
return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32);
}
bool mutate_maybe_u32(uint32_t _maybe_u32) {
@@ -255,7 +255,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<int64_t> maybe_i64() const {
return GetOptional<int64_t, int64_t>(VT_MAYBE_I64);
}
bool mutate_maybe_i64(int64_t _maybe_i64) {
@@ -273,7 +273,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<uint64_t> maybe_u64() const {
return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64);
}
bool mutate_maybe_u64(uint64_t _maybe_u64) {
@@ -291,7 +291,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<float> maybe_f32() const {
return GetOptional<float, float>(VT_MAYBE_F32);
}
bool mutate_maybe_f32(float _maybe_f32) {
@@ -309,7 +309,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<double> maybe_f64() const {
return GetOptional<double, double>(VT_MAYBE_F64);
}
bool mutate_maybe_f64(double _maybe_f64) {
@@ -327,7 +327,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::flatbuffers::Optional<bool> maybe_bool() const {
return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL);
}
bool mutate_maybe_bool(bool _maybe_bool) {
@@ -345,7 +345,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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 {
::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) {
@@ -357,7 +357,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@@ -397,15 +397,15 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
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_;
::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);
}
@@ -514,54 +514,54 @@ struct ScalarStuffBuilder {
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)
explicit ScalarStuffBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<ScalarStuff> Finish() {
::flatbuffers::Offset<ScalarStuff> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ScalarStuff>(end);
auto o = ::flatbuffers::Offset<ScalarStuff>(end);
return o;
}
};
inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
::flatbuffers::FlatBufferBuilder &_fbb,
int8_t just_i8 = 0,
flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt,
::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,
::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,
::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,
::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,
::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,
::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,
::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,
::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,
::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt,
float default_f32 = 42.0f,
double just_f64 = 0.0,
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt,
::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt,
double default_f64 = 42.0,
bool just_bool = false,
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt,
::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,
::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);
@@ -603,7 +603,7 @@ inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
return builder_.Finish();
}
flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::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) {
@@ -651,13 +651,13 @@ inline bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs) {
}
inline ScalarStuffT *ScalarStuff::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
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 {
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; }
@@ -698,14 +698,14 @@ inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_
{ 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) {
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) {
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;
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;
@@ -782,13 +782,13 @@ inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBuffe
_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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
optional_scalars::OptionalByteTypeTable
};
static const char * const names[] = {
@@ -796,52 +796,52 @@ inline const flatbuffers::TypeTable *OptionalByteTypeTable() {
"One",
"Two"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
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 }
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[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
optional_scalars::OptionalByteTypeTable
};
static const char * const names[] = {
@@ -882,26 +882,26 @@ inline const flatbuffers::TypeTable *ScalarStuffTypeTable() {
"maybe_enum",
"default_enum"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names
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);
return ::flatbuffers::GetRoot<optional_scalars::ScalarStuff>(buf);
}
inline const optional_scalars::ScalarStuff *GetSizePrefixedScalarStuff(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
return ::flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
}
inline ScalarStuff *GetMutableScalarStuff(void *buf) {
return flatbuffers::GetMutableRoot<ScalarStuff>(buf);
return ::flatbuffers::GetMutableRoot<ScalarStuff>(buf);
}
inline optional_scalars::ScalarStuff *GetMutableSizePrefixedScalarStuff(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
}
inline const char *ScalarStuffIdentifier() {
@@ -909,22 +909,22 @@ inline const char *ScalarStuffIdentifier() {
}
inline bool ScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier());
}
inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier(), true);
}
inline bool VerifyScalarStuffBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
}
inline bool VerifySizePrefixedScalarStuffBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
}
@@ -933,26 +933,26 @@ inline const char *ScalarStuffExtension() {
}
inline void FinishScalarStuffBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
::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) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
fbb.FinishSizePrefixed(root, ScalarStuffIdentifier());
}
inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetScalarStuff(buf)->UnPack(res));
}
inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res));
}

392
tests/union_vector/union_vector_generated.h
View File

@@ -44,17 +44,17 @@ bool operator!=(const HandFanT &lhs, const HandFanT &rhs);
bool operator==(const MovieT &lhs, const MovieT &rhs);
bool operator!=(const MovieT &lhs, const MovieT &rhs);
inline const flatbuffers::TypeTable *AttackerTypeTable();
inline const ::flatbuffers::TypeTable *AttackerTypeTable();
inline const flatbuffers::TypeTable *RapunzelTypeTable();
inline const ::flatbuffers::TypeTable *RapunzelTypeTable();
inline const flatbuffers::TypeTable *BookReaderTypeTable();
inline const ::flatbuffers::TypeTable *BookReaderTypeTable();
inline const flatbuffers::TypeTable *FallingTubTypeTable();
inline const ::flatbuffers::TypeTable *FallingTubTypeTable();
inline const flatbuffers::TypeTable *HandFanTypeTable();
inline const ::flatbuffers::TypeTable *HandFanTypeTable();
inline const flatbuffers::TypeTable *MovieTypeTable();
inline const ::flatbuffers::TypeTable *MovieTypeTable();
enum Character : uint8_t {
Character_NONE = 0,
@@ -96,7 +96,7 @@ inline const char * const *EnumNamesCharacter() {
}
inline const char *EnumNameCharacter(Character e) {
if (flatbuffers::IsOutRange(e, Character_NONE, Character_Unused)) return "";
if (::flatbuffers::IsOutRange(e, Character_NONE, Character_Unused)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesCharacter()[index];
}
@@ -118,8 +118,8 @@ struct CharacterUnion {
void Reset();
static void *UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
static void *UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver);
::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
AttackerT *AsMuLan() {
return type == Character_MuLan ?
@@ -212,8 +212,8 @@ inline bool operator!=(const CharacterUnion &lhs, const CharacterUnion &rhs) {
return !(lhs == rhs);
}
bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type);
bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum Gadget : uint8_t {
Gadget_NONE = 0,
@@ -243,7 +243,7 @@ inline const char * const *EnumNamesGadget() {
}
inline const char *EnumNameGadget(Gadget e) {
if (flatbuffers::IsOutRange(e, Gadget_NONE, Gadget_HandFan)) return "";
if (::flatbuffers::IsOutRange(e, Gadget_NONE, Gadget_HandFan)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesGadget()[index];
}
@@ -299,8 +299,8 @@ struct GadgetUnion {
}
}
static void *UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
static void *UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver);
::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
FallingTub *AsFallingTub() {
return type == Gadget_FallingTub ?
@@ -345,28 +345,28 @@ inline bool operator!=(const GadgetUnion &lhs, const GadgetUnion &rhs) {
return !(lhs == rhs);
}
bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type);
bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
private:
int32_t hair_length_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return RapunzelTypeTable();
}
Rapunzel()
: hair_length_(0) {
}
Rapunzel(int32_t _hair_length)
: hair_length_(flatbuffers::EndianScalar(_hair_length)) {
: hair_length_(::flatbuffers::EndianScalar(_hair_length)) {
}
int32_t hair_length() const {
return flatbuffers::EndianScalar(hair_length_);
return ::flatbuffers::EndianScalar(hair_length_);
}
void mutate_hair_length(int32_t _hair_length) {
flatbuffers::WriteScalar(&hair_length_, _hair_length);
::flatbuffers::WriteScalar(&hair_length_, _hair_length);
}
};
FLATBUFFERS_STRUCT_END(Rapunzel, 4);
@@ -386,20 +386,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
int32_t books_read_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BookReaderTypeTable();
}
BookReader()
: books_read_(0) {
}
BookReader(int32_t _books_read)
: books_read_(flatbuffers::EndianScalar(_books_read)) {
: books_read_(::flatbuffers::EndianScalar(_books_read)) {
}
int32_t books_read() const {
return flatbuffers::EndianScalar(books_read_);
return ::flatbuffers::EndianScalar(books_read_);
}
void mutate_books_read(int32_t _books_read) {
flatbuffers::WriteScalar(&books_read_, _books_read);
::flatbuffers::WriteScalar(&books_read_, _books_read);
}
};
FLATBUFFERS_STRUCT_END(BookReader, 4);
@@ -419,20 +419,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS {
int32_t weight_;
public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return FallingTubTypeTable();
}
FallingTub()
: weight_(0) {
}
FallingTub(int32_t _weight)
: weight_(flatbuffers::EndianScalar(_weight)) {
: weight_(::flatbuffers::EndianScalar(_weight)) {
}
int32_t weight() const {
return flatbuffers::EndianScalar(weight_);
return ::flatbuffers::EndianScalar(weight_);
}
void mutate_weight(int32_t _weight) {
flatbuffers::WriteScalar(&weight_, _weight);
::flatbuffers::WriteScalar(&weight_, _weight);
}
};
FLATBUFFERS_STRUCT_END(FallingTub, 4);
@@ -447,15 +447,15 @@ inline bool operator!=(const FallingTub &lhs, const FallingTub &rhs) {
}
struct AttackerT : public flatbuffers::NativeTable {
struct AttackerT : public ::flatbuffers::NativeTable {
typedef Attacker TableType;
int32_t sword_attack_damage = 0;
};
struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef AttackerT NativeTableType;
typedef AttackerBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return AttackerTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -467,53 +467,53 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_sword_attack_damage(int32_t _sword_attack_damage = 0) {
return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
verifier.EndTable();
}
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Attacker> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
AttackerT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<Attacker> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct AttackerBuilder {
typedef Attacker Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_sword_attack_damage(int32_t sword_attack_damage) {
fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0);
}
explicit AttackerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit AttackerBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Attacker> Finish() {
::flatbuffers::Offset<Attacker> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Attacker>(end);
auto o = ::flatbuffers::Offset<Attacker>(end);
return o;
}
};
inline flatbuffers::Offset<Attacker> CreateAttacker(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<Attacker> CreateAttacker(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t sword_attack_damage = 0) {
AttackerBuilder builder_(_fbb);
builder_.add_sword_attack_damage(sword_attack_damage);
return builder_.Finish();
}
flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct HandFanT : public flatbuffers::NativeTable {
struct HandFanT : public ::flatbuffers::NativeTable {
typedef HandFan TableType;
int32_t length = 0;
};
struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef HandFanT NativeTableType;
typedef HandFanBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return HandFanTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -525,54 +525,54 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_length(int32_t _length = 0) {
return SetField<int32_t>(VT_LENGTH, _length, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
verifier.EndTable();
}
HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<HandFan> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
HandFanT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<HandFan> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct HandFanBuilder {
typedef HandFan Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_length(int32_t length) {
fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0);
}
explicit HandFanBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit HandFanBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<HandFan> Finish() {
::flatbuffers::Offset<HandFan> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<HandFan>(end);
auto o = ::flatbuffers::Offset<HandFan>(end);
return o;
}
};
inline flatbuffers::Offset<HandFan> CreateHandFan(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<HandFan> CreateHandFan(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t length = 0) {
HandFanBuilder builder_(_fbb);
builder_.add_length(length);
return builder_.Finish();
}
flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MovieT : public flatbuffers::NativeTable {
struct MovieT : public ::flatbuffers::NativeTable {
typedef Movie TableType;
CharacterUnion main_character{};
std::vector<CharacterUnion> characters{};
};
struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MovieT NativeTableType;
typedef MovieBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MovieTypeTable();
}
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -599,28 +599,28 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const BookReader *main_character_as_BookFan() const {
return main_character_type() == Character_BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
}
const flatbuffers::String *main_character_as_Other() const {
return main_character_type() == Character_Other ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
const ::flatbuffers::String *main_character_as_Other() const {
return main_character_type() == Character_Other ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
}
const flatbuffers::String *main_character_as_Unused() const {
return main_character_type() == Character_Unused ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
const ::flatbuffers::String *main_character_as_Unused() const {
return main_character_type() == Character_Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
}
void *mutable_main_character() {
return GetPointer<void *>(VT_MAIN_CHARACTER);
}
const flatbuffers::Vector<uint8_t> *characters_type() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
const ::flatbuffers::Vector<uint8_t> *characters_type() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
}
flatbuffers::Vector<uint8_t> *mutable_characters_type() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
::flatbuffers::Vector<uint8_t> *mutable_characters_type() {
return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
}
const flatbuffers::Vector<flatbuffers::Offset<void>> *characters() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *characters() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
flatbuffers::Vector<flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -632,44 +632,44 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyCharacterVector(verifier, characters(), characters_type()) &&
verifier.EndTable();
}
MovieT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Movie> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MovieBuilder {
typedef Movie Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_main_character_type(Character main_character_type) {
fbb_.AddElement<uint8_t>(Movie::VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(main_character_type), 0);
}
void add_main_character(flatbuffers::Offset<void> main_character) {
void add_main_character(::flatbuffers::Offset<void> main_character) {
fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character);
}
void add_characters_type(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type) {
void add_characters_type(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type) {
fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, characters_type);
}
void add_characters(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters) {
void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
}
explicit MovieBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Movie> Finish() {
::flatbuffers::Offset<Movie> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Movie>(end);
auto o = ::flatbuffers::Offset<Movie>(end);
return o;
}
};
inline flatbuffers::Offset<Movie> CreateMovie(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<Movie> CreateMovie(
::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character_NONE,
flatbuffers::Offset<void> main_character = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters = 0) {
::flatbuffers::Offset<void> main_character = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
MovieBuilder builder_(_fbb);
builder_.add_characters(characters);
builder_.add_characters_type(characters_type);
@@ -678,14 +678,14 @@ inline flatbuffers::Offset<Movie> CreateMovie(
return builder_.Finish();
}
inline flatbuffers::Offset<Movie> CreateMovieDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character_NONE,
flatbuffers::Offset<void> main_character = 0,
::flatbuffers::Offset<void> main_character = 0,
const std::vector<uint8_t> *characters_type = nullptr,
const std::vector<flatbuffers::Offset<void>> *characters = nullptr) {
const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) {
auto characters_type__ = characters_type ? _fbb.CreateVector<uint8_t>(*characters_type) : 0;
auto characters__ = characters ? _fbb.CreateVector<flatbuffers::Offset<void>>(*characters) : 0;
auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
return CreateMovie(
_fbb,
main_character_type,
@@ -694,7 +694,7 @@ inline flatbuffers::Offset<Movie> CreateMovieDirect(
characters__);
}
flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const AttackerT &lhs, const AttackerT &rhs) {
@@ -707,26 +707,26 @@ inline bool operator!=(const AttackerT &lhs, const AttackerT &rhs) {
}
inline AttackerT *Attacker::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline AttackerT *Attacker::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<AttackerT>(new AttackerT());
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Attacker::UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void Attacker::UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; }
}
inline flatbuffers::Offset<Attacker> Attacker::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Attacker> Attacker::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateAttacker(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _sword_attack_damage = _o->sword_attack_damage;
return CreateAttacker(
_fbb,
@@ -744,26 +744,26 @@ inline bool operator!=(const HandFanT &lhs, const HandFanT &rhs) {
}
inline HandFanT *HandFan::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline HandFanT *HandFan::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<HandFanT>(new HandFanT());
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void HandFan::UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void HandFan::UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = length(); _o->length = _e; }
}
inline flatbuffers::Offset<HandFan> HandFan::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<HandFan> HandFan::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateHandFan(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _length = _o->length;
return CreateHandFan(
_fbb,
@@ -782,33 +782,33 @@ inline bool operator!=(const MovieT &lhs, const MovieT &rhs) {
}
inline MovieT *Movie::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
inline MovieT *Movie::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<MovieT>(new MovieT());
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Movie::UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver) const {
inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = main_character_type(); _o->main_character.type = _e; }
{ auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
}
inline flatbuffers::Offset<Movie> Movie::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMovie(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _main_character_type = _o->main_character.type;
auto _main_character = _o->main_character.Pack(_fbb);
auto _characters_type = _o->characters.size() ? _fbb.CreateVector<uint8_t>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return static_cast<uint8_t>(__va->__o->characters[i].type); }, &_va) : 0;
auto _characters = _o->characters.size() ? _fbb.CreateVector<flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
return CreateMovie(
_fbb,
_main_character_type,
@@ -817,7 +817,7 @@ inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_f
_characters);
}
inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type) {
inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type) {
switch (type) {
case Character_NONE: {
return true;
@@ -836,21 +836,21 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character_Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr);
}
case Character_Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr);
}
default: return true;
}
}
inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
inline bool VerifyCharacterVector(::flatbuffers::Verifier &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) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyCharacter(
verifier, values->Get(i), types->GetEnum<Character>(i))) {
return false;
@@ -859,7 +859,7 @@ inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuf
return true;
}
inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver) {
inline void *CharacterUnion::UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver) {
(void)resolver;
switch (type) {
case Character_MuLan: {
@@ -879,18 +879,18 @@ inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatb
return new BookReader(*ptr);
}
case Character_Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return new std::string(ptr->c_str(), ptr->size());
}
case Character_Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return new std::string(ptr->c_str(), ptr->size());
}
default: return nullptr;
}
}
inline flatbuffers::Offset<void> CharacterUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
inline ::flatbuffers::Offset<void> CharacterUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case Character_MuLan: {
@@ -990,7 +990,7 @@ inline void CharacterUnion::Reset() {
type = Character_NONE;
}
inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
switch (type) {
case Gadget_NONE: {
return true;
@@ -1006,10 +1006,10 @@ inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadge
}
}
inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
inline bool VerifyGadgetVector(::flatbuffers::Verifier &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) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyGadget(
verifier, values->Get(i), types->GetEnum<Gadget>(i))) {
return false;
@@ -1018,7 +1018,7 @@ inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffer
return true;
}
inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver) {
inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver) {
(void)resolver;
switch (type) {
case Gadget_FallingTub: {
@@ -1033,7 +1033,7 @@ inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const flatbuffers
}
}
inline flatbuffers::Offset<void> GadgetUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
inline ::flatbuffers::Offset<void> GadgetUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case Gadget_FallingTub: {
@@ -1081,17 +1081,17 @@ inline void GadgetUnion::Reset() {
type = Gadget_NONE;
}
inline const flatbuffers::TypeTable *CharacterTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 },
{ flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_STRING, 0, -1 }
inline const ::flatbuffers::TypeTable *CharacterTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ ::flatbuffers::ET_STRING, 0, -1 },
{ ::flatbuffers::ET_STRING, 0, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
AttackerTypeTable,
RapunzelTypeTable,
BookReaderTypeTable
@@ -1105,19 +1105,19 @@ inline const flatbuffers::TypeTable *CharacterTypeTable() {
"Other",
"Unused"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *GadgetTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 }
inline const ::flatbuffers::TypeTable *GadgetTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
FallingTubTypeTable,
HandFanTypeTable
};
@@ -1126,88 +1126,88 @@ inline const flatbuffers::TypeTable *GadgetTypeTable() {
"FallingTub",
"HandFan"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *AttackerTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *AttackerTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const char * const names[] = {
"sword_attack_damage"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *RapunzelTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *RapunzelTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const int64_t values[] = { 0, 4 };
static const char * const names[] = {
"hair_length"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *BookReaderTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *BookReaderTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const int64_t values[] = { 0, 4 };
static const char * const names[] = {
"books_read"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *FallingTubTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *FallingTubTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const int64_t values[] = { 0, 4 };
static const char * const names[] = {
"weight"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
};
return &tt;
}
inline const flatbuffers::TypeTable *HandFanTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }
inline const ::flatbuffers::TypeTable *HandFanTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_INT, 0, -1 }
};
static const char * const names[] = {
"length"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
};
return &tt;
}
inline const flatbuffers::TypeTable *MovieTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UTYPE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_UTYPE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 0 }
inline const ::flatbuffers::TypeTable *MovieTypeTable() {
static const ::flatbuffers::TypeCode type_codes[] = {
{ ::flatbuffers::ET_UTYPE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_UTYPE, 1, 0 },
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
};
static const flatbuffers::TypeFunction type_refs[] = {
static const ::flatbuffers::TypeFunction type_refs[] = {
CharacterTypeTable
};
static const char * const names[] = {
@@ -1216,26 +1216,26 @@ inline const flatbuffers::TypeTable *MovieTypeTable() {
"characters_type",
"characters"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}
inline const Movie *GetMovie(const void *buf) {
return flatbuffers::GetRoot<Movie>(buf);
return ::flatbuffers::GetRoot<Movie>(buf);
}
inline const Movie *GetSizePrefixedMovie(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Movie>(buf);
return ::flatbuffers::GetSizePrefixedRoot<Movie>(buf);
}
inline Movie *GetMutableMovie(void *buf) {
return flatbuffers::GetMutableRoot<Movie>(buf);
return ::flatbuffers::GetMutableRoot<Movie>(buf);
}
inline Movie *GetMutableSizePrefixedMovie(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
return ::flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
}
inline const char *MovieIdentifier() {
@@ -1243,46 +1243,46 @@ inline const char *MovieIdentifier() {
}
inline bool MovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier());
}
inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier(), true);
}
inline bool VerifyMovieBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Movie>(MovieIdentifier());
}
inline bool VerifySizePrefixedMovieBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
}
inline void FinishMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Movie> root) {
fbb.Finish(root, MovieIdentifier());
}
inline void FinishSizePrefixedMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Movie> root) {
fbb.FinishSizePrefixed(root, MovieIdentifier());
}
inline flatbuffers::unique_ptr<MovieT> UnPackMovie(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
}
inline flatbuffers::unique_ptr<MovieT> UnPackSizePrefixedMovie(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res));
}