// automatically generated by the FlatBuffers compiler, do not modify

#ifndef FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_

#define FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_

#include "flatbuffers/flatbuffers.h"

namespace reflection {

struct Type;

struct KeyValue;

struct EnumVal;

struct Enum;

struct Field;

struct Object;

struct Schema;

enum BaseType {

None = 0,

UType = 1,

Bool = 2,

Byte = 3,

UByte = 4,

Short = 5,

UShort = 6,

Int = 7,

UInt = 8,

Long = 9,

ULong = 10,

Float = 11,

Double = 12,

String = 13,

Vector = 14,

Obj = 15,

Union = 16,

};

inline const char **EnumNamesBaseType() {

static const char *names[] = { "None", "UType", "Bool", "Byte", "UByte", "Short", "UShort", "Int", "UInt", "Long", "ULong", "Float", "Double", "String", "Vector", "Obj", "Union", nullptr };

return names;

}

inline const char *EnumNameBaseType(BaseType e) { return EnumNamesBaseType()[static_cast<int>(e)]; }

struct Type FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

enum {

VT_BASE_TYPE = 4,

VT_ELEMENT = 6,

VT_INDEX = 8

};

BaseType base_type() const { return static_cast<BaseType>(GetField<int8_t>(VT_BASE_TYPE, 0)); }

BaseType element() const { return static_cast<BaseType>(GetField<int8_t>(VT_ELEMENT, 0)); }

int32_t index() const { return GetField<int32_t>(VT_INDEX, -1); }

bool Verify(flatbuffers::Verifier &verifier) const {

return VerifyTableStart(verifier) &&

VerifyField<int8_t>(verifier, VT_BASE_TYPE) &&

VerifyField<int8_t>(verifier, VT_ELEMENT) &&

VerifyField<int32_t>(verifier, VT_INDEX) &&

verifier.EndTable();

}

};

struct TypeBuilder {

flatbuffers::FlatBufferBuilder &fbb_;

flatbuffers::uoffset_t start_;

void add_base_type(BaseType base_type) { fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0); }

void add_element(BaseType element) { fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0); }

void add_index(int32_t index) { fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1); }

TypeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }

TypeBuilder &operator=(const TypeBuilder &);

flatbuffers::Offset<Type> Finish() {

auto o = flatbuffers::Offset<Type>(fbb_.EndTable(start_, 3));

return o;

}

};

inline flatbuffers::Offset<Type> CreateType(flatbuffers::FlatBufferBuilder &_fbb,

BaseType base_type = None,

BaseType element = None,

int32_t index = -1) {

TypeBuilder builder_(_fbb);

builder_.add_index(index);

builder_.add_element(element);

builder_.add_base_type(base_type);

return builder_.Finish();

}

struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

enum {

VT_KEY = 4,

VT_VALUE = 6

};

const flatbuffers::String *key() const { return GetPointer<const flatbuffers::String *>(VT_KEY); }

bool KeyCompareLessThan(const KeyValue *o) const { return *key() < *o->key(); }

int KeyCompareWithValue(const char *val) const { return strcmp(key()->c_str(), val); }

const flatbuffers::String *value() const { return GetPointer<const flatbuffers::String *>(VT_VALUE); }

bool Verify(flatbuffers::Verifier &verifier) const {

return VerifyTableStart(verifier) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_KEY) &&

verifier.Verify(key()) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_VALUE) &&

verifier.Verify(value()) &&

verifier.EndTable();

}

};

struct KeyValueBuilder {

flatbuffers::FlatBufferBuilder &fbb_;

flatbuffers::uoffset_t start_;

void add_key(flatbuffers::Offset<flatbuffers::String> key) { fbb_.AddOffset(KeyValue::VT_KEY, key); }

void add_value(flatbuffers::Offset<flatbuffers::String> value) { fbb_.AddOffset(KeyValue::VT_VALUE, value); }

KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }

KeyValueBuilder &operator=(const KeyValueBuilder &);

flatbuffers::Offset<KeyValue> Finish() {

auto o = flatbuffers::Offset<KeyValue>(fbb_.EndTable(start_, 2));

fbb_.Required(o, KeyValue::VT_KEY); // key

return o;

}

};

inline flatbuffers::Offset<KeyValue> CreateKeyValue(flatbuffers::FlatBufferBuilder &_fbb,

flatbuffers::Offset<flatbuffers::String> key = 0,

flatbuffers::Offset<flatbuffers::String> value = 0) {

KeyValueBuilder builder_(_fbb);

builder_.add_value(value);

builder_.add_key(key);

return builder_.Finish();

}

inline flatbuffers::Offset<KeyValue> CreateKeyValueDirect(flatbuffers::FlatBufferBuilder &_fbb,

const char *key = nullptr,

const char *value = nullptr) {

return CreateKeyValue(_fbb, key ? _fbb.CreateString(key) : 0, value ? _fbb.CreateString(value) : 0);

}

struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

enum {

VT_NAME = 4,

VT_VALUE = 6,

VT_OBJECT = 8

};

const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(VT_NAME); }

int64_t value() const { return GetField<int64_t>(VT_VALUE, 0); }

bool KeyCompareLessThan(const EnumVal *o) const { return value() < o->value(); }

int KeyCompareWithValue(int64_t val) const { return value() < val ? -1 : value() > val; }

const Object *object() const { return GetPointer<const Object *>(VT_OBJECT); }

bool Verify(flatbuffers::Verifier &verifier) const {

return VerifyTableStart(verifier) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NAME) &&

verifier.Verify(name()) &&

VerifyField<int64_t>(verifier, VT_VALUE) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_OBJECT) &&

verifier.VerifyTable(object()) &&

verifier.EndTable();

}

};

struct EnumValBuilder {

flatbuffers::FlatBufferBuilder &fbb_;

flatbuffers::uoffset_t start_;

void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(EnumVal::VT_NAME, name); }

void add_value(int64_t value) { fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0); }

void add_object(flatbuffers::Offset<Object> object) { fbb_.AddOffset(EnumVal::VT_OBJECT, object); }

EnumValBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }

EnumValBuilder &operator=(const EnumValBuilder &);

flatbuffers::Offset<EnumVal> Finish() {

auto o = flatbuffers::Offset<EnumVal>(fbb_.EndTable(start_, 3));

fbb_.Required(o, EnumVal::VT_NAME); // name

return o;

}

};

inline flatbuffers::Offset<EnumVal> CreateEnumVal(flatbuffers::FlatBufferBuilder &_fbb,

flatbuffers::Offset<flatbuffers::String> name = 0,

int64_t value = 0,

flatbuffers::Offset<Object> object = 0) {

EnumValBuilder builder_(_fbb);

builder_.add_value(value);

builder_.add_object(object);

builder_.add_name(name);

return builder_.Finish();

}

inline flatbuffers::Offset<EnumVal> CreateEnumValDirect(flatbuffers::FlatBufferBuilder &_fbb,

const char *name = nullptr,

int64_t value = 0,

flatbuffers::Offset<Object> object = 0) {

return CreateEnumVal(_fbb, name ? _fbb.CreateString(name) : 0, value, object);

}

struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

enum {

VT_NAME = 4,

VT_VALUES = 6,

VT_IS_UNION = 8,

VT_UNDERLYING_TYPE = 10,

VT_ATTRIBUTES = 12

};

const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(VT_NAME); }

bool KeyCompareLessThan(const Enum *o) const { return *name() < *o->name(); }

int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }

const flatbuffers::Vector<flatbuffers::Offset<EnumVal>> *values() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<EnumVal>> *>(VT_VALUES); }

bool is_union() const { return GetField<uint8_t>(VT_IS_UNION, 0) != 0; }

const Type *underlying_type() const { return GetPointer<const Type *>(VT_UNDERLYING_TYPE); }

