mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-02 04:04:19 +00:00
6b271b7ecb
For example:
include/flatbuffers/reflection.h:365:8: error: definition of implicit copy
constructor for 'pointer_inside_vector<flatbuffers::Table, unsigned char>'
is deprecated because it has a user-declared copy assignment operator
[-Werror,-Wdeprecated-copy]
void operator=(const pointer_inside_vector &piv);
^
It's unclear why the old code wanted to declare a public `operator=`
without defining it; that just seems like a misunderstanding of the C++03 idiom
for deleting a member function. And anyway, we don't *want* to delete the
assignment operator; these are polymorphic types that do not follow value
semantics and nobody should ever be trying to copy them. So the simplest fix
is just to go back to the Rule of Zero: remove the declaration of `operator=`
and let the compiler do what it wanted to do originally anyway.
"The best code is no code."
Also, update the generated .h files.
Fixes #5649.
575 lines
16 KiB
C++
575 lines
16 KiB
C++
// automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
|
|
#ifndef FLATBUFFERS_GENERATED_EVOLUTIONV2_EVOLUTION_V2_H_
|
|
#define FLATBUFFERS_GENERATED_EVOLUTIONV2_EVOLUTION_V2_H_
|
|
|
|
#include "flatbuffers/flatbuffers.h"
|
|
|
|
namespace Evolution {
|
|
namespace V2 {
|
|
|
|
struct TableA;
|
|
|
|
struct TableB;
|
|
|
|
struct TableC;
|
|
|
|
struct Struct;
|
|
|
|
struct Root;
|
|
|
|
enum class Enum : int8_t {
|
|
King = 0,
|
|
Queen = 1,
|
|
Rook = 2,
|
|
Bishop = 3,
|
|
MIN = King,
|
|
MAX = Bishop
|
|
};
|
|
|
|
inline const Enum (&EnumValuesEnum())[4] {
|
|
static const Enum values[] = {
|
|
Enum::King,
|
|
Enum::Queen,
|
|
Enum::Rook,
|
|
Enum::Bishop
|
|
};
|
|
return values;
|
|
}
|
|
|
|
inline const char * const *EnumNamesEnum() {
|
|
static const char * const names[5] = {
|
|
"King",
|
|
"Queen",
|
|
"Rook",
|
|
"Bishop",
|
|
nullptr
|
|
};
|
|
return names;
|
|
}
|
|
|
|
inline const char *EnumNameEnum(Enum e) {
|
|
if (e < Enum::King || e > Enum::Bishop) return "";
|
|
const size_t index = static_cast<size_t>(e);
|
|
return EnumNamesEnum()[index];
|
|
}
|
|
|
|
enum class Union : uint8_t {
|
|
NONE = 0,
|
|
TableA = 1,
|
|
TableB = 2,
|
|
TableC = 3,
|
|
MIN = NONE,
|
|
MAX = TableC
|
|
};
|
|
|
|
inline const Union (&EnumValuesUnion())[4] {
|
|
static const Union values[] = {
|
|
Union::NONE,
|
|
Union::TableA,
|
|
Union::TableB,
|
|
Union::TableC
|
|
};
|
|
return values;
|
|
}
|
|
|
|
inline const char * const *EnumNamesUnion() {
|
|
static const char * const names[5] = {
|
|
"NONE",
|
|
"TableA",
|
|
"TableB",
|
|
"TableC",
|
|
nullptr
|
|
};
|
|
return names;
|
|
}
|
|
|
|
inline const char *EnumNameUnion(Union e) {
|
|
if (e < Union::NONE || e > Union::TableC) return "";
|
|
const size_t index = static_cast<size_t>(e);
|
|
return EnumNamesUnion()[index];
|
|
}
|
|
|
|
template<typename T> struct UnionTraits {
|
|
static const Union enum_value = Union::NONE;
|
|
};
|
|
|
|
template<> struct UnionTraits<Evolution::V2::TableA> {
|
|
static const Union enum_value = Union::TableA;
|
|
};
|
|
|
|
template<> struct UnionTraits<Evolution::V2::TableB> {
|
|
static const Union enum_value = Union::TableB;
|
|
};
|
|
|
|
template<> struct UnionTraits<Evolution::V2::TableC> {
|
|
static const Union enum_value = Union::TableC;
|
|
};
|
|
|
|
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<uint8_t> *types);
|
|
|
|
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
|
|
private:
|
|
int32_t a_;
|
|
int32_t padding0__;
|
|
double b_;
|
|
|
|
public:
|
|
Struct() {
|
|
memset(static_cast<void *>(this), 0, sizeof(Struct));
|
|
}
|
|
Struct(int32_t _a, double _b)
|
|
: a_(flatbuffers::EndianScalar(_a)),
|
|
padding0__(0),
|
|
b_(flatbuffers::EndianScalar(_b)) {
|
|
(void)padding0__;
|
|
}
|
|
int32_t a() const {
|
|
return flatbuffers::EndianScalar(a_);
|
|
}
|
|
double b() const {
|
|
return flatbuffers::EndianScalar(b_);
|
|
}
|
|
};
|
|
FLATBUFFERS_STRUCT_END(Struct, 16);
|
|
|
|
struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_A = 4,
|
|
VT_B = 6,
|
|
VT_C = 8
|
|
};
|
|
float a() const {
|
|
return GetField<float>(VT_A, 0.0f);
|
|
}
|
|
int32_t b() const {
|
|
return GetField<int32_t>(VT_B, 0);
|
|
}
|
|
const flatbuffers::String *c() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_C);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<float>(verifier, VT_A) &&
|
|
VerifyField<int32_t>(verifier, VT_B) &&
|
|
VerifyOffset(verifier, VT_C) &&
|
|
verifier.VerifyString(c()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TableABuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_a(float a) {
|
|
fbb_.AddElement<float>(TableA::VT_A, a, 0.0f);
|
|
}
|
|
void add_b(int32_t b) {
|
|
fbb_.AddElement<int32_t>(TableA::VT_B, b, 0);
|
|
}
|
|
void add_c(flatbuffers::Offset<flatbuffers::String> c) {
|
|
fbb_.AddOffset(TableA::VT_C, c);
|
|
}
|
|
explicit TableABuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<TableA> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<TableA>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<TableA> CreateTableA(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
float a = 0.0f,
|
|
int32_t b = 0,
|
|
flatbuffers::Offset<flatbuffers::String> c = 0) {
|
|
TableABuilder builder_(_fbb);
|
|
builder_.add_c(c);
|
|
builder_.add_b(b);
|
|
builder_.add_a(a);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<TableA> CreateTableADirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
float a = 0.0f,
|
|
int32_t b = 0,
|
|
const char *c = nullptr) {
|
|
auto c__ = c ? _fbb.CreateString(c) : 0;
|
|
return Evolution::V2::CreateTableA(
|
|
_fbb,
|
|
a,
|
|
b,
|
|
c__);
|
|
}
|
|
|
|
struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_A = 4
|
|
};
|
|
int32_t a() const {
|
|
return GetField<int32_t>(VT_A, 0);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<int32_t>(verifier, VT_A) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TableBBuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_a(int32_t a) {
|
|
fbb_.AddElement<int32_t>(TableB::VT_A, a, 0);
|
|
}
|
|
explicit TableBBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<TableB> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<TableB>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<TableB> CreateTableB(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
int32_t a = 0) {
|
|
TableBBuilder builder_(_fbb);
|
|
builder_.add_a(a);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct TableC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_A = 4,
|
|
VT_B = 6
|
|
};
|
|
double a() const {
|
|
return GetField<double>(VT_A, 0.0);
|
|
}
|
|
const flatbuffers::String *b() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_B);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<double>(verifier, VT_A) &&
|
|
VerifyOffset(verifier, VT_B) &&
|
|
verifier.VerifyString(b()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TableCBuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_a(double a) {
|
|
fbb_.AddElement<double>(TableC::VT_A, a, 0.0);
|
|
}
|
|
void add_b(flatbuffers::Offset<flatbuffers::String> b) {
|
|
fbb_.AddOffset(TableC::VT_B, b);
|
|
}
|
|
explicit TableCBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<TableC> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<TableC>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<TableC> CreateTableC(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
double a = 0.0,
|
|
flatbuffers::Offset<flatbuffers::String> b = 0) {
|
|
TableCBuilder builder_(_fbb);
|
|
builder_.add_a(a);
|
|
builder_.add_b(b);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<TableC> CreateTableCDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
double a = 0.0,
|
|
const char *b = nullptr) {
|
|
auto b__ = b ? _fbb.CreateString(b) : 0;
|
|
return Evolution::V2::CreateTableC(
|
|
_fbb,
|
|
a,
|
|
b__);
|
|
}
|
|
|
|
struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_B = 6,
|
|
VT_C_TYPE = 8,
|
|
VT_C = 10,
|
|
VT_D = 12,
|
|
VT_E = 14,
|
|
VT_FF = 16,
|
|
VT_G = 18,
|
|
VT_H = 20,
|
|
VT_I = 22,
|
|
VT_J = 24,
|
|
VT_K = 26
|
|
};
|
|
bool b() const {
|
|
return GetField<uint8_t>(VT_B, 0) != 0;
|
|
}
|
|
Evolution::V2::Union c_type() const {
|
|
return static_cast<Evolution::V2::Union>(GetField<uint8_t>(VT_C_TYPE, 0));
|
|
}
|
|
const void *c() const {
|
|
return GetPointer<const void *>(VT_C);
|
|
}
|
|
template<typename T> const T *c_as() const;
|
|
const Evolution::V2::TableA *c_as_TableA() const {
|
|
return c_type() == Evolution::V2::Union::TableA ? static_cast<const Evolution::V2::TableA *>(c()) : nullptr;
|
|
}
|
|
const Evolution::V2::TableB *c_as_TableB() const {
|
|
return c_type() == Evolution::V2::Union::TableB ? static_cast<const Evolution::V2::TableB *>(c()) : nullptr;
|
|
}
|
|
const Evolution::V2::TableC *c_as_TableC() const {
|
|
return c_type() == Evolution::V2::Union::TableC ? static_cast<const Evolution::V2::TableC *>(c()) : nullptr;
|
|
}
|
|
Evolution::V2::Enum d() const {
|
|
return static_cast<Evolution::V2::Enum>(GetField<int8_t>(VT_D, 0));
|
|
}
|
|
const Evolution::V2::TableA *e() const {
|
|
return GetPointer<const Evolution::V2::TableA *>(VT_E);
|
|
}
|
|
const Evolution::V2::Struct *ff() const {
|
|
return GetStruct<const Evolution::V2::Struct *>(VT_FF);
|
|
}
|
|
const flatbuffers::Vector<int32_t> *g() const {
|
|
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_G);
|
|
}
|
|
const flatbuffers::Vector<flatbuffers::Offset<Evolution::V2::TableB>> *h() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Evolution::V2::TableB>> *>(VT_H);
|
|
}
|
|
uint32_t i() const {
|
|
return GetField<uint32_t>(VT_I, 1234);
|
|
}
|
|
const Evolution::V2::TableC *j() const {
|
|
return GetPointer<const Evolution::V2::TableC *>(VT_J);
|
|
}
|
|
uint8_t k() const {
|
|
return GetField<uint8_t>(VT_K, 56);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_B) &&
|
|
VerifyField<uint8_t>(verifier, VT_C_TYPE) &&
|
|
VerifyOffset(verifier, VT_C) &&
|
|
VerifyUnion(verifier, c(), c_type()) &&
|
|
VerifyField<int8_t>(verifier, VT_D) &&
|
|
VerifyOffset(verifier, VT_E) &&
|
|
verifier.VerifyTable(e()) &&
|
|
VerifyField<Evolution::V2::Struct>(verifier, VT_FF) &&
|
|
VerifyOffset(verifier, VT_G) &&
|
|
verifier.VerifyVector(g()) &&
|
|
VerifyOffset(verifier, VT_H) &&
|
|
verifier.VerifyVector(h()) &&
|
|
verifier.VerifyVectorOfTables(h()) &&
|
|
VerifyField<uint32_t>(verifier, VT_I) &&
|
|
VerifyOffset(verifier, VT_J) &&
|
|
verifier.VerifyTable(j()) &&
|
|
VerifyField<uint8_t>(verifier, VT_K) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
template<> inline const Evolution::V2::TableA *Root::c_as<Evolution::V2::TableA>() const {
|
|
return c_as_TableA();
|
|
}
|
|
|
|
template<> inline const Evolution::V2::TableB *Root::c_as<Evolution::V2::TableB>() const {
|
|
return c_as_TableB();
|
|
}
|
|
|
|
template<> inline const Evolution::V2::TableC *Root::c_as<Evolution::V2::TableC>() const {
|
|
return c_as_TableC();
|
|
}
|
|
|
|
struct RootBuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_b(bool b) {
|
|
fbb_.AddElement<uint8_t>(Root::VT_B, static_cast<uint8_t>(b), 0);
|
|
}
|
|
void add_c_type(Evolution::V2::Union c_type) {
|
|
fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0);
|
|
}
|
|
void add_c(flatbuffers::Offset<void> c) {
|
|
fbb_.AddOffset(Root::VT_C, c);
|
|
}
|
|
void add_d(Evolution::V2::Enum d) {
|
|
fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0);
|
|
}
|
|
void add_e(flatbuffers::Offset<Evolution::V2::TableA> e) {
|
|
fbb_.AddOffset(Root::VT_E, e);
|
|
}
|
|
void add_ff(const Evolution::V2::Struct *ff) {
|
|
fbb_.AddStruct(Root::VT_FF, ff);
|
|
}
|
|
void add_g(flatbuffers::Offset<flatbuffers::Vector<int32_t>> g) {
|
|
fbb_.AddOffset(Root::VT_G, g);
|
|
}
|
|
void add_h(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Evolution::V2::TableB>>> h) {
|
|
fbb_.AddOffset(Root::VT_H, h);
|
|
}
|
|
void add_i(uint32_t i) {
|
|
fbb_.AddElement<uint32_t>(Root::VT_I, i, 1234);
|
|
}
|
|
void add_j(flatbuffers::Offset<Evolution::V2::TableC> j) {
|
|
fbb_.AddOffset(Root::VT_J, j);
|
|
}
|
|
void add_k(uint8_t k) {
|
|
fbb_.AddElement<uint8_t>(Root::VT_K, k, 56);
|
|
}
|
|
explicit RootBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Root> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Root>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Root> CreateRoot(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
bool b = false,
|
|
Evolution::V2::Union c_type = Evolution::V2::Union::NONE,
|
|
flatbuffers::Offset<void> c = 0,
|
|
Evolution::V2::Enum d = Evolution::V2::Enum::King,
|
|
flatbuffers::Offset<Evolution::V2::TableA> e = 0,
|
|
const Evolution::V2::Struct *ff = 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> j = 0,
|
|
uint8_t k = 56) {
|
|
RootBuilder builder_(_fbb);
|
|
builder_.add_j(j);
|
|
builder_.add_i(i);
|
|
builder_.add_h(h);
|
|
builder_.add_g(g);
|
|
builder_.add_ff(ff);
|
|
builder_.add_e(e);
|
|
builder_.add_c(c);
|
|
builder_.add_k(k);
|
|
builder_.add_d(d);
|
|
builder_.add_c_type(c_type);
|
|
builder_.add_b(b);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Root> CreateRootDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
bool b = false,
|
|
Evolution::V2::Union c_type = Evolution::V2::Union::NONE,
|
|
flatbuffers::Offset<void> c = 0,
|
|
Evolution::V2::Enum d = Evolution::V2::Enum::King,
|
|
flatbuffers::Offset<Evolution::V2::TableA> e = 0,
|
|
const Evolution::V2::Struct *ff = 0,
|
|
const std::vector<int32_t> *g = nullptr,
|
|
const std::vector<flatbuffers::Offset<Evolution::V2::TableB>> *h = nullptr,
|
|
uint32_t i = 1234,
|
|
flatbuffers::Offset<Evolution::V2::TableC> j = 0,
|
|
uint8_t k = 56) {
|
|
auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0;
|
|
auto h__ = h ? _fbb.CreateVector<flatbuffers::Offset<Evolution::V2::TableB>>(*h) : 0;
|
|
return Evolution::V2::CreateRoot(
|
|
_fbb,
|
|
b,
|
|
c_type,
|
|
c,
|
|
d,
|
|
e,
|
|
ff,
|
|
g__,
|
|
h__,
|
|
i,
|
|
j,
|
|
k);
|
|
}
|
|
|
|
inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type) {
|
|
switch (type) {
|
|
case Union::NONE: {
|
|
return true;
|
|
}
|
|
case Union::TableA: {
|
|
auto ptr = reinterpret_cast<const Evolution::V2::TableA *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Union::TableB: {
|
|
auto ptr = reinterpret_cast<const Evolution::V2::TableB *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Union::TableC: {
|
|
auto ptr = reinterpret_cast<const Evolution::V2::TableC *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
default: return true;
|
|
}
|
|
}
|
|
|
|
inline bool VerifyUnionVector(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) {
|
|
if (!VerifyUnion(
|
|
verifier, values->Get(i), types->GetEnum<Union>(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline const Evolution::V2::Root *GetRoot(const void *buf) {
|
|
return flatbuffers::GetRoot<Evolution::V2::Root>(buf);
|
|
}
|
|
|
|
inline const Evolution::V2::Root *GetSizePrefixedRoot(const void *buf) {
|
|
return flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf);
|
|
}
|
|
|
|
inline bool VerifyRootBuffer(
|
|
flatbuffers::Verifier &verifier) {
|
|
return verifier.VerifyBuffer<Evolution::V2::Root>(nullptr);
|
|
}
|
|
|
|
inline bool VerifySizePrefixedRootBuffer(
|
|
flatbuffers::Verifier &verifier) {
|
|
return verifier.VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr);
|
|
}
|
|
|
|
inline void FinishRootBuffer(
|
|
flatbuffers::FlatBufferBuilder &fbb,
|
|
flatbuffers::Offset<Evolution::V2::Root> root) {
|
|
fbb.Finish(root);
|
|
}
|
|
|
|
inline void FinishSizePrefixedRootBuffer(
|
|
flatbuffers::FlatBufferBuilder &fbb,
|
|
flatbuffers::Offset<Evolution::V2::Root> root) {
|
|
fbb.FinishSizePrefixed(root);
|
|
}
|
|
|
|
} // namespace V2
|
|
} // namespace Evolution
|
|
|
|
#endif // FLATBUFFERS_GENERATED_EVOLUTIONV2_EVOLUTION_V2_H_
|