Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-08-27 09:30:28 

0001 // automatically generated by the FlatBuffers compiler, do not modify
0002 
0003 
0004 #ifndef FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
0005 #define FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
0006 
0007 #include "flatbuffers/flatbuffers.h"
0008 
0009 // Ensure the included flatbuffers.h is the same version as when this file was
0010 // generated, otherwise it may not be compatible.
0011 static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
0012               FLATBUFFERS_VERSION_MINOR == 12 &&
0013               FLATBUFFERS_VERSION_REVISION == 23,
0014              "Non-compatible flatbuffers version included");
0015 
0016 namespace reflection {
0017 
0018 struct Type;
0019 struct TypeBuilder;
0020 
0021 struct KeyValue;
0022 struct KeyValueBuilder;
0023 
0024 struct EnumVal;
0025 struct EnumValBuilder;
0026 
0027 struct Enum;
0028 struct EnumBuilder;
0029 
0030 struct Field;
0031 struct FieldBuilder;
0032 
0033 struct Object;
0034 struct ObjectBuilder;
0035 
0036 struct RPCCall;
0037 struct RPCCallBuilder;
0038 
0039 struct Service;
0040 struct ServiceBuilder;
0041 
0042 struct SchemaFile;
0043 struct SchemaFileBuilder;
0044 
0045 struct Schema;
0046 struct SchemaBuilder;
0047 
0048 enum BaseType {
0049   None = 0,
0050   UType = 1,
0051   Bool = 2,
0052   Byte = 3,
0053   UByte = 4,
0054   Short = 5,
0055   UShort = 6,
0056   Int = 7,
0057   UInt = 8,
0058   Long = 9,
0059   ULong = 10,
0060   Float = 11,
0061   Double = 12,
0062   String = 13,
0063   Vector = 14,
0064   Obj = 15,
0065   Union = 16,
0066   Array = 17,
0067   Vector64 = 18,
0068   MaxBaseType = 19
0069 };
0070 
0071 inline const BaseType (&EnumValuesBaseType())[20] {
0072   static const BaseType values[] = {
0073     None,
0074     UType,
0075     Bool,
0076     Byte,
0077     UByte,
0078     Short,
0079     UShort,
0080     Int,
0081     UInt,
0082     Long,
0083     ULong,
0084     Float,
0085     Double,
0086     String,
0087     Vector,
0088     Obj,
0089     Union,
0090     Array,
0091     Vector64,
0092     MaxBaseType
0093   };
0094   return values;
0095 }
0096 
0097 inline const char * const *EnumNamesBaseType() {
0098   static const char * const names[21] = {
0099     "None",
0100     "UType",
0101     "Bool",
0102     "Byte",
0103     "UByte",
0104     "Short",
0105     "UShort",
0106     "Int",
0107     "UInt",
0108     "Long",
0109     "ULong",
0110     "Float",
0111     "Double",
0112     "String",
0113     "Vector",
0114     "Obj",
0115     "Union",
0116     "Array",
0117     "Vector64",
0118     "MaxBaseType",
0119     nullptr
0120   };
0121   return names;
0122 }
0123 
0124 inline const char *EnumNameBaseType(BaseType e) {
0125   if (::flatbuffers::IsOutRange(e, None, MaxBaseType)) return "";
0126   const size_t index = static_cast<size_t>(e);
0127   return EnumNamesBaseType()[index];
0128 }
0129 
0130 /// New schema language features that are not supported by old code generators.
0131 enum AdvancedFeatures {
0132   AdvancedArrayFeatures = 1ULL,
0133   AdvancedUnionFeatures = 2ULL,
0134   OptionalScalars = 4ULL,
0135   DefaultVectorsAndStrings = 8ULL
0136 };
0137 
0138 inline const AdvancedFeatures (&EnumValuesAdvancedFeatures())[4] {
0139   static const AdvancedFeatures values[] = {
0140     AdvancedArrayFeatures,
0141     AdvancedUnionFeatures,
0142     OptionalScalars,
0143     DefaultVectorsAndStrings
0144   };
0145   return values;
0146 }
0147 
0148 inline const char * const *EnumNamesAdvancedFeatures() {
0149   static const char * const names[9] = {
0150     "AdvancedArrayFeatures",
0151     "AdvancedUnionFeatures",
0152     "",
0153     "OptionalScalars",
0154     "",
0155     "",
0156     "",
0157     "DefaultVectorsAndStrings",
0158     nullptr
0159   };
0160   return names;
0161 }
0162 
0163 inline const char *EnumNameAdvancedFeatures(AdvancedFeatures e) {
0164   if (::flatbuffers::IsOutRange(e, AdvancedArrayFeatures, DefaultVectorsAndStrings)) return "";
0165   const size_t index = static_cast<size_t>(e) - static_cast<size_t>(AdvancedArrayFeatures);
0166   return EnumNamesAdvancedFeatures()[index];
0167 }
0168 
0169 struct Type FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
0170   typedef TypeBuilder Builder;
0171   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
0172     VT_BASE_TYPE = 4,
0173     VT_ELEMENT = 6,
0174     VT_INDEX = 8,
0175     VT_FIXED_LENGTH = 10,
0176     VT_BASE_SIZE = 12,
0177     VT_ELEMENT_SIZE = 14
0178   };
0179   reflection::BaseType base_type() const {
0180     return static_cast<reflection::BaseType>(GetField<int8_t>(VT_BASE_TYPE, 0));
0181   }
0182   reflection::BaseType element() const {
0183     return static_cast<reflection::BaseType>(GetField<int8_t>(VT_ELEMENT, 0));
0184   }
0185   int32_t index() const {
0186     return GetField<int32_t>(VT_INDEX, -1);
0187   }
0188   uint16_t fixed_length() const {
0189     return GetField<uint16_t>(VT_FIXED_LENGTH, 0);
0190   }
0191   /// The size (octets) of the `base_type` field.
0192   uint32_t base_size() const {
0193     return GetField<uint32_t>(VT_BASE_SIZE, 4);
0194   }
0195   /// The size (octets) of the `element` field, if present.
0196   uint32_t element_size() const {
0197     return GetField<uint32_t>(VT_ELEMENT_SIZE, 0);
0198   }
0199   bool Verify(::flatbuffers::Verifier &verifier) const {
0200     return VerifyTableStart(verifier) &&
0201            VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
0202            VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
0203            VerifyField<int32_t>(verifier, VT_INDEX, 4) &&
0204            VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH, 2) &&
0205            VerifyField<uint32_t>(verifier, VT_BASE_SIZE, 4) &&
0206            VerifyField<uint32_t>(verifier, VT_ELEMENT_SIZE, 4) &&
0207            verifier.EndTable();
0208   }
0209 };
0210 
0211 struct TypeBuilder {
0212   typedef Type Table;
0213   ::flatbuffers::FlatBufferBuilder &fbb_;
0214   ::flatbuffers::uoffset_t start_;
0215   void add_base_type(reflection::BaseType base_type) {
0216     fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0);
0217   }
0218   void add_element(reflection::BaseType element) {
0219     fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0);
0220   }
0221   void add_index(int32_t index) {
0222     fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1);
0223   }
0224   void add_fixed_length(uint16_t fixed_length) {
0225     fbb_.AddElement<uint16_t>(Type::VT_FIXED_LENGTH, fixed_length, 0);
0226   }
0227   void add_base_size(uint32_t base_size) {
0228     fbb_.AddElement<uint32_t>(Type::VT_BASE_SIZE, base_size, 4);
0229   }
0230   void add_element_size(uint32_t element_size) {
0231     fbb_.AddElement<uint32_t>(Type::VT_ELEMENT_SIZE, element_size, 0);
0232   }
0233   explicit TypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
0234         : fbb_(_fbb) {
0235     start_ = fbb_.StartTable();
0236   }
0237   ::flatbuffers::Offset<Type> Finish() {
0238     const auto end = fbb_.EndTable(start_);
0239     auto o = ::flatbuffers::Offset<Type>(end);
0240     return o;
0241   }
0242 };
0243 
0244 inline ::flatbuffers::Offset<Type> CreateType(
0245     ::flatbuffers::FlatBufferBuilder &_fbb,
0246     reflection::BaseType base_type = reflection::None,
0247     reflection::BaseType element = reflection::None,
0248     int32_t index = -1,
0249     uint16_t fixed_length = 0,
0250     uint32_t base_size = 4,
0251     uint32_t element_size = 0) {
0252   TypeBuilder builder_(_fbb);
0253   builder_.add_element_size(element_size);
0254   builder_.add_base_size(base_size);
0255   builder_.add_index(index);
0256   builder_.add_fixed_length(fixed_length);
0257   builder_.add_element(element);
0258   builder_.add_base_type(base_type);
0259   return builder_.Finish();
0260 }
0261 
0262 struct KeyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
0263   typedef KeyValueBuilder Builder;
0264   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
0265     VT_KEY = 4,
0266     VT_VALUE = 6
0267   };
0268   const ::flatbuffers::String *key() const {
0269     return GetPointer<const ::flatbuffers::String *>(VT_KEY);
0270   }
0271   bool KeyCompareLessThan(const KeyValue * const o) const {
0272     return *key() < *o->key();
0273   }
0274   int KeyCompareWithValue(const char *_key) const {
0275     return strcmp(key()->c_str(), _key);
0276   }
0277   template<typename StringType>
0278   int KeyCompareWithValue(const StringType& _key) const {
0279     if (key()->c_str() < _key) return -1;
0280     if (_key < key()->c_str()) return 1;
0281     return 0;
0282   }
0283   const ::flatbuffers::String *value() const {
0284     return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
0285   }
0286   bool Verify(::flatbuffers::Verifier &verifier) const {
0287     return VerifyTableStart(verifier) &&
0288            VerifyOffsetRequired(verifier, VT_KEY) &&
0289            verifier.VerifyString(key()) &&
0290            VerifyOffset(verifier, VT_VALUE) &&
0291            verifier.VerifyString(value()) &&
0292            verifier.EndTable();
0293   }
0294 };
0295 
0296 struct KeyValueBuilder {
0297   typedef KeyValue Table;
0298   ::flatbuffers::FlatBufferBuilder &fbb_;
0299   ::flatbuffers::uoffset_t start_;
0300   void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
0301     fbb_.AddOffset(KeyValue::VT_KEY, key);
0302   }
0303   void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
0304     fbb_.AddOffset(KeyValue::VT_VALUE, value);
0305   }
0306   explicit KeyValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
0307         : fbb_(_fbb) {
0308     start_ = fbb_.StartTable();
0309   }
0310   ::flatbuffers::Offset<KeyValue> Finish() {
0311     const auto end = fbb_.EndTable(start_);
0312     auto o = ::flatbuffers::Offset<KeyValue>(end);
0313     fbb_.Required(o, KeyValue::VT_KEY);
0314     return o;
0315   }
0316 };
0317 
0318 inline ::flatbuffers::Offset<KeyValue> CreateKeyValue(
0319     ::flatbuffers::FlatBufferBuilder &_fbb,
0320     ::flatbuffers::Offset<::flatbuffers::String> key = 0,
0321     ::flatbuffers::Offset<::flatbuffers::String> value = 0) {
0322   KeyValueBuilder builder_(_fbb);
0323   builder_.add_value(value);
0324   builder_.add_key(key);
0325   return builder_.Finish();
0326 }
0327 
0328 inline ::flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
0329     ::flatbuffers::FlatBufferBuilder &_fbb,
0330     const char *key = nullptr,
0331     const char *value = nullptr) {
0332   auto key__ = key ? _fbb.CreateString(key) : 0;
0333   auto value__ = value ? _fbb.CreateString(value) : 0;
0334   return reflection::CreateKeyValue(
0335       _fbb,
0336       key__,
0337       value__);
0338 }
0339 
0340 struct EnumVal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
0341   typedef EnumValBuilder Builder;
0342   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
0343     VT_NAME = 4,
0344     VT_VALUE = 6,
0345     VT_UNION_TYPE = 10,
0346     VT_DOCUMENTATION = 12,
0347     VT_ATTRIBUTES = 14
0348   };
0349   const ::flatbuffers::String *name() const {
0350     return GetPointer<const ::flatbuffers::String *>(VT_NAME);
0351   }
0352   int64_t value() const {
0353     return GetField<int64_t>(VT_VALUE, 0);
0354   }
0355   bool KeyCompareLessThan(const EnumVal * const o) const {
0356     return value() < o->value();
0357   }
0358   int KeyCompareWithValue(int64_t _value) const {
0359     return static_cast<int>(value() > _value) - static_cast<int>(value() < _value);
0360   }
0361   const reflection::Type *union_type() const {
0362     return GetPointer<const reflection::Type *>(VT_UNION_TYPE);
0363   }
0364   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
0365     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
0366   }
0367   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
0368     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
0369   }
0370   bool Verify(::flatbuffers::Verifier &verifier) const {
0371     return VerifyTableStart(verifier) &&
0372            VerifyOffsetRequired(verifier, VT_NAME) &&
0373            verifier.VerifyString(name()) &&
0374            VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
0375            VerifyOffset(verifier, VT_UNION_TYPE) &&
0376            verifier.VerifyTable(union_type()) &&
0377            VerifyOffset(verifier, VT_DOCUMENTATION) &&
0378            verifier.VerifyVector(documentation()) &&
0379            verifier.VerifyVectorOfStrings(documentation()) &&
0380            VerifyOffset(verifier, VT_ATTRIBUTES) &&
0381            verifier.VerifyVector(attributes()) &&
0382            verifier.VerifyVectorOfTables(attributes()) &&
0383            verifier.EndTable();
0384   }
0385 };
0386 
0387 struct EnumValBuilder {
0388   typedef EnumVal Table;
0389   ::flatbuffers::FlatBufferBuilder &fbb_;
0390   ::flatbuffers::uoffset_t start_;
0391   void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
0392     fbb_.AddOffset(EnumVal::VT_NAME, name);
0393   }
0394   void add_value(int64_t value) {
0395     fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0);
0396   }
0397   void add_union_type(::flatbuffers::Offset<reflection::Type> union_type) {
0398     fbb_.AddOffset(EnumVal::VT_UNION_TYPE, union_type);
0399   }
0400   void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
0401     fbb_.AddOffset(EnumVal::VT_DOCUMENTATION, documentation);
0402   }
0403   void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
0404     fbb_.AddOffset(EnumVal::VT_ATTRIBUTES, attributes);
0405   }
0406   explicit EnumValBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
0407         : fbb_(_fbb) {
0408     start_ = fbb_.StartTable();
0409   }
0410   ::flatbuffers::Offset<EnumVal> Finish() {
0411     const auto end = fbb_.EndTable(start_);
0412     auto o = ::flatbuffers::Offset<EnumVal>(end);
0413     fbb_.Required(o, EnumVal::VT_NAME);
0414     return o;
0415   }
0416 };
0417 
0418 inline ::flatbuffers::Offset<EnumVal> CreateEnumVal(
0419     ::flatbuffers::FlatBufferBuilder &_fbb,
0420     ::flatbuffers::Offset<::flatbuffers::String> name = 0,
0421     int64_t value = 0,
0422     ::flatbuffers::Offset<reflection::Type> union_type = 0,
0423     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
0424     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0) {
0425   EnumValBuilder builder_(_fbb);
0426   builder_.add_value(value);
0427   builder_.add_attributes(attributes);
0428   builder_.add_documentation(documentation);
0429   builder_.add_union_type(union_type);
0430   builder_.add_name(name);
0431   return builder_.Finish();
0432 }
0433 
0434 inline ::flatbuffers::Offset<EnumVal> CreateEnumValDirect(
0435     ::flatbuffers::FlatBufferBuilder &_fbb,
0436     const char *name = nullptr,
0437     int64_t value = 0,
0438     ::flatbuffers::Offset<reflection::Type> union_type = 0,
0439     const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
0440     std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr) {
0441   auto name__ = name ? _fbb.CreateString(name) : 0;
0442   auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
0443   auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
0444   return reflection::CreateEnumVal(
0445       _fbb,
0446       name__,
0447       value,
0448       union_type,
0449       documentation__,
0450       attributes__);
0451 }
0452 
0453 struct Enum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
0454   typedef EnumBuilder Builder;
0455   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
0456     VT_NAME = 4,
0457     VT_VALUES = 6,
0458     VT_IS_UNION = 8,
0459     VT_UNDERLYING_TYPE = 10,
0460     VT_ATTRIBUTES = 12,
0461     VT_DOCUMENTATION = 14,
0462     VT_DECLARATION_FILE = 16
0463   };
0464   const ::flatbuffers::String *name() const {
0465     return GetPointer<const ::flatbuffers::String *>(VT_NAME);
0466   }
0467   bool KeyCompareLessThan(const Enum * const o) const {
0468     return *name() < *o->name();
0469   }
0470   int KeyCompareWithValue(const char *_name) const {
0471     return strcmp(name()->c_str(), _name);
0472   }
0473   template<typename StringType>
0474   int KeyCompareWithValue(const StringType& _name) const {
0475     if (name()->c_str() < _name) return -1;
0476     if (_name < name()->c_str()) return 1;
0477     return 0;
0478   }
0479   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *values() const {
0480     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *>(VT_VALUES);
0481   }
0482   bool is_union() const {
0483     return GetField<uint8_t>(VT_IS_UNION, 0) != 0;
0484   }
0485   const reflection::Type *underlying_type() const {
0486     return GetPointer<const reflection::Type *>(VT_UNDERLYING_TYPE);
0487   }
0488   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
0489     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
0490   }
0491   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
0492     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
0493   }
0494   /// File that this Enum is declared in.
0495   const ::flatbuffers::String *declaration_file() const {
0496     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
0497   }
0498   bool Verify(::flatbuffers::Verifier &verifier) const {
0499     return VerifyTableStart(verifier) &&
0500            VerifyOffsetRequired(verifier, VT_NAME) &&
0501            verifier.VerifyString(name()) &&
0502            VerifyOffsetRequired(verifier, VT_VALUES) &&
0503            verifier.VerifyVector(values()) &&
0504            verifier.VerifyVectorOfTables(values()) &&
0505            VerifyField<uint8_t>(verifier, VT_IS_UNION, 1) &&
0506            VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
0507            verifier.VerifyTable(underlying_type()) &&
0508            VerifyOffset(verifier, VT_ATTRIBUTES) &&
0509            verifier.VerifyVector(attributes()) &&
0510            verifier.VerifyVectorOfTables(attributes()) &&
0511            VerifyOffset(verifier, VT_DOCUMENTATION) &&
0512            verifier.VerifyVector(documentation()) &&
0513            verifier.VerifyVectorOfStrings(documentation()) &&
0514            VerifyOffset(verifier, VT_DECLARATION_FILE) &&
0515            verifier.VerifyString(declaration_file()) &&
0516            verifier.EndTable();
0517   }
0518 };
0519 
0520 struct EnumBuilder {
0521   typedef Enum Table;
0522   ::flatbuffers::FlatBufferBuilder &fbb_;
0523   ::flatbuffers::uoffset_t start_;
0524   void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
0525     fbb_.AddOffset(Enum::VT_NAME, name);
0526   }
0527   void add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values) {
0528     fbb_.AddOffset(Enum::VT_VALUES, values);
0529   }
0530   void add_is_union(bool is_union) {
0531     fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0);
0532   }
0533   void add_underlying_type(::flatbuffers::Offset<reflection::Type> underlying_type) {
0534     fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type);
0535   }
0536   void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
0537     fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes);
0538   }
0539   void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
0540     fbb_.AddOffset(Enum::VT_DOCUMENTATION, documentation);
0541   }
0542   void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
0543     fbb_.AddOffset(Enum::VT_DECLARATION_FILE, declaration_file);
0544   }
0545   explicit EnumBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
0546         : fbb_(_fbb) {
0547     start_ = fbb_.StartTable();
0548   }
0549   ::flatbuffers::Offset<Enum> Finish() {
0550     const auto end = fbb_.EndTable(start_);
0551     auto o = ::flatbuffers::Offset<Enum>(end);
0552     fbb_.Required(o, Enum::VT_NAME);
0553     fbb_.Required(o, Enum::VT_VALUES);
0554     fbb_.Required(o, Enum::VT_UNDERLYING_TYPE);
0555     return o;
0556   }
0557 };
0558 
0559 inline ::flatbuffers::Offset<Enum> CreateEnum(
0560     ::flatbuffers::FlatBufferBuilder &_fbb,
0561     ::flatbuffers::Offset<::flatbuffers::String> name = 0,
0562     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values = 0,
0563     bool is_union = false,
0564     ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
0565     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
0566     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
0567     ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
0568   EnumBuilder builder_(_fbb);
0569   builder_.add_declaration_file(declaration_file);
0570   builder_.add_documentation(documentation);
0571   builder_.add_attributes(attributes);
0572   builder_.add_underlying_type(underlying_type);
0573   builder_.add_values(values);
0574   builder_.add_name(name);
0575   builder_.add_is_union(is_union);
0576   return builder_.Finish();
0577 }
0578 
0579 inline ::flatbuffers::Offset<Enum> CreateEnumDirect(
0580     ::flatbuffers::FlatBufferBuilder &_fbb,
0581     const char *name = nullptr,
0582     std::vector<::flatbuffers::Offset<reflection::EnumVal>> *values = nullptr,
0583     bool is_union = false,
0584     ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
0585     std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
0586     const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
0587     const char *declaration_file = nullptr) {
0588   auto name__ = name ? _fbb.CreateString(name) : 0;
0589   auto values__ = values ? _fbb.CreateVectorOfSortedTables<reflection::EnumVal>(values) : 0;
0590   auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
0591   auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
0592   auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
0593   return reflection::CreateEnum(
0594       _fbb,
0595       name__,
0596       values__,
0597       is_union,
0598       underlying_type,
0599       attributes__,
0600       documentation__,
0601       declaration_file__);
0602 }
0603 
0604 struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
0605   typedef FieldBuilder Builder;
0606   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
0607     VT_NAME = 4,
0608     VT_TYPE = 6,
0609     VT_ID = 8,
0610     VT_OFFSET = 10,
0611     VT_DEFAULT_INTEGER = 12,
0612     VT_DEFAULT_REAL = 14,
0613     VT_DEPRECATED = 16,
0614     VT_REQUIRED = 18,
0615     VT_KEY = 20,
0616     VT_ATTRIBUTES = 22,
0617     VT_DOCUMENTATION = 24,
0618     VT_OPTIONAL = 26,
0619     VT_PADDING = 28,
0620     VT_OFFSET64 = 30
0621   };
0622   const ::flatbuffers::String *name() const {
0623     return GetPointer<const ::flatbuffers::String *>(VT_NAME);
0624   }
0625   bool KeyCompareLessThan(const Field * const o) const {
0626     return *name() < *o->name();
0627   }
0628   int KeyCompareWithValue(const char *_name) const {
0629     return strcmp(name()->c_str(), _name);
0630   }
0631   template<typename StringType>
0632   int KeyCompareWithValue(const StringType& _name) const {
0633     if (name()->c_str() < _name) return -1;
0634     if (_name < name()->c_str()) return 1;
0635     return 0;
0636   }
0637   const reflection::Type *type() const {
0638     return GetPointer<const reflection::Type *>(VT_TYPE);
0639   }
0640   uint16_t id() const {
0641     return GetField<uint16_t>(VT_ID, 0);
0642   }
0643   uint16_t offset() const {
0644     return GetField<uint16_t>(VT_OFFSET, 0);
0645   }
0646   int64_t default_integer() const {
0647     return GetField<int64_t>(VT_DEFAULT_INTEGER, 0);
0648   }
0649   double default_real() const {
0650     return GetField<double>(VT_DEFAULT_REAL, 0.0);
0651   }
0652   bool deprecated() const {
0653     return GetField<uint8_t>(VT_DEPRECATED, 0) != 0;
0654   }
0655   bool required() const {
0656     return GetField<uint8_t>(VT_REQUIRED, 0) != 0;
0657   }
0658   bool key() const {
0659     return GetField<uint8_t>(VT_KEY, 0) != 0;
0660   }
0661   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
0662     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
0663   }
0664   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
0665     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
0666   }
0667   bool optional() const {
0668     return GetField<uint8_t>(VT_OPTIONAL, 0) != 0;
0669   }
0670   /// Number of padding octets to always add after this field. Structs only.
0671   uint16_t padding() const {
0672     return GetField<uint16_t>(VT_PADDING, 0);
0673   }
0674   /// If the field uses 64-bit offsets.
0675   bool offset64() const {
0676     return GetField<uint8_t>(VT_OFFSET64, 0) != 0;
0677   }
0678   bool Verify(::flatbuffers::Verifier &verifier) const {
0679     return VerifyTableStart(verifier) &&
0680            VerifyOffsetRequired(verifier, VT_NAME) &&
0681            verifier.VerifyString(name()) &&
0682            VerifyOffsetRequired(verifier, VT_TYPE) &&
0683            verifier.VerifyTable(type()) &&
0684            VerifyField<uint16_t>(verifier, VT_ID, 2) &&
0685            VerifyField<uint16_t>(verifier, VT_OFFSET, 2) &&
0686            VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER, 8) &&
0687            VerifyField<double>(verifier, VT_DEFAULT_REAL, 8) &&
0688            VerifyField<uint8_t>(verifier, VT_DEPRECATED, 1) &&
0689            VerifyField<uint8_t>(verifier, VT_REQUIRED, 1) &&
0690            VerifyField<uint8_t>(verifier, VT_KEY, 1) &&
0691            VerifyOffset(verifier, VT_ATTRIBUTES) &&
0692            verifier.VerifyVector(attributes()) &&
0693            verifier.VerifyVectorOfTables(attributes()) &&
0694            VerifyOffset(verifier, VT_DOCUMENTATION) &&
0695            verifier.VerifyVector(documentation()) &&
0696            verifier.VerifyVectorOfStrings(documentation()) &&
0697            VerifyField<uint8_t>(verifier, VT_OPTIONAL, 1) &&
0698            VerifyField<uint16_t>(verifier, VT_PADDING, 2) &&
0699            VerifyField<uint8_t>(verifier, VT_OFFSET64, 1) &&
0700            verifier.EndTable();
0701   }
0702 };
0703 
0704 struct FieldBuilder {
0705   typedef Field Table;
0706   ::flatbuffers::FlatBufferBuilder &fbb_;
0707   ::flatbuffers::uoffset_t start_;
0708   void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
0709     fbb_.AddOffset(Field::VT_NAME, name);
0710   }
0711   void add_type(::flatbuffers::Offset<reflection::Type> type) {
0712     fbb_.AddOffset(Field::VT_TYPE, type);
0713   }
0714   void add_id(uint16_t id) {
0715     fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0);
0716   }
0717   void add_offset(uint16_t offset) {
0718     fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0);
0719   }
0720   void add_default_integer(int64_t default_integer) {
0721     fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0);
0722   }
0723   void add_default_real(double default_real) {
0724     fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0);
0725   }
0726   void add_deprecated(bool deprecated) {
0727     fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0);
0728   }
0729   void add_required(bool required) {
0730     fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0);
0731   }
0732   void add_key(bool key) {
0733     fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0);
0734   }
0735   void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
0736     fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes);
0737   }
0738   void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
0739     fbb_.AddOffset(Field::VT_DOCUMENTATION, documentation);
0740   }
0741   void add_optional(bool optional) {
0742     fbb_.AddElement<uint8_t>(Field::VT_OPTIONAL, static_cast<uint8_t>(optional), 0);
0743   }
0744   void add_padding(uint16_t padding) {
0745     fbb_.AddElement<uint16_t>(Field::VT_PADDING, padding, 0);
0746   }
0747   void add_offset64(bool offset64) {
0748     fbb_.AddElement<uint8_t>(Field::VT_OFFSET64, static_cast<uint8_t>(offset64), 0);
0749   }
0750   explicit FieldBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
0751         : fbb_(_fbb) {
0752     start_ = fbb_.StartTable();
0753   }
0754   ::flatbuffers::Offset<Field> Finish() {
0755     const auto end = fbb_.EndTable(start_);
0756     auto o = ::flatbuffers::Offset<Field>(end);
0757     fbb_.Required(o, Field::VT_NAME);
0758     fbb_.Required(o, Field::VT_TYPE);
0759     return o;
0760   }
0761 };
0762 
0763 inline ::flatbuffers::Offset<Field> CreateField(
0764     ::flatbuffers::FlatBufferBuilder &_fbb,
0765     ::flatbuffers::Offset<::flatbuffers::String> name = 0,
0766     ::flatbuffers::Offset<reflection::Type> type = 0,
0767     uint16_t id = 0,
0768     uint16_t offset = 0,
0769     int64_t default_integer = 0,
0770     double default_real = 0.0,
0771     bool deprecated = false,
0772     bool required = false,
0773     bool key = false,
0774     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
0775     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
0776     bool optional = false,
0777     uint16_t padding = 0,
0778     bool offset64 = false) {
0779   FieldBuilder builder_(_fbb);
0780   builder_.add_default_real(default_real);
0781   builder_.add_default_integer(default_integer);
0782   builder_.add_documentation(documentation);
0783   builder_.add_attributes(attributes);
0784   builder_.add_type(type);
0785   builder_.add_name(name);
0786   builder_.add_padding(padding);
0787   builder_.add_offset(offset);
0788   builder_.add_id(id);
0789   builder_.add_offset64(offset64);
0790   builder_.add_optional(optional);
0791   builder_.add_key(key);
0792   builder_.add_required(required);
0793   builder_.add_deprecated(deprecated);
0794   return builder_.Finish();
0795 }
0796 
0797 inline ::flatbuffers::Offset<Field> CreateFieldDirect(
0798     ::flatbuffers::FlatBufferBuilder &_fbb,
0799     const char *name = nullptr,
0800     ::flatbuffers::Offset<reflection::Type> type = 0,
0801     uint16_t id = 0,
0802     uint16_t offset = 0,
0803     int64_t default_integer = 0,
0804     double default_real = 0.0,
0805     bool deprecated = false,
0806     bool required = false,
0807     bool key = false,
0808     std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
0809     const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
0810     bool optional = false,
0811     uint16_t padding = 0,
0812     bool offset64 = false) {
0813   auto name__ = name ? _fbb.CreateString(name) : 0;
0814   auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
0815   auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
0816   return reflection::CreateField(
0817       _fbb,
0818       name__,
0819       type,
0820       id,
0821       offset,
0822       default_integer,
0823       default_real,
0824       deprecated,
0825       required,
0826       key,
0827       attributes__,
0828       documentation__,
0829       optional,
0830       padding,
0831       offset64);
0832 }
0833 
0834 struct Object FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
0835   typedef ObjectBuilder Builder;
0836   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
0837     VT_NAME = 4,
0838     VT_FIELDS = 6,
0839     VT_IS_STRUCT = 8,
0840     VT_MINALIGN = 10,
0841     VT_BYTESIZE = 12,
0842     VT_ATTRIBUTES = 14,
0843     VT_DOCUMENTATION = 16,
0844     VT_DECLARATION_FILE = 18
0845   };
0846   const ::flatbuffers::String *name() const {
0847     return GetPointer<const ::flatbuffers::String *>(VT_NAME);
0848   }
0849   bool KeyCompareLessThan(const Object * const o) const {
0850     return *name() < *o->name();
0851   }
0852   int KeyCompareWithValue(const char *_name) const {
0853     return strcmp(name()->c_str(), _name);
0854   }
0855   template<typename StringType>
0856   int KeyCompareWithValue(const StringType& _name) const {
0857     if (name()->c_str() < _name) return -1;
0858     if (_name < name()->c_str()) return 1;
0859     return 0;
0860   }
0861   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *fields() const {
0862     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *>(VT_FIELDS);
0863   }
0864   bool is_struct() const {
0865     return GetField<uint8_t>(VT_IS_STRUCT, 0) != 0;
0866   }
0867   int32_t minalign() const {
0868     return GetField<int32_t>(VT_MINALIGN, 0);
0869   }
0870   int32_t bytesize() const {
0871     return GetField<int32_t>(VT_BYTESIZE, 0);
0872   }
0873   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
0874     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
0875   }
0876   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
0877     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
0878   }
0879   /// File that this Object is declared in.
0880   const ::flatbuffers::String *declaration_file() const {
0881     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
0882   }
0883   bool Verify(::flatbuffers::Verifier &verifier) const {
0884     return VerifyTableStart(verifier) &&
0885            VerifyOffsetRequired(verifier, VT_NAME) &&
0886            verifier.VerifyString(name()) &&
0887            VerifyOffsetRequired(verifier, VT_FIELDS) &&
0888            verifier.VerifyVector(fields()) &&
0889            verifier.VerifyVectorOfTables(fields()) &&
0890            VerifyField<uint8_t>(verifier, VT_IS_STRUCT, 1) &&
0891            VerifyField<int32_t>(verifier, VT_MINALIGN, 4) &&
0892            VerifyField<int32_t>(verifier, VT_BYTESIZE, 4) &&
0893            VerifyOffset(verifier, VT_ATTRIBUTES) &&
0894            verifier.VerifyVector(attributes()) &&
0895            verifier.VerifyVectorOfTables(attributes()) &&
0896            VerifyOffset(verifier, VT_DOCUMENTATION) &&
0897            verifier.VerifyVector(documentation()) &&
0898            verifier.VerifyVectorOfStrings(documentation()) &&
0899            VerifyOffset(verifier, VT_DECLARATION_FILE) &&
0900            verifier.VerifyString(declaration_file()) &&
0901            verifier.EndTable();
0902   }
0903 };
0904 
0905 struct ObjectBuilder {
0906   typedef Object Table;
0907   ::flatbuffers::FlatBufferBuilder &fbb_;
0908   ::flatbuffers::uoffset_t start_;
0909   void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
0910     fbb_.AddOffset(Object::VT_NAME, name);
0911   }
0912   void add_fields(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields) {
0913     fbb_.AddOffset(Object::VT_FIELDS, fields);
0914   }
0915   void add_is_struct(bool is_struct) {
0916     fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0);
0917   }
0918   void add_minalign(int32_t minalign) {
0919     fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0);
0920   }
0921   void add_bytesize(int32_t bytesize) {
0922     fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0);
0923   }
0924   void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
0925     fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes);
0926   }
0927   void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
0928     fbb_.AddOffset(Object::VT_DOCUMENTATION, documentation);
0929   }
0930   void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
0931     fbb_.AddOffset(Object::VT_DECLARATION_FILE, declaration_file);
0932   }
0933   explicit ObjectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
0934         : fbb_(_fbb) {
0935     start_ = fbb_.StartTable();
0936   }
0937   ::flatbuffers::Offset<Object> Finish() {
0938     const auto end = fbb_.EndTable(start_);
0939     auto o = ::flatbuffers::Offset<Object>(end);
0940     fbb_.Required(o, Object::VT_NAME);
0941     fbb_.Required(o, Object::VT_FIELDS);
0942     return o;
0943   }
0944 };
0945 
0946 inline ::flatbuffers::Offset<Object> CreateObject(
0947     ::flatbuffers::FlatBufferBuilder &_fbb,
0948     ::flatbuffers::Offset<::flatbuffers::String> name = 0,
0949     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields = 0,
0950     bool is_struct = false,
0951     int32_t minalign = 0,
0952     int32_t bytesize = 0,
0953     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
0954     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
0955     ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
0956   ObjectBuilder builder_(_fbb);
0957   builder_.add_declaration_file(declaration_file);
0958   builder_.add_documentation(documentation);
0959   builder_.add_attributes(attributes);
0960   builder_.add_bytesize(bytesize);
0961   builder_.add_minalign(minalign);
0962   builder_.add_fields(fields);
0963   builder_.add_name(name);
0964   builder_.add_is_struct(is_struct);
0965   return builder_.Finish();
0966 }
0967 
0968 inline ::flatbuffers::Offset<Object> CreateObjectDirect(
0969     ::flatbuffers::FlatBufferBuilder &_fbb,
0970     const char *name = nullptr,
0971     std::vector<::flatbuffers::Offset<reflection::Field>> *fields = nullptr,
0972     bool is_struct = false,
0973     int32_t minalign = 0,
0974     int32_t bytesize = 0,
0975     std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
0976     const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
0977     const char *declaration_file = nullptr) {
0978   auto name__ = name ? _fbb.CreateString(name) : 0;
0979   auto fields__ = fields ? _fbb.CreateVectorOfSortedTables<reflection::Field>(fields) : 0;
0980   auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
0981   auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
0982   auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
0983   return reflection::CreateObject(
0984       _fbb,
0985       name__,
0986       fields__,
0987       is_struct,
0988       minalign,
0989       bytesize,
0990       attributes__,
0991       documentation__,
0992       declaration_file__);
0993 }
0994 
0995 struct RPCCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
0996   typedef RPCCallBuilder Builder;
0997   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
0998     VT_NAME = 4,
0999     VT_REQUEST = 6,
1000     VT_RESPONSE = 8,
1001     VT_ATTRIBUTES = 10,
1002     VT_DOCUMENTATION = 12
1003   };
1004   const ::flatbuffers::String *name() const {
1005     return GetPointer<const ::flatbuffers::String *>(VT_NAME);
1006   }
1007   bool KeyCompareLessThan(const RPCCall * const o) const {
1008     return *name() < *o->name();
1009   }
1010   int KeyCompareWithValue(const char *_name) const {
1011     return strcmp(name()->c_str(), _name);
1012   }
1013   template<typename StringType>
1014   int KeyCompareWithValue(const StringType& _name) const {
1015     if (name()->c_str() < _name) return -1;
1016     if (_name < name()->c_str()) return 1;
1017     return 0;
1018   }
1019   const reflection::Object *request() const {
1020     return GetPointer<const reflection::Object *>(VT_REQUEST);
1021   }
1022   const reflection::Object *response() const {
1023     return GetPointer<const reflection::Object *>(VT_RESPONSE);
1024   }
1025   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
1026     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
1027   }
1028   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
1029     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
1030   }
1031   bool Verify(::flatbuffers::Verifier &verifier) const {
1032     return VerifyTableStart(verifier) &&
1033            VerifyOffsetRequired(verifier, VT_NAME) &&
1034            verifier.VerifyString(name()) &&
1035            VerifyOffsetRequired(verifier, VT_REQUEST) &&
1036            verifier.VerifyTable(request()) &&
1037            VerifyOffsetRequired(verifier, VT_RESPONSE) &&
1038            verifier.VerifyTable(response()) &&
1039            VerifyOffset(verifier, VT_ATTRIBUTES) &&
1040            verifier.VerifyVector(attributes()) &&
1041            verifier.VerifyVectorOfTables(attributes()) &&
1042            VerifyOffset(verifier, VT_DOCUMENTATION) &&
1043            verifier.VerifyVector(documentation()) &&
1044            verifier.VerifyVectorOfStrings(documentation()) &&
1045            verifier.EndTable();
1046   }
1047 };
1048 
1049 struct RPCCallBuilder {
1050   typedef RPCCall Table;
1051   ::flatbuffers::FlatBufferBuilder &fbb_;
1052   ::flatbuffers::uoffset_t start_;
1053   void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
1054     fbb_.AddOffset(RPCCall::VT_NAME, name);
1055   }
1056   void add_request(::flatbuffers::Offset<reflection::Object> request) {
1057     fbb_.AddOffset(RPCCall::VT_REQUEST, request);
1058   }
1059   void add_response(::flatbuffers::Offset<reflection::Object> response) {
1060     fbb_.AddOffset(RPCCall::VT_RESPONSE, response);
1061   }
1062   void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
1063     fbb_.AddOffset(RPCCall::VT_ATTRIBUTES, attributes);
1064   }
1065   void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
1066     fbb_.AddOffset(RPCCall::VT_DOCUMENTATION, documentation);
1067   }
1068   explicit RPCCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1069         : fbb_(_fbb) {
1070     start_ = fbb_.StartTable();
1071   }
1072   ::flatbuffers::Offset<RPCCall> Finish() {
1073     const auto end = fbb_.EndTable(start_);
1074     auto o = ::flatbuffers::Offset<RPCCall>(end);
1075     fbb_.Required(o, RPCCall::VT_NAME);
1076     fbb_.Required(o, RPCCall::VT_REQUEST);
1077     fbb_.Required(o, RPCCall::VT_RESPONSE);
1078     return o;
1079   }
1080 };
1081 
1082 inline ::flatbuffers::Offset<RPCCall> CreateRPCCall(
1083     ::flatbuffers::FlatBufferBuilder &_fbb,
1084     ::flatbuffers::Offset<::flatbuffers::String> name = 0,
1085     ::flatbuffers::Offset<reflection::Object> request = 0,
1086     ::flatbuffers::Offset<reflection::Object> response = 0,
1087     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
1088     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0) {
1089   RPCCallBuilder builder_(_fbb);
1090   builder_.add_documentation(documentation);
1091   builder_.add_attributes(attributes);
1092   builder_.add_response(response);
1093   builder_.add_request(request);
1094   builder_.add_name(name);
1095   return builder_.Finish();
1096 }
1097 
1098 inline ::flatbuffers::Offset<RPCCall> CreateRPCCallDirect(
1099     ::flatbuffers::FlatBufferBuilder &_fbb,
1100     const char *name = nullptr,
1101     ::flatbuffers::Offset<reflection::Object> request = 0,
1102     ::flatbuffers::Offset<reflection::Object> response = 0,
1103     std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
1104     const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr) {
1105   auto name__ = name ? _fbb.CreateString(name) : 0;
1106   auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
1107   auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
1108   return reflection::CreateRPCCall(
1109       _fbb,
1110       name__,
1111       request,
1112       response,
1113       attributes__,
1114       documentation__);
1115 }
1116 
1117 struct Service FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1118   typedef ServiceBuilder Builder;
1119   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1120     VT_NAME = 4,
1121     VT_CALLS = 6,
1122     VT_ATTRIBUTES = 8,
1123     VT_DOCUMENTATION = 10,
1124     VT_DECLARATION_FILE = 12
1125   };
1126   const ::flatbuffers::String *name() const {
1127     return GetPointer<const ::flatbuffers::String *>(VT_NAME);
1128   }
1129   bool KeyCompareLessThan(const Service * const o) const {
1130     return *name() < *o->name();
1131   }
1132   int KeyCompareWithValue(const char *_name) const {
1133     return strcmp(name()->c_str(), _name);
1134   }
1135   template<typename StringType>
1136   int KeyCompareWithValue(const StringType& _name) const {
1137     if (name()->c_str() < _name) return -1;
1138     if (_name < name()->c_str()) return 1;
1139     return 0;
1140   }
1141   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *calls() const {
1142     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *>(VT_CALLS);
1143   }
1144   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
1145     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
1146   }
1147   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
1148     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
1149   }
1150   /// File that this Service is declared in.
1151   const ::flatbuffers::String *declaration_file() const {
1152     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
1153   }
1154   bool Verify(::flatbuffers::Verifier &verifier) const {
1155     return VerifyTableStart(verifier) &&
1156            VerifyOffsetRequired(verifier, VT_NAME) &&
1157            verifier.VerifyString(name()) &&
1158            VerifyOffset(verifier, VT_CALLS) &&
1159            verifier.VerifyVector(calls()) &&
1160            verifier.VerifyVectorOfTables(calls()) &&
1161            VerifyOffset(verifier, VT_ATTRIBUTES) &&
1162            verifier.VerifyVector(attributes()) &&
1163            verifier.VerifyVectorOfTables(attributes()) &&
1164            VerifyOffset(verifier, VT_DOCUMENTATION) &&
1165            verifier.VerifyVector(documentation()) &&
1166            verifier.VerifyVectorOfStrings(documentation()) &&
1167            VerifyOffset(verifier, VT_DECLARATION_FILE) &&
1168            verifier.VerifyString(declaration_file()) &&
1169            verifier.EndTable();
1170   }
1171 };
1172 
1173 struct ServiceBuilder {
1174   typedef Service Table;
1175   ::flatbuffers::FlatBufferBuilder &fbb_;
1176   ::flatbuffers::uoffset_t start_;
1177   void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
1178     fbb_.AddOffset(Service::VT_NAME, name);
1179   }
1180   void add_calls(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>>> calls) {
1181     fbb_.AddOffset(Service::VT_CALLS, calls);
1182   }
1183   void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
1184     fbb_.AddOffset(Service::VT_ATTRIBUTES, attributes);
1185   }
1186   void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
1187     fbb_.AddOffset(Service::VT_DOCUMENTATION, documentation);
1188   }
1189   void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
1190     fbb_.AddOffset(Service::VT_DECLARATION_FILE, declaration_file);
1191   }
1192   explicit ServiceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1193         : fbb_(_fbb) {
1194     start_ = fbb_.StartTable();
1195   }
1196   ::flatbuffers::Offset<Service> Finish() {
1197     const auto end = fbb_.EndTable(start_);
1198     auto o = ::flatbuffers::Offset<Service>(end);
1199     fbb_.Required(o, Service::VT_NAME);
1200     return o;
1201   }
1202 };
1203 
1204 inline ::flatbuffers::Offset<Service> CreateService(
1205     ::flatbuffers::FlatBufferBuilder &_fbb,
1206     ::flatbuffers::Offset<::flatbuffers::String> name = 0,
1207     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>>> calls = 0,
1208     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
1209     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
1210     ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
1211   ServiceBuilder builder_(_fbb);
1212   builder_.add_declaration_file(declaration_file);
1213   builder_.add_documentation(documentation);
1214   builder_.add_attributes(attributes);
1215   builder_.add_calls(calls);
1216   builder_.add_name(name);
1217   return builder_.Finish();
1218 }
1219 
1220 inline ::flatbuffers::Offset<Service> CreateServiceDirect(
1221     ::flatbuffers::FlatBufferBuilder &_fbb,
1222     const char *name = nullptr,
1223     std::vector<::flatbuffers::Offset<reflection::RPCCall>> *calls = nullptr,
1224     std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
1225     const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
1226     const char *declaration_file = nullptr) {
1227   auto name__ = name ? _fbb.CreateString(name) : 0;
1228   auto calls__ = calls ? _fbb.CreateVectorOfSortedTables<reflection::RPCCall>(calls) : 0;
1229   auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
1230   auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
1231   auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
1232   return reflection::CreateService(
1233       _fbb,
1234       name__,
1235       calls__,
1236       attributes__,
1237       documentation__,
1238       declaration_file__);
1239 }
1240 
1241 /// File specific information.
1242 /// Symbols declared within a file may be recovered by iterating over all
1243 /// symbols and examining the `declaration_file` field.
1244 struct SchemaFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1245   typedef SchemaFileBuilder Builder;
1246   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1247     VT_FILENAME = 4,
1248     VT_INCLUDED_FILENAMES = 6
1249   };
1250   /// Filename, relative to project root.
1251   const ::flatbuffers::String *filename() const {
1252     return GetPointer<const ::flatbuffers::String *>(VT_FILENAME);
1253   }
1254   bool KeyCompareLessThan(const SchemaFile * const o) const {
1255     return *filename() < *o->filename();
1256   }
1257   int KeyCompareWithValue(const char *_filename) const {
1258     return strcmp(filename()->c_str(), _filename);
1259   }
1260   template<typename StringType>
1261   int KeyCompareWithValue(const StringType& _filename) const {
1262     if (filename()->c_str() < _filename) return -1;
1263     if (_filename < filename()->c_str()) return 1;
1264     return 0;
1265   }
1266   /// Names of included files, relative to project root.
1267   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames() const {
1268     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INCLUDED_FILENAMES);
1269   }
1270   bool Verify(::flatbuffers::Verifier &verifier) const {
1271     return VerifyTableStart(verifier) &&
1272            VerifyOffsetRequired(verifier, VT_FILENAME) &&
1273            verifier.VerifyString(filename()) &&
1274            VerifyOffset(verifier, VT_INCLUDED_FILENAMES) &&
1275            verifier.VerifyVector(included_filenames()) &&
1276            verifier.VerifyVectorOfStrings(included_filenames()) &&
1277            verifier.EndTable();
1278   }
1279 };
1280 
1281 struct SchemaFileBuilder {
1282   typedef SchemaFile Table;
1283   ::flatbuffers::FlatBufferBuilder &fbb_;
1284   ::flatbuffers::uoffset_t start_;
1285   void add_filename(::flatbuffers::Offset<::flatbuffers::String> filename) {
1286     fbb_.AddOffset(SchemaFile::VT_FILENAME, filename);
1287   }
1288   void add_included_filenames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> included_filenames) {
1289     fbb_.AddOffset(SchemaFile::VT_INCLUDED_FILENAMES, included_filenames);
1290   }
1291   explicit SchemaFileBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1292         : fbb_(_fbb) {
1293     start_ = fbb_.StartTable();
1294   }
1295   ::flatbuffers::Offset<SchemaFile> Finish() {
1296     const auto end = fbb_.EndTable(start_);
1297     auto o = ::flatbuffers::Offset<SchemaFile>(end);
1298     fbb_.Required(o, SchemaFile::VT_FILENAME);
1299     return o;
1300   }
1301 };
1302 
1303 inline ::flatbuffers::Offset<SchemaFile> CreateSchemaFile(
1304     ::flatbuffers::FlatBufferBuilder &_fbb,
1305     ::flatbuffers::Offset<::flatbuffers::String> filename = 0,
1306     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> included_filenames = 0) {
1307   SchemaFileBuilder builder_(_fbb);
1308   builder_.add_included_filenames(included_filenames);
1309   builder_.add_filename(filename);
1310   return builder_.Finish();
1311 }
1312 
1313 inline ::flatbuffers::Offset<SchemaFile> CreateSchemaFileDirect(
1314     ::flatbuffers::FlatBufferBuilder &_fbb,
1315     const char *filename = nullptr,
1316     const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames = nullptr) {
1317   auto filename__ = filename ? _fbb.CreateString(filename) : 0;
1318   auto included_filenames__ = included_filenames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*included_filenames) : 0;
1319   return reflection::CreateSchemaFile(
1320       _fbb,
1321       filename__,
1322       included_filenames__);
1323 }
1324 
1325 struct Schema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1326   typedef SchemaBuilder Builder;
1327   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1328     VT_OBJECTS = 4,
1329     VT_ENUMS = 6,
1330     VT_FILE_IDENT = 8,
1331     VT_FILE_EXT = 10,
1332     VT_ROOT_TABLE = 12,
1333     VT_SERVICES = 14,
1334     VT_ADVANCED_FEATURES = 16,
1335     VT_FBS_FILES = 18
1336   };
1337   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *objects() const {
1338     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *>(VT_OBJECTS);
1339   }
1340   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *enums() const {
1341     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *>(VT_ENUMS);
1342   }
1343   const ::flatbuffers::String *file_ident() const {
1344     return GetPointer<const ::flatbuffers::String *>(VT_FILE_IDENT);
1345   }
1346   const ::flatbuffers::String *file_ext() const {
1347     return GetPointer<const ::flatbuffers::String *>(VT_FILE_EXT);
1348   }
1349   const reflection::Object *root_table() const {
1350     return GetPointer<const reflection::Object *>(VT_ROOT_TABLE);
1351   }
1352   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *services() const {
1353     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *>(VT_SERVICES);
1354   }
1355   reflection::AdvancedFeatures advanced_features() const {
1356     return static_cast<reflection::AdvancedFeatures>(GetField<uint64_t>(VT_ADVANCED_FEATURES, 0));
1357   }
1358   /// All the files used in this compilation. Files are relative to where
1359   /// flatc was invoked.
1360   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files() const {
1361     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *>(VT_FBS_FILES);
1362   }
1363   bool Verify(::flatbuffers::Verifier &verifier) const {
1364     return VerifyTableStart(verifier) &&
1365            VerifyOffsetRequired(verifier, VT_OBJECTS) &&
1366            verifier.VerifyVector(objects()) &&
1367            verifier.VerifyVectorOfTables(objects()) &&
1368            VerifyOffsetRequired(verifier, VT_ENUMS) &&
1369            verifier.VerifyVector(enums()) &&
1370            verifier.VerifyVectorOfTables(enums()) &&
1371            VerifyOffset(verifier, VT_FILE_IDENT) &&
1372            verifier.VerifyString(file_ident()) &&
1373            VerifyOffset(verifier, VT_FILE_EXT) &&
1374            verifier.VerifyString(file_ext()) &&
1375            VerifyOffset(verifier, VT_ROOT_TABLE) &&
1376            verifier.VerifyTable(root_table()) &&
1377            VerifyOffset(verifier, VT_SERVICES) &&
1378            verifier.VerifyVector(services()) &&
1379            verifier.VerifyVectorOfTables(services()) &&
1380            VerifyField<uint64_t>(verifier, VT_ADVANCED_FEATURES, 8) &&
1381            VerifyOffset(verifier, VT_FBS_FILES) &&
1382            verifier.VerifyVector(fbs_files()) &&
1383            verifier.VerifyVectorOfTables(fbs_files()) &&
1384            verifier.EndTable();
1385   }
1386 };
1387 
1388 struct SchemaBuilder {
1389   typedef Schema Table;
1390   ::flatbuffers::FlatBufferBuilder &fbb_;
1391   ::flatbuffers::uoffset_t start_;
1392   void add_objects(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>>> objects) {
1393     fbb_.AddOffset(Schema::VT_OBJECTS, objects);
1394   }
1395   void add_enums(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>>> enums) {
1396     fbb_.AddOffset(Schema::VT_ENUMS, enums);
1397   }
1398   void add_file_ident(::flatbuffers::Offset<::flatbuffers::String> file_ident) {
1399     fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident);
1400   }
1401   void add_file_ext(::flatbuffers::Offset<::flatbuffers::String> file_ext) {
1402     fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext);
1403   }
1404   void add_root_table(::flatbuffers::Offset<reflection::Object> root_table) {
1405     fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table);
1406   }
1407   void add_services(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>>> services) {
1408     fbb_.AddOffset(Schema::VT_SERVICES, services);
1409   }
1410   void add_advanced_features(reflection::AdvancedFeatures advanced_features) {
1411     fbb_.AddElement<uint64_t>(Schema::VT_ADVANCED_FEATURES, static_cast<uint64_t>(advanced_features), 0);
1412   }
1413   void add_fbs_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>>> fbs_files) {
1414     fbb_.AddOffset(Schema::VT_FBS_FILES, fbs_files);
1415   }
1416   explicit SchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1417         : fbb_(_fbb) {
1418     start_ = fbb_.StartTable();
1419   }
1420   ::flatbuffers::Offset<Schema> Finish() {
1421     const auto end = fbb_.EndTable(start_);
1422     auto o = ::flatbuffers::Offset<Schema>(end);
1423     fbb_.Required(o, Schema::VT_OBJECTS);
1424     fbb_.Required(o, Schema::VT_ENUMS);
1425     return o;
1426   }
1427 };
1428 
1429 inline ::flatbuffers::Offset<Schema> CreateSchema(
1430     ::flatbuffers::FlatBufferBuilder &_fbb,
1431     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>>> objects = 0,
1432     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>>> enums = 0,
1433     ::flatbuffers::Offset<::flatbuffers::String> file_ident = 0,
1434     ::flatbuffers::Offset<::flatbuffers::String> file_ext = 0,
1435     ::flatbuffers::Offset<reflection::Object> root_table = 0,
1436     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>>> services = 0,
1437     reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0),
1438     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>>> fbs_files = 0) {
1439   SchemaBuilder builder_(_fbb);
1440   builder_.add_advanced_features(advanced_features);
1441   builder_.add_fbs_files(fbs_files);
1442   builder_.add_services(services);
1443   builder_.add_root_table(root_table);
1444   builder_.add_file_ext(file_ext);
1445   builder_.add_file_ident(file_ident);
1446   builder_.add_enums(enums);
1447   builder_.add_objects(objects);
1448   return builder_.Finish();
1449 }
1450 
1451 inline ::flatbuffers::Offset<Schema> CreateSchemaDirect(
1452     ::flatbuffers::FlatBufferBuilder &_fbb,
1453     std::vector<::flatbuffers::Offset<reflection::Object>> *objects = nullptr,
1454     std::vector<::flatbuffers::Offset<reflection::Enum>> *enums = nullptr,
1455     const char *file_ident = nullptr,
1456     const char *file_ext = nullptr,
1457     ::flatbuffers::Offset<reflection::Object> root_table = 0,
1458     std::vector<::flatbuffers::Offset<reflection::Service>> *services = nullptr,
1459     reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0),
1460     std::vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files = nullptr) {
1461   auto objects__ = objects ? _fbb.CreateVectorOfSortedTables<reflection::Object>(objects) : 0;
1462   auto enums__ = enums ? _fbb.CreateVectorOfSortedTables<reflection::Enum>(enums) : 0;
1463   auto file_ident__ = file_ident ? _fbb.CreateString(file_ident) : 0;
1464   auto file_ext__ = file_ext ? _fbb.CreateString(file_ext) : 0;
1465   auto services__ = services ? _fbb.CreateVectorOfSortedTables<reflection::Service>(services) : 0;
1466   auto fbs_files__ = fbs_files ? _fbb.CreateVectorOfSortedTables<reflection::SchemaFile>(fbs_files) : 0;
1467   return reflection::CreateSchema(
1468       _fbb,
1469       objects__,
1470       enums__,
1471       file_ident__,
1472       file_ext__,
1473       root_table,
1474       services__,
1475       advanced_features,
1476       fbs_files__);
1477 }
1478 
1479 inline const reflection::Schema *GetSchema(const void *buf) {
1480   return ::flatbuffers::GetRoot<reflection::Schema>(buf);
1481 }
1482 
1483 inline const reflection::Schema *GetSizePrefixedSchema(const void *buf) {
1484   return ::flatbuffers::GetSizePrefixedRoot<reflection::Schema>(buf);
1485 }
1486 
1487 inline const char *SchemaIdentifier() {
1488   return "BFBS";
1489 }
1490 
1491 inline bool SchemaBufferHasIdentifier(const void *buf) {
1492   return ::flatbuffers::BufferHasIdentifier(
1493       buf, SchemaIdentifier());
1494 }
1495 
1496 inline bool SizePrefixedSchemaBufferHasIdentifier(const void *buf) {
1497   return ::flatbuffers::BufferHasIdentifier(
1498       buf, SchemaIdentifier(), true);
1499 }
1500 
1501 inline bool VerifySchemaBuffer(
1502     ::flatbuffers::Verifier &verifier) {
1503   return verifier.VerifyBuffer<reflection::Schema>(SchemaIdentifier());
1504 }
1505 
1506 inline bool VerifySizePrefixedSchemaBuffer(
1507     ::flatbuffers::Verifier &verifier) {
1508   return verifier.VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
1509 }
1510 
1511 inline const char *SchemaExtension() {
1512   return "bfbs";
1513 }
1514 
1515 inline void FinishSchemaBuffer(
1516     ::flatbuffers::FlatBufferBuilder &fbb,
1517     ::flatbuffers::Offset<reflection::Schema> root) {
1518   fbb.Finish(root, SchemaIdentifier());
1519 }
1520 
1521 inline void FinishSizePrefixedSchemaBuffer(
1522     ::flatbuffers::FlatBufferBuilder &fbb,
1523     ::flatbuffers::Offset<reflection::Schema> root) {
1524   fbb.FinishSizePrefixed(root, SchemaIdentifier());
1525 }
1526 
1527 }  // namespace reflection
1528 
1529 #endif  // FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!