const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *attributes() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_ATTRIBUTES); }

bool Verify(flatbuffers::Verifier &verifier) const {

return VerifyTableStart(verifier) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NAME) &&

verifier.Verify(name()) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_VALUES) &&

verifier.Verify(values()) &&

verifier.VerifyVectorOfTables(values()) &&

VerifyField<uint8_t>(verifier, VT_IS_UNION) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_UNDERLYING_TYPE) &&

verifier.VerifyTable(underlying_type()) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_ATTRIBUTES) &&

verifier.Verify(attributes()) &&

verifier.VerifyVectorOfTables(attributes()) &&

verifier.EndTable();

}

};

struct EnumBuilder {

flatbuffers::FlatBufferBuilder &fbb_;

flatbuffers::uoffset_t start_;

void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(Enum::VT_NAME, name); }

void add_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<EnumVal>>> values) { fbb_.AddOffset(Enum::VT_VALUES, values); }

void add_is_union(bool is_union) { fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0); }

void add_underlying_type(flatbuffers::Offset<Type> underlying_type) { fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type); }

void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) { fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes); }

EnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }

EnumBuilder &operator=(const EnumBuilder &);

flatbuffers::Offset<Enum> Finish() {

auto o = flatbuffers::Offset<Enum>(fbb_.EndTable(start_, 5));

fbb_.Required(o, Enum::VT_NAME); // name

fbb_.Required(o, Enum::VT_VALUES); // values

fbb_.Required(o, Enum::VT_UNDERLYING_TYPE); // underlying_type

return o;

}

};

inline flatbuffers::Offset<Enum> CreateEnum(flatbuffers::FlatBufferBuilder &_fbb,

flatbuffers::Offset<flatbuffers::String> name = 0,

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<EnumVal>>> values = 0,

bool is_union = false,

flatbuffers::Offset<Type> underlying_type = 0,

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes = 0) {

EnumBuilder builder_(_fbb);

builder_.add_attributes(attributes);

builder_.add_underlying_type(underlying_type);

builder_.add_values(values);

builder_.add_name(name);

builder_.add_is_union(is_union);

return builder_.Finish();

}

inline flatbuffers::Offset<Enum> CreateEnumDirect(flatbuffers::FlatBufferBuilder &_fbb,

const char *name = nullptr,

const std::vector<flatbuffers::Offset<EnumVal>> *values = nullptr,

bool is_union = false,

flatbuffers::Offset<Type> underlying_type = 0,

const std::vector<flatbuffers::Offset<KeyValue>> *attributes = nullptr) {

return CreateEnum(_fbb, name ? _fbb.CreateString(name) : 0, values ? _fbb.CreateVector<flatbuffers::Offset<EnumVal>>(*values) : 0, is_union, underlying_type, attributes ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*attributes) : 0);

}

struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

enum {

VT_NAME = 4,

VT_TYPE = 6,

VT_ID = 8,

VT_OFFSET = 10,

VT_DEFAULT_INTEGER = 12,

VT_DEFAULT_REAL = 14,

VT_DEPRECATED = 16,

VT_REQUIRED = 18,

VT_KEY = 20,

VT_ATTRIBUTES = 22

};

const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(VT_NAME); }

bool KeyCompareLessThan(const Field *o) const { return *name() < *o->name(); }

int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }

const Type *type() const { return GetPointer<const Type *>(VT_TYPE); }

uint16_t id() const { return GetField<uint16_t>(VT_ID, 0); }

uint16_t offset() const { return GetField<uint16_t>(VT_OFFSET, 0); }

int64_t default_integer() const { return GetField<int64_t>(VT_DEFAULT_INTEGER, 0); }

double default_real() const { return GetField<double>(VT_DEFAULT_REAL, 0.0); }

bool deprecated() const { return GetField<uint8_t>(VT_DEPRECATED, 0) != 0; }

bool required() const { return GetField<uint8_t>(VT_REQUIRED, 0) != 0; }

