BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-07 13:53:38 +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));
}