bool key() const { return GetField<uint8_t>(VT_KEY, 0) != 0; }

const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *attributes() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_ATTRIBUTES); }

bool Verify(flatbuffers::Verifier &verifier) const {

return VerifyTableStart(verifier) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NAME) &&

verifier.Verify(name()) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_TYPE) &&

verifier.VerifyTable(type()) &&

VerifyField<uint16_t>(verifier, VT_ID) &&

VerifyField<uint16_t>(verifier, VT_OFFSET) &&

VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER) &&

VerifyField<double>(verifier, VT_DEFAULT_REAL) &&

VerifyField<uint8_t>(verifier, VT_DEPRECATED) &&

VerifyField<uint8_t>(verifier, VT_REQUIRED) &&

VerifyField<uint8_t>(verifier, VT_KEY) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_ATTRIBUTES) &&

verifier.Verify(attributes()) &&

verifier.VerifyVectorOfTables(attributes()) &&

verifier.EndTable();

}

};

struct FieldBuilder {

flatbuffers::FlatBufferBuilder &fbb_;

flatbuffers::uoffset_t start_;

void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(Field::VT_NAME, name); }

void add_type(flatbuffers::Offset<Type> type) { fbb_.AddOffset(Field::VT_TYPE, type); }

void add_id(uint16_t id) { fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0); }

void add_offset(uint16_t offset) { fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0); }

void add_default_integer(int64_t default_integer) { fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0); }

void add_default_real(double default_real) { fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0); }

void add_deprecated(bool deprecated) { fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0); }

void add_required(bool required) { fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0); }

void add_key(bool key) { fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0); }

void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) { fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes); }

FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }

FieldBuilder &operator=(const FieldBuilder &);

flatbuffers::Offset<Field> Finish() {

auto o = flatbuffers::Offset<Field>(fbb_.EndTable(start_, 10));

fbb_.Required(o, Field::VT_NAME); // name

fbb_.Required(o, Field::VT_TYPE); // type

return o;

}

};

inline flatbuffers::Offset<Field> CreateField(flatbuffers::FlatBufferBuilder &_fbb,

flatbuffers::Offset<flatbuffers::String> name = 0,

flatbuffers::Offset<Type> type = 0,

uint16_t id = 0,

uint16_t offset = 0,

int64_t default_integer = 0,

double default_real = 0.0,

bool deprecated = false,

bool required = false,

bool key = false,

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes = 0) {

FieldBuilder builder_(_fbb);

builder_.add_default_real(default_real);

builder_.add_default_integer(default_integer);

builder_.add_attributes(attributes);

builder_.add_type(type);

builder_.add_name(name);

builder_.add_offset(offset);

builder_.add_id(id);

builder_.add_key(key);

builder_.add_required(required);

builder_.add_deprecated(deprecated);

return builder_.Finish();

}

inline flatbuffers::Offset<Field> CreateFieldDirect(flatbuffers::FlatBufferBuilder &_fbb,

const char *name = nullptr,

flatbuffers::Offset<Type> type = 0,

uint16_t id = 0,

uint16_t offset = 0,

int64_t default_integer = 0,

double default_real = 0.0,

bool deprecated = false,

bool required = false,

bool key = false,

const std::vector<flatbuffers::Offset<KeyValue>> *attributes = nullptr) {

return CreateField(_fbb, name ? _fbb.CreateString(name) : 0, type, id, offset, default_integer, default_real, deprecated, required, key, attributes ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*attributes) : 0);

}

struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

enum {

VT_NAME = 4,

VT_FIELDS = 6,

VT_IS_STRUCT = 8,

VT_MINALIGN = 10,

VT_BYTESIZE = 12,

VT_ATTRIBUTES = 14

};

const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(VT_NAME); }

bool KeyCompareLessThan(const Object *o) const { return *name() < *o->name(); }

int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }

const flatbuffers::Vector<flatbuffers::Offset<Field>> *fields() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Field>> *>(VT_FIELDS); }

bool is_struct() const { return GetField<uint8_t>(VT_IS_STRUCT, 0) != 0; }

int32_t minalign() const { return GetField<int32_t>(VT_MINALIGN, 0); }

int32_t bytesize() const { return GetField<int32_t>(VT_BYTESIZE, 0); }

const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *attributes() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_ATTRIBUTES); }

bool Verify(flatbuffers::Verifier &verifier) const {

return VerifyTableStart(verifier) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NAME) &&

verifier.Verify(name()) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_FIELDS) &&

verifier.Verify(fields()) &&

verifier.VerifyVectorOfTables(fields()) &&

VerifyField<uint8_t>(verifier, VT_IS_STRUCT) &&

VerifyField<int32_t>(verifier, VT_MINALIGN) &&

VerifyField<int32_t>(verifier, VT_BYTESIZE) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_ATTRIBUTES) &&

verifier.Verify(attributes()) &&

verifier.VerifyVectorOfTables(attributes()) &&

verifier.EndTable();

}

};

struct ObjectBuilder {

flatbuffers::FlatBufferBuilder &fbb_;

flatbuffers::uoffset_t start_;

void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(Object::VT_NAME, name); }

void add_fields(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> fields) { fbb_.AddOffset(Object::VT_FIELDS, fields); }

void add_is_struct(bool is_struct) { fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0); }

void add_minalign(int32_t minalign) { fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0); }

void add_bytesize(int32_t bytesize) { fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0); }

void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) { fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes); }

ObjectBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }

ObjectBuilder &operator=(const ObjectBuilder &);

flatbuffers::Offset<Object> Finish() {

auto o = flatbuffers::Offset<Object>(fbb_.EndTable(start_, 6));

fbb_.Required(o, Object::VT_NAME); // name

fbb_.Required(o, Object::VT_FIELDS); // fields

return o;

}

};

inline flatbuffers::Offset<Object> CreateObject(flatbuffers::FlatBufferBuilder &_fbb,

flatbuffers::Offset<flatbuffers::String> name = 0,

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> fields = 0,

bool is_struct = false,

int32_t minalign = 0,

int32_t bytesize = 0,

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes = 0) {

ObjectBuilder builder_(_fbb);

builder_.add_attributes(attributes);

builder_.add_bytesize(bytesize);

builder_.add_minalign(minalign);

builder_.add_fields(fields);

builder_.add_name(name);

builder_.add_is_struct(is_struct);

return builder_.Finish();

}

inline flatbuffers::Offset<Object> CreateObjectDirect(flatbuffers::FlatBufferBuilder &_fbb,

const char *name = nullptr,

const std::vector<flatbuffers::Offset<Field>> *fields = nullptr,

bool is_struct = false,

int32_t minalign = 0,

int32_t bytesize = 0,

const std::vector<flatbuffers::Offset<KeyValue>> *attributes = nullptr) {

return CreateObject(_fbb, name ? _fbb.CreateString(name) : 0, fields ? _fbb.CreateVector<flatbuffers::Offset<Field>>(*fields) : 0, is_struct, minalign, bytesize, attributes ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*attributes) : 0);

}

struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

enum {

VT_OBJECTS = 4,

VT_ENUMS = 6,

VT_FILE_IDENT = 8,

VT_FILE_EXT = 10,

VT_ROOT_TABLE = 12

};

const flatbuffers::Vector<flatbuffers::Offset<Object>> *objects() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Object>> *>(VT_OBJECTS); }

const flatbuffers::Vector<flatbuffers::Offset<Enum>> *enums() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Enum>> *>(VT_ENUMS); }

const flatbuffers::String *file_ident() const { return GetPointer<const flatbuffers::String *>(VT_FILE_IDENT); }

const flatbuffers::String *file_ext() const { return GetPointer<const flatbuffers::String *>(VT_FILE_EXT); }

const Object *root_table() const { return GetPointer<const Object *>(VT_ROOT_TABLE); }

bool Verify(flatbuffers::Verifier &verifier) const {

return VerifyTableStart(verifier) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_OBJECTS) &&

verifier.Verify(objects()) &&

verifier.VerifyVectorOfTables(objects()) &&

VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_ENUMS) &&

verifier.Verify(enums()) &&

verifier.VerifyVectorOfTables(enums()) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_FILE_IDENT) &&

verifier.Verify(file_ident()) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_FILE_EXT) &&

verifier.Verify(file_ext()) &&

VerifyField<flatbuffers::uoffset_t>(verifier, VT_ROOT_TABLE) &&

verifier.VerifyTable(root_table()) &&

verifier.EndTable();

}

};

struct SchemaBuilder {

flatbuffers::FlatBufferBuilder &fbb_;

flatbuffers::uoffset_t start_;

void add_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Object>>> objects) { fbb_.AddOffset(Schema::VT_OBJECTS, objects); }

void add_enums(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Enum>>> enums) { fbb_.AddOffset(Schema::VT_ENUMS, enums); }

void add_file_ident(flatbuffers::Offset<flatbuffers::String> file_ident) { fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident); }

void add_file_ext(flatbuffers::Offset<flatbuffers::String> file_ext) { fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext); }

void add_root_table(flatbuffers::Offset<Object> root_table) { fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table); }

SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }

SchemaBuilder &operator=(const SchemaBuilder &);

flatbuffers::Offset<Schema> Finish() {

auto o = flatbuffers::Offset<Schema>(fbb_.EndTable(start_, 5));

fbb_.Required(o, Schema::VT_OBJECTS); // objects

fbb_.Required(o, Schema::VT_ENUMS); // enums

return o;

}

};

inline flatbuffers::Offset<Schema> CreateSchema(flatbuffers::FlatBufferBuilder &_fbb,

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Object>>> objects = 0,

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Enum>>> enums = 0,

flatbuffers::Offset<flatbuffers::String> file_ident = 0,

flatbuffers::Offset<flatbuffers::String> file_ext = 0,

flatbuffers::Offset<Object> root_table = 0) {

SchemaBuilder builder_(_fbb);

builder_.add_root_table(root_table);

builder_.add_file_ext(file_ext);

builder_.add_file_ident(file_ident);

builder_.add_enums(enums);

builder_.add_objects(objects);

return builder_.Finish();

}

inline flatbuffers::Offset<Schema> CreateSchemaDirect(flatbuffers::FlatBufferBuilder &_fbb,

const std::vector<flatbuffers::Offset<Object>> *objects = nullptr,

const std::vector<flatbuffers::Offset<Enum>> *enums = nullptr,

const char *file_ident = nullptr,

const char *file_ext = nullptr,

flatbuffers::Offset<Object> root_table = 0) {

return CreateSchema(_fbb, objects ? _fbb.CreateVector<flatbuffers::Offset<Object>>(*objects) : 0, enums ? _fbb.CreateVector<flatbuffers::Offset<Enum>>(*enums) : 0, file_ident ? _fbb.CreateString(file_ident) : 0, file_ext ? _fbb.CreateString(file_ext) : 0, root_table);

}

inline const reflection::Schema *GetSchema(const void *buf) {

return flatbuffers::GetRoot<reflection::Schema>(buf);

}

inline const char *SchemaIdentifier() {

return "BFBS";

}

inline bool SchemaBufferHasIdentifier(const void *buf) {

return flatbuffers::BufferHasIdentifier(buf, SchemaIdentifier());

}

inline bool VerifySchemaBuffer(flatbuffers::Verifier &verifier) {

return verifier.VerifyBuffer<reflection::Schema>(SchemaIdentifier());

}

inline const char *SchemaExtension() { return "bfbs"; }

inline void FinishSchemaBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<reflection::Schema> root) {

fbb.Finish(root, SchemaIdentifier());

}

} // namespace reflection

#endif // FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_