onert-micro/externals/flatbuffers/reflection_generated.h

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright 2017 Google Inc. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 // automatically generated by the FlatBuffers compiler, do not modify
  18
  19 #ifndef FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
  20 #define FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
  21
  22 #include "flatbuffers/flatbuffers.h"
  23
  24 namespace reflection
  25 {
  26
  27 struct Type;
  28 struct TypeBuilder;
  29
  30 struct KeyValue;
  31 struct KeyValueBuilder;
  32
  33 struct EnumVal;
  34 struct EnumValBuilder;
  35
  36 struct Enum;
  37 struct EnumBuilder;
  38
  39 struct Field;
  40 struct FieldBuilder;
  41
  42 struct Object;
  43 struct ObjectBuilder;
  44
  45 struct RPCCall;
  46 struct RPCCallBuilder;
  47
  48 struct Service;
  49 struct ServiceBuilder;
  50
  51 struct Schema;
  52 struct SchemaBuilder;
  53
  54 enum BaseType
  55 {
  56   None = 0,
  57   UType = 1,
  58   Bool = 2,
  59   Byte = 3,
  60   UByte = 4,
  61   Short = 5,
  62   UShort = 6,
  63   Int = 7,
  64   UInt = 8,
  65   Long = 9,
  66   ULong = 10,
  67   Float = 11,
  68   Double = 12,
  69   String = 13,
  70   Vector = 14,
  71   Obj = 15,
  72   Union = 16,
  73   Array = 17,
  74   MaxBaseType = 18
  75 };
  76
  77 inline const BaseType (&EnumValuesBaseType())[19]
  78 {
  79   static const BaseType values[] = {None,   UType, Bool,  Byte,  UByte,      Short,  UShort,
  80                                     Int,    UInt,  Long,  ULong, Float,      Double, String,
  81                                     Vector, Obj,   Union, Array, MaxBaseType};
  82   return values;
  83 }
  84
  85 inline const char *const *EnumNamesBaseType()
  86 {
  87   static const char *const names[20] = {"None",  "UType",  "Bool",   "Byte",        "UByte",
  88                                         "Short", "UShort", "Int",    "UInt",        "Long",
  89                                         "ULong", "Float",  "Double", "String",      "Vector",
  90                                         "Obj",   "Union",  "Array",  "MaxBaseType", nullptr};
  91   return names;
  92 }
  93
  94 inline const char *EnumNameBaseType(BaseType e)
  95 {
  96   if (flatbuffers::IsOutRange(e, None, MaxBaseType))
  97     return "";
  98   const size_t index = static_cast<size_t>(e);
  99   return EnumNamesBaseType()[index];
 100 }
 101
 102 enum AdvancedFeatures
 103 {
 104   AdvancedArrayFeatures = 1ULL,
 105   AdvancedUnionFeatures = 2ULL,
 106   OptionalScalars = 4ULL,
 107   DefaultVectorsAndStrings = 8ULL
 108 };
 109
 110 inline const AdvancedFeatures (&EnumValuesAdvancedFeatures())[4]
 111 {
 112   static const AdvancedFeatures values[] = {AdvancedArrayFeatures, AdvancedUnionFeatures,
 113                                             OptionalScalars, DefaultVectorsAndStrings};
 114   return values;
 115 }
 116
 117 inline const char *const *EnumNamesAdvancedFeatures()
 118 {
 119   static const char *const names[9] = {"AdvancedArrayFeatures",
 120                                        "AdvancedUnionFeatures",
 121                                        "",
 122                                        "OptionalScalars",
 123                                        "",
 124                                        "",
 125                                        "",
 126                                        "DefaultVectorsAndStrings",
 127                                        nullptr};
 128   return names;
 129 }
 130
 131 inline const char *EnumNameAdvancedFeatures(AdvancedFeatures e)
 132 {
 133   if (flatbuffers::IsOutRange(e, AdvancedArrayFeatures, DefaultVectorsAndStrings))
 134     return "";
 135   const size_t index = static_cast<size_t>(e) - static_cast<size_t>(AdvancedArrayFeatures);
 136   return EnumNamesAdvancedFeatures()[index];
 137 }
 138
 139 struct Type FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 140 {
 141   typedef TypeBuilder Builder;
 142   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 143   {
 144     VT_BASE_TYPE = 4,
 145     VT_ELEMENT = 6,
 146     VT_INDEX = 8,
 147     VT_FIXED_LENGTH = 10
 148   };
 149   reflection::BaseType base_type() const
 150   {
 151     return static_cast<reflection::BaseType>(GetField<int8_t>(VT_BASE_TYPE, 0));
 152   }
 153   reflection::BaseType element() const
 154   {
 155     return static_cast<reflection::BaseType>(GetField<int8_t>(VT_ELEMENT, 0));
 156   }
 157   int32_t index() const { return GetField<int32_t>(VT_INDEX, -1); }
 158   uint16_t fixed_length() const { return GetField<uint16_t>(VT_FIXED_LENGTH, 0); }
 159   bool Verify(flatbuffers::Verifier &verifier) const
 160   {
 161     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_BASE_TYPE) &&
 162            VerifyField<int8_t>(verifier, VT_ELEMENT) && VerifyField<int32_t>(verifier, VT_INDEX) &&
 163            VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH) && verifier.EndTable();
 164   }
 165 };
 166
 167 struct TypeBuilder
 168 {
 169   typedef Type Table;
 170   flatbuffers::FlatBufferBuilder &fbb_;
 171   flatbuffers::uoffset_t start_;
 172   void add_base_type(reflection::BaseType base_type)
 173   {
 174     fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0);
 175   }
 176   void add_element(reflection::BaseType element)
 177   {
 178     fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0);
 179   }
 180   void add_index(int32_t index) { fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1); }
 181   void add_fixed_length(uint16_t fixed_length)
 182   {
 183     fbb_.AddElement<uint16_t>(Type::VT_FIXED_LENGTH, fixed_length, 0);
 184   }
 185   explicit TypeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
 186   {
 187     start_ = fbb_.StartTable();
 188   }
 189   flatbuffers::Offset<Type> Finish()
 190   {
 191     const auto end = fbb_.EndTable(start_);
 192     auto o = flatbuffers::Offset<Type>(end);
 193     return o;
 194   }
 195 };
 196
 197 inline flatbuffers::Offset<Type> CreateType(flatbuffers::FlatBufferBuilder &_fbb,
 198                                             reflection::BaseType base_type = reflection::None,
 199                                             reflection::BaseType element = reflection::None,
 200                                             int32_t index = -1, uint16_t fixed_length = 0)
 201 {
 202   TypeBuilder builder_(_fbb);
 203   builder_.add_index(index);
 204   builder_.add_fixed_length(fixed_length);
 205   builder_.add_element(element);
 206   builder_.add_base_type(base_type);
 207   return builder_.Finish();
 208 }
 209
 210 struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 211 {
 212   typedef KeyValueBuilder Builder;
 213   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 214   {
 215     VT_KEY = 4,
 216     VT_VALUE = 6
 217   };
 218   const flatbuffers::String *key() const { return GetPointer<const flatbuffers::String *>(VT_KEY); }
 219   bool KeyCompareLessThan(const KeyValue *o) const { return *key() < *o->key(); }
 220   int KeyCompareWithValue(const char *val) const { return strcmp(key()->c_str(), val); }
 221   const flatbuffers::String *value() const
 222   {
 223     return GetPointer<const flatbuffers::String *>(VT_VALUE);
 224   }
 225   bool Verify(flatbuffers::Verifier &verifier) const
 226   {
 227     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_KEY) &&
 228            verifier.VerifyString(key()) && VerifyOffset(verifier, VT_VALUE) &&
 229            verifier.VerifyString(value()) && verifier.EndTable();
 230   }
 231 };
 232
 233 struct KeyValueBuilder
 234 {
 235   typedef KeyValue Table;
 236   flatbuffers::FlatBufferBuilder &fbb_;
 237   flatbuffers::uoffset_t start_;
 238   void add_key(flatbuffers::Offset<flatbuffers::String> key)
 239   {
 240     fbb_.AddOffset(KeyValue::VT_KEY, key);
 241   }
 242   void add_value(flatbuffers::Offset<flatbuffers::String> value)
 243   {
 244     fbb_.AddOffset(KeyValue::VT_VALUE, value);
 245   }
 246   explicit KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
 247   {
 248     start_ = fbb_.StartTable();
 249   }
 250   flatbuffers::Offset<KeyValue> Finish()
 251   {
 252     const auto end = fbb_.EndTable(start_);
 253     auto o = flatbuffers::Offset<KeyValue>(end);
 254     fbb_.Required(o, KeyValue::VT_KEY);
 255     return o;
 256   }
 257 };
 258
 259 inline flatbuffers::Offset<KeyValue>
 260 CreateKeyValue(flatbuffers::FlatBufferBuilder &_fbb,
 261                flatbuffers::Offset<flatbuffers::String> key = 0,
 262                flatbuffers::Offset<flatbuffers::String> value = 0)
 263 {
 264   KeyValueBuilder builder_(_fbb);
 265   builder_.add_value(value);
 266   builder_.add_key(key);
 267   return builder_.Finish();
 268 }
 269
 270 inline flatbuffers::Offset<KeyValue> CreateKeyValueDirect(flatbuffers::FlatBufferBuilder &_fbb,
 271                                                           const char *key = nullptr,
 272                                                           const char *value = nullptr)
 273 {
 274   auto key__ = key ? _fbb.CreateString(key) : 0;
 275   auto value__ = value ? _fbb.CreateString(value) : 0;
 276   return reflection::CreateKeyValue(_fbb, key__, value__);
 277 }
 278
 279 struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 280 {
 281   typedef EnumValBuilder Builder;
 282   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 283   {
 284     VT_NAME = 4,
 285     VT_VALUE = 6,
 286     VT_OBJECT = 8,
 287     VT_UNION_TYPE = 10,
 288     VT_DOCUMENTATION = 12
 289   };
 290   const flatbuffers::String *name() const
 291   {
 292     return GetPointer<const flatbuffers::String *>(VT_NAME);
 293   }
 294   int64_t value() const { return GetField<int64_t>(VT_VALUE, 0); }
 295   bool KeyCompareLessThan(const EnumVal *o) const { return value() < o->value(); }
 296   int KeyCompareWithValue(int64_t val) const
 297   {
 298     return static_cast<int>(value() > val) - static_cast<int>(value() < val);
 299   }
 300   const reflection::Object *object() const
 301   {
 302     return GetPointer<const reflection::Object *>(VT_OBJECT);
 303   }
 304   const reflection::Type *union_type() const
 305   {
 306     return GetPointer<const reflection::Type *>(VT_UNION_TYPE);
 307   }
 308   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *documentation() const
 309   {
 310     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
 311       VT_DOCUMENTATION);
 312   }
 313   bool Verify(flatbuffers::Verifier &verifier) const
 314   {
 315     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_NAME) &&
 316            verifier.VerifyString(name()) && VerifyField<int64_t>(verifier, VT_VALUE) &&
 317            VerifyOffset(verifier, VT_OBJECT) && verifier.VerifyTable(object()) &&
 318            VerifyOffset(verifier, VT_UNION_TYPE) && verifier.VerifyTable(union_type()) &&
 319            VerifyOffset(verifier, VT_DOCUMENTATION) && verifier.VerifyVector(documentation()) &&
 320            verifier.VerifyVectorOfStrings(documentation()) && verifier.EndTable();
 321   }
 322 };
 323
 324 struct EnumValBuilder
 325 {
 326   typedef EnumVal Table;
 327   flatbuffers::FlatBufferBuilder &fbb_;
 328   flatbuffers::uoffset_t start_;
 329   void add_name(flatbuffers::Offset<flatbuffers::String> name)
 330   {
 331     fbb_.AddOffset(EnumVal::VT_NAME, name);
 332   }
 333   void add_value(int64_t value) { fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0); }
 334   void add_object(flatbuffers::Offset<reflection::Object> object)
 335   {
 336     fbb_.AddOffset(EnumVal::VT_OBJECT, object);
 337   }
 338   void add_union_type(flatbuffers::Offset<reflection::Type> union_type)
 339   {
 340     fbb_.AddOffset(EnumVal::VT_UNION_TYPE, union_type);
 341   }
 342   void add_documentation(
 343     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
 344       documentation)
 345   {
 346     fbb_.AddOffset(EnumVal::VT_DOCUMENTATION, documentation);
 347   }
 348   explicit EnumValBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
 349   {
 350     start_ = fbb_.StartTable();
 351   }
 352   flatbuffers::Offset<EnumVal> Finish()
 353   {
 354     const auto end = fbb_.EndTable(start_);
 355     auto o = flatbuffers::Offset<EnumVal>(end);
 356     fbb_.Required(o, EnumVal::VT_NAME);
 357     return o;
 358   }
 359 };
 360
 361 inline flatbuffers::Offset<EnumVal> CreateEnumVal(
 362   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> name = 0,
 363   int64_t value = 0, flatbuffers::Offset<reflection::Object> object = 0,
 364   flatbuffers::Offset<reflection::Type> union_type = 0,
 365   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> documentation =
 366     0)
 367 {
 368   EnumValBuilder builder_(_fbb);
 369   builder_.add_value(value);
 370   builder_.add_documentation(documentation);
 371   builder_.add_union_type(union_type);
 372   builder_.add_object(object);
 373   builder_.add_name(name);
 374   return builder_.Finish();
 375 }
 376
 377 inline flatbuffers::Offset<EnumVal> CreateEnumValDirect(
 378   flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, int64_t value = 0,
 379   flatbuffers::Offset<reflection::Object> object = 0,
 380   flatbuffers::Offset<reflection::Type> union_type = 0,
 381   const std::vector<flatbuffers::Offset<flatbuffers::String>> *documentation = nullptr)
 382 {
 383   auto name__ = name ? _fbb.CreateString(name) : 0;
 384   auto documentation__ =
 385     documentation ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*documentation) : 0;
 386   return reflection::CreateEnumVal(_fbb, name__, value, object, union_type, documentation__);
 387 }
 388
 389 struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 390 {
 391   typedef EnumBuilder Builder;
 392   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 393   {
 394     VT_NAME = 4,
 395     VT_VALUES = 6,
 396     VT_IS_UNION = 8,
 397     VT_UNDERLYING_TYPE = 10,
 398     VT_ATTRIBUTES = 12,
 399     VT_DOCUMENTATION = 14
 400   };
 401   const flatbuffers::String *name() const
 402   {
 403     return GetPointer<const flatbuffers::String *>(VT_NAME);
 404   }
 405   bool KeyCompareLessThan(const Enum *o) const { return *name() < *o->name(); }
 406   int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }
 407   const flatbuffers::Vector<flatbuffers::Offset<reflection::EnumVal>> *values() const
 408   {
 409     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::EnumVal>> *>(
 410       VT_VALUES);
 411   }
 412   bool is_union() const { return GetField<uint8_t>(VT_IS_UNION, 0) != 0; }
 413   const reflection::Type *underlying_type() const
 414   {
 415     return GetPointer<const reflection::Type *>(VT_UNDERLYING_TYPE);
 416   }
 417   const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *attributes() const
 418   {
 419     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *>(
 420       VT_ATTRIBUTES);
 421   }
 422   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *documentation() const
 423   {
 424     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
 425       VT_DOCUMENTATION);
 426   }
 427   bool Verify(flatbuffers::Verifier &verifier) const
 428   {
 429     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_NAME) &&
 430            verifier.VerifyString(name()) && VerifyOffsetRequired(verifier, VT_VALUES) &&
 431            verifier.VerifyVector(values()) && verifier.VerifyVectorOfTables(values()) &&
 432            VerifyField<uint8_t>(verifier, VT_IS_UNION) &&
 433            VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
 434            verifier.VerifyTable(underlying_type()) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
 435            verifier.VerifyVector(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
 436            VerifyOffset(verifier, VT_DOCUMENTATION) && verifier.VerifyVector(documentation()) &&
 437            verifier.VerifyVectorOfStrings(documentation()) && verifier.EndTable();
 438   }
 439 };
 440
 441 struct EnumBuilder
 442 {
 443   typedef Enum Table;
 444   flatbuffers::FlatBufferBuilder &fbb_;
 445   flatbuffers::uoffset_t start_;
 446   void add_name(flatbuffers::Offset<flatbuffers::String> name)
 447   {
 448     fbb_.AddOffset(Enum::VT_NAME, name);
 449   }
 450   void add_values(
 451     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::EnumVal>>> values)
 452   {
 453     fbb_.AddOffset(Enum::VT_VALUES, values);
 454   }
 455   void add_is_union(bool is_union)
 456   {
 457     fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0);
 458   }
 459   void add_underlying_type(flatbuffers::Offset<reflection::Type> underlying_type)
 460   {
 461     fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type);
 462   }
 463   void add_attributes(
 464     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes)
 465   {
 466     fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes);
 467   }
 468   void add_documentation(
 469     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
 470       documentation)
 471   {
 472     fbb_.AddOffset(Enum::VT_DOCUMENTATION, documentation);
 473   }
 474   explicit EnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
 475   {
 476     start_ = fbb_.StartTable();
 477   }
 478   flatbuffers::Offset<Enum> Finish()
 479   {
 480     const auto end = fbb_.EndTable(start_);
 481     auto o = flatbuffers::Offset<Enum>(end);
 482     fbb_.Required(o, Enum::VT_NAME);
 483     fbb_.Required(o, Enum::VT_VALUES);
 484     fbb_.Required(o, Enum::VT_UNDERLYING_TYPE);
 485     return o;
 486   }
 487 };
 488
 489 inline flatbuffers::Offset<Enum> CreateEnum(
 490   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> name = 0,
 491   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::EnumVal>>> values = 0,
 492   bool is_union = false, flatbuffers::Offset<reflection::Type> underlying_type = 0,
 493   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes =
 494     0,
 495   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> documentation =
 496     0)
 497 {
 498   EnumBuilder builder_(_fbb);
 499   builder_.add_documentation(documentation);
 500   builder_.add_attributes(attributes);
 501   builder_.add_underlying_type(underlying_type);
 502   builder_.add_values(values);
 503   builder_.add_name(name);
 504   builder_.add_is_union(is_union);
 505   return builder_.Finish();
 506 }
 507
 508 inline flatbuffers::Offset<Enum> CreateEnumDirect(
 509   flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr,
 510   std::vector<flatbuffers::Offset<reflection::EnumVal>> *values = nullptr, bool is_union = false,
 511   flatbuffers::Offset<reflection::Type> underlying_type = 0,
 512   std::vector<flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
 513   const std::vector<flatbuffers::Offset<flatbuffers::String>> *documentation = nullptr)
 514 {
 515   auto name__ = name ? _fbb.CreateString(name) : 0;
 516   auto values__ = values ? _fbb.CreateVectorOfSortedTables<reflection::EnumVal>(values) : 0;
 517   auto attributes__ =
 518     attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
 519   auto documentation__ =
 520     documentation ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*documentation) : 0;
 521   return reflection::CreateEnum(_fbb, name__, values__, is_union, underlying_type, attributes__,
 522                                 documentation__);
 523 }
 524
 525 struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 526 {
 527   typedef FieldBuilder Builder;
 528   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 529   {
 530     VT_NAME = 4,
 531     VT_TYPE = 6,
 532     VT_ID = 8,
 533     VT_OFFSET = 10,
 534     VT_DEFAULT_INTEGER = 12,
 535     VT_DEFAULT_REAL = 14,
 536     VT_DEPRECATED = 16,
 537     VT_REQUIRED = 18,
 538     VT_KEY = 20,
 539     VT_ATTRIBUTES = 22,
 540     VT_DOCUMENTATION = 24,
 541     VT_OPTIONAL = 26
 542   };
 543   const flatbuffers::String *name() const
 544   {
 545     return GetPointer<const flatbuffers::String *>(VT_NAME);
 546   }
 547   bool KeyCompareLessThan(const Field *o) const { return *name() < *o->name(); }
 548   int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }
 549   const reflection::Type *type() const { return GetPointer<const reflection::Type *>(VT_TYPE); }
 550   uint16_t id() const { return GetField<uint16_t>(VT_ID, 0); }
 551   uint16_t offset() const { return GetField<uint16_t>(VT_OFFSET, 0); }
 552   int64_t default_integer() const { return GetField<int64_t>(VT_DEFAULT_INTEGER, 0); }
 553   double default_real() const { return GetField<double>(VT_DEFAULT_REAL, 0.0); }
 554   bool deprecated() const { return GetField<uint8_t>(VT_DEPRECATED, 0) != 0; }
 555   bool required() const { return GetField<uint8_t>(VT_REQUIRED, 0) != 0; }
 556   bool key() const { return GetField<uint8_t>(VT_KEY, 0) != 0; }
 557   const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *attributes() const
 558   {
 559     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *>(
 560       VT_ATTRIBUTES);
 561   }
 562   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *documentation() const
 563   {
 564     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
 565       VT_DOCUMENTATION);
 566   }
 567   bool optional() const { return GetField<uint8_t>(VT_OPTIONAL, 0) != 0; }
 568   bool Verify(flatbuffers::Verifier &verifier) const
 569   {
 570     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_NAME) &&
 571            verifier.VerifyString(name()) && VerifyOffsetRequired(verifier, VT_TYPE) &&
 572            verifier.VerifyTable(type()) && VerifyField<uint16_t>(verifier, VT_ID) &&
 573            VerifyField<uint16_t>(verifier, VT_OFFSET) &&
 574            VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER) &&
 575            VerifyField<double>(verifier, VT_DEFAULT_REAL) &&
 576            VerifyField<uint8_t>(verifier, VT_DEPRECATED) &&
 577            VerifyField<uint8_t>(verifier, VT_REQUIRED) && VerifyField<uint8_t>(verifier, VT_KEY) &&
 578            VerifyOffset(verifier, VT_ATTRIBUTES) && verifier.VerifyVector(attributes()) &&
 579            verifier.VerifyVectorOfTables(attributes()) &&
 580            VerifyOffset(verifier, VT_DOCUMENTATION) && verifier.VerifyVector(documentation()) &&
 581            verifier.VerifyVectorOfStrings(documentation()) &&
 582            VerifyField<uint8_t>(verifier, VT_OPTIONAL) && verifier.EndTable();
 583   }
 584 };
 585
 586 struct FieldBuilder
 587 {
 588   typedef Field Table;
 589   flatbuffers::FlatBufferBuilder &fbb_;
 590   flatbuffers::uoffset_t start_;
 591   void add_name(flatbuffers::Offset<flatbuffers::String> name)
 592   {
 593     fbb_.AddOffset(Field::VT_NAME, name);
 594   }
 595   void add_type(flatbuffers::Offset<reflection::Type> type)
 596   {
 597     fbb_.AddOffset(Field::VT_TYPE, type);
 598   }
 599   void add_id(uint16_t id) { fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0); }
 600   void add_offset(uint16_t offset) { fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0); }
 601   void add_default_integer(int64_t default_integer)
 602   {
 603     fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0);
 604   }
 605   void add_default_real(double default_real)
 606   {
 607     fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0);
 608   }
 609   void add_deprecated(bool deprecated)
 610   {
 611     fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0);
 612   }
 613   void add_required(bool required)
 614   {
 615     fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0);
 616   }
 617   void add_key(bool key) { fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0); }
 618   void add_attributes(
 619     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes)
 620   {
 621     fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes);
 622   }
 623   void add_documentation(
 624     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
 625       documentation)
 626   {
 627     fbb_.AddOffset(Field::VT_DOCUMENTATION, documentation);
 628   }
 629   void add_optional(bool optional)
 630   {
 631     fbb_.AddElement<uint8_t>(Field::VT_OPTIONAL, static_cast<uint8_t>(optional), 0);
 632   }
 633   explicit FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
 634   {
 635     start_ = fbb_.StartTable();
 636   }
 637   flatbuffers::Offset<Field> Finish()
 638   {
 639     const auto end = fbb_.EndTable(start_);
 640     auto o = flatbuffers::Offset<Field>(end);
 641     fbb_.Required(o, Field::VT_NAME);
 642     fbb_.Required(o, Field::VT_TYPE);
 643     return o;
 644   }
 645 };
 646
 647 inline flatbuffers::Offset<Field> CreateField(
 648   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> name = 0,
 649   flatbuffers::Offset<reflection::Type> type = 0, uint16_t id = 0, uint16_t offset = 0,
 650   int64_t default_integer = 0, double default_real = 0.0, bool deprecated = false,
 651   bool required = false, bool key = false,
 652   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes =
 653     0,
 654   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> documentation =
 655     0,
 656   bool optional = false)
 657 {
 658   FieldBuilder builder_(_fbb);
 659   builder_.add_default_real(default_real);
 660   builder_.add_default_integer(default_integer);
 661   builder_.add_documentation(documentation);
 662   builder_.add_attributes(attributes);
 663   builder_.add_type(type);
 664   builder_.add_name(name);
 665   builder_.add_offset(offset);
 666   builder_.add_id(id);
 667   builder_.add_optional(optional);
 668   builder_.add_key(key);
 669   builder_.add_required(required);
 670   builder_.add_deprecated(deprecated);
 671   return builder_.Finish();
 672 }
 673
 674 inline flatbuffers::Offset<Field> CreateFieldDirect(
 675   flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr,
 676   flatbuffers::Offset<reflection::Type> type = 0, uint16_t id = 0, uint16_t offset = 0,
 677   int64_t default_integer = 0, double default_real = 0.0, bool deprecated = false,
 678   bool required = false, bool key = false,
 679   std::vector<flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
 680   const std::vector<flatbuffers::Offset<flatbuffers::String>> *documentation = nullptr,
 681   bool optional = false)
 682 {
 683   auto name__ = name ? _fbb.CreateString(name) : 0;
 684   auto attributes__ =
 685     attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
 686   auto documentation__ =
 687     documentation ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*documentation) : 0;
 688   return reflection::CreateField(_fbb, name__, type, id, offset, default_integer, default_real,
 689                                  deprecated, required, key, attributes__, documentation__,
 690                                  optional);
 691 }
 692
 693 struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 694 {
 695   typedef ObjectBuilder Builder;
 696   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 697   {
 698     VT_NAME = 4,
 699     VT_FIELDS = 6,
 700     VT_IS_STRUCT = 8,
 701     VT_MINALIGN = 10,
 702     VT_BYTESIZE = 12,
 703     VT_ATTRIBUTES = 14,
 704     VT_DOCUMENTATION = 16
 705   };
 706   const flatbuffers::String *name() const
 707   {
 708     return GetPointer<const flatbuffers::String *>(VT_NAME);
 709   }
 710   bool KeyCompareLessThan(const Object *o) const { return *name() < *o->name(); }
 711   int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }
 712   const flatbuffers::Vector<flatbuffers::Offset<reflection::Field>> *fields() const
 713   {
 714     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::Field>> *>(
 715       VT_FIELDS);
 716   }
 717   bool is_struct() const { return GetField<uint8_t>(VT_IS_STRUCT, 0) != 0; }
 718   int32_t minalign() const { return GetField<int32_t>(VT_MINALIGN, 0); }
 719   int32_t bytesize() const { return GetField<int32_t>(VT_BYTESIZE, 0); }
 720   const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *attributes() const
 721   {
 722     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *>(
 723       VT_ATTRIBUTES);
 724   }
 725   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *documentation() const
 726   {
 727     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
 728       VT_DOCUMENTATION);
 729   }
 730   bool Verify(flatbuffers::Verifier &verifier) const
 731   {
 732     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_NAME) &&
 733            verifier.VerifyString(name()) && VerifyOffsetRequired(verifier, VT_FIELDS) &&
 734            verifier.VerifyVector(fields()) && verifier.VerifyVectorOfTables(fields()) &&
 735            VerifyField<uint8_t>(verifier, VT_IS_STRUCT) &&
 736            VerifyField<int32_t>(verifier, VT_MINALIGN) &&
 737            VerifyField<int32_t>(verifier, VT_BYTESIZE) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
 738            verifier.VerifyVector(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
 739            VerifyOffset(verifier, VT_DOCUMENTATION) && verifier.VerifyVector(documentation()) &&
 740            verifier.VerifyVectorOfStrings(documentation()) && verifier.EndTable();
 741   }
 742 };
 743
 744 struct ObjectBuilder
 745 {
 746   typedef Object Table;
 747   flatbuffers::FlatBufferBuilder &fbb_;
 748   flatbuffers::uoffset_t start_;
 749   void add_name(flatbuffers::Offset<flatbuffers::String> name)
 750   {
 751     fbb_.AddOffset(Object::VT_NAME, name);
 752   }
 753   void add_fields(
 754     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Field>>> fields)
 755   {
 756     fbb_.AddOffset(Object::VT_FIELDS, fields);
 757   }
 758   void add_is_struct(bool is_struct)
 759   {
 760     fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0);
 761   }
 762   void add_minalign(int32_t minalign)
 763   {
 764     fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0);
 765   }
 766   void add_bytesize(int32_t bytesize)
 767   {
 768     fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0);
 769   }
 770   void add_attributes(
 771     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes)
 772   {
 773     fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes);
 774   }
 775   void add_documentation(
 776     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
 777       documentation)
 778   {
 779     fbb_.AddOffset(Object::VT_DOCUMENTATION, documentation);
 780   }
 781   explicit ObjectBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
 782   {
 783     start_ = fbb_.StartTable();
 784   }
 785   flatbuffers::Offset<Object> Finish()
 786   {
 787     const auto end = fbb_.EndTable(start_);
 788     auto o = flatbuffers::Offset<Object>(end);
 789     fbb_.Required(o, Object::VT_NAME);
 790     fbb_.Required(o, Object::VT_FIELDS);
 791     return o;
 792   }
 793 };
 794
 795 inline flatbuffers::Offset<Object> CreateObject(
 796   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> name = 0,
 797   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Field>>> fields = 0,
 798   bool is_struct = false, int32_t minalign = 0, int32_t bytesize = 0,
 799   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes =
 800     0,
 801   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> documentation =
 802     0)
 803 {
 804   ObjectBuilder builder_(_fbb);
 805   builder_.add_documentation(documentation);
 806   builder_.add_attributes(attributes);
 807   builder_.add_bytesize(bytesize);
 808   builder_.add_minalign(minalign);
 809   builder_.add_fields(fields);
 810   builder_.add_name(name);
 811   builder_.add_is_struct(is_struct);
 812   return builder_.Finish();
 813 }
 814
 815 inline flatbuffers::Offset<Object> CreateObjectDirect(
 816   flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr,
 817   std::vector<flatbuffers::Offset<reflection::Field>> *fields = nullptr, bool is_struct = false,
 818   int32_t minalign = 0, int32_t bytesize = 0,
 819   std::vector<flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
 820   const std::vector<flatbuffers::Offset<flatbuffers::String>> *documentation = nullptr)
 821 {
 822   auto name__ = name ? _fbb.CreateString(name) : 0;
 823   auto fields__ = fields ? _fbb.CreateVectorOfSortedTables<reflection::Field>(fields) : 0;
 824   auto attributes__ =
 825     attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
 826   auto documentation__ =
 827     documentation ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*documentation) : 0;
 828   return reflection::CreateObject(_fbb, name__, fields__, is_struct, minalign, bytesize,
 829                                   attributes__, documentation__);
 830 }
 831
 832 struct RPCCall FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 833 {
 834   typedef RPCCallBuilder Builder;
 835   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 836   {
 837     VT_NAME = 4,
 838     VT_REQUEST = 6,
 839     VT_RESPONSE = 8,
 840     VT_ATTRIBUTES = 10,
 841     VT_DOCUMENTATION = 12
 842   };
 843   const flatbuffers::String *name() const
 844   {
 845     return GetPointer<const flatbuffers::String *>(VT_NAME);
 846   }
 847   bool KeyCompareLessThan(const RPCCall *o) const { return *name() < *o->name(); }
 848   int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }
 849   const reflection::Object *request() const
 850   {
 851     return GetPointer<const reflection::Object *>(VT_REQUEST);
 852   }
 853   const reflection::Object *response() const
 854   {
 855     return GetPointer<const reflection::Object *>(VT_RESPONSE);
 856   }
 857   const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *attributes() const
 858   {
 859     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *>(
 860       VT_ATTRIBUTES);
 861   }
 862   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *documentation() const
 863   {
 864     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
 865       VT_DOCUMENTATION);
 866   }
 867   bool Verify(flatbuffers::Verifier &verifier) const
 868   {
 869     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_NAME) &&
 870            verifier.VerifyString(name()) && VerifyOffsetRequired(verifier, VT_REQUEST) &&
 871            verifier.VerifyTable(request()) && VerifyOffsetRequired(verifier, VT_RESPONSE) &&
 872            verifier.VerifyTable(response()) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
 873            verifier.VerifyVector(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
 874            VerifyOffset(verifier, VT_DOCUMENTATION) && verifier.VerifyVector(documentation()) &&
 875            verifier.VerifyVectorOfStrings(documentation()) && verifier.EndTable();
 876   }
 877 };
 878
 879 struct RPCCallBuilder
 880 {
 881   typedef RPCCall Table;
 882   flatbuffers::FlatBufferBuilder &fbb_;
 883   flatbuffers::uoffset_t start_;
 884   void add_name(flatbuffers::Offset<flatbuffers::String> name)
 885   {
 886     fbb_.AddOffset(RPCCall::VT_NAME, name);
 887   }
 888   void add_request(flatbuffers::Offset<reflection::Object> request)
 889   {
 890     fbb_.AddOffset(RPCCall::VT_REQUEST, request);
 891   }
 892   void add_response(flatbuffers::Offset<reflection::Object> response)
 893   {
 894     fbb_.AddOffset(RPCCall::VT_RESPONSE, response);
 895   }
 896   void add_attributes(
 897     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes)
 898   {
 899     fbb_.AddOffset(RPCCall::VT_ATTRIBUTES, attributes);
 900   }
 901   void add_documentation(
 902     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
 903       documentation)
 904   {
 905     fbb_.AddOffset(RPCCall::VT_DOCUMENTATION, documentation);
 906   }
 907   explicit RPCCallBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
 908   {
 909     start_ = fbb_.StartTable();
 910   }
 911   flatbuffers::Offset<RPCCall> Finish()
 912   {
 913     const auto end = fbb_.EndTable(start_);
 914     auto o = flatbuffers::Offset<RPCCall>(end);
 915     fbb_.Required(o, RPCCall::VT_NAME);
 916     fbb_.Required(o, RPCCall::VT_REQUEST);
 917     fbb_.Required(o, RPCCall::VT_RESPONSE);
 918     return o;
 919   }
 920 };
 921
 922 inline flatbuffers::Offset<RPCCall> CreateRPCCall(
 923   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> name = 0,
 924   flatbuffers::Offset<reflection::Object> request = 0,
 925   flatbuffers::Offset<reflection::Object> response = 0,
 926   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes =
 927     0,
 928   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> documentation =
 929     0)
 930 {
 931   RPCCallBuilder builder_(_fbb);
 932   builder_.add_documentation(documentation);
 933   builder_.add_attributes(attributes);
 934   builder_.add_response(response);
 935   builder_.add_request(request);
 936   builder_.add_name(name);
 937   return builder_.Finish();
 938 }
 939
 940 inline flatbuffers::Offset<RPCCall> CreateRPCCallDirect(
 941   flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr,
 942   flatbuffers::Offset<reflection::Object> request = 0,
 943   flatbuffers::Offset<reflection::Object> response = 0,
 944   std::vector<flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
 945   const std::vector<flatbuffers::Offset<flatbuffers::String>> *documentation = nullptr)
 946 {
 947   auto name__ = name ? _fbb.CreateString(name) : 0;
 948   auto attributes__ =
 949     attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
 950   auto documentation__ =
 951     documentation ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*documentation) : 0;
 952   return reflection::CreateRPCCall(_fbb, name__, request, response, attributes__, documentation__);
 953 }
 954
 955 struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 956 {
 957   typedef ServiceBuilder Builder;
 958   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 959   {
 960     VT_NAME = 4,
 961     VT_CALLS = 6,
 962     VT_ATTRIBUTES = 8,
 963     VT_DOCUMENTATION = 10
 964   };
 965   const flatbuffers::String *name() const
 966   {
 967     return GetPointer<const flatbuffers::String *>(VT_NAME);
 968   }
 969   bool KeyCompareLessThan(const Service *o) const { return *name() < *o->name(); }
 970   int KeyCompareWithValue(const char *val) const { return strcmp(name()->c_str(), val); }
 971   const flatbuffers::Vector<flatbuffers::Offset<reflection::RPCCall>> *calls() const
 972   {
 973     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::RPCCall>> *>(
 974       VT_CALLS);
 975   }
 976   const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *attributes() const
 977   {
 978     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>> *>(
 979       VT_ATTRIBUTES);
 980   }
 981   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *documentation() const
 982   {
 983     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
 984       VT_DOCUMENTATION);
 985   }
 986   bool Verify(flatbuffers::Verifier &verifier) const
 987   {
 988     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_NAME) &&
 989            verifier.VerifyString(name()) && VerifyOffset(verifier, VT_CALLS) &&
 990            verifier.VerifyVector(calls()) && verifier.VerifyVectorOfTables(calls()) &&
 991            VerifyOffset(verifier, VT_ATTRIBUTES) && verifier.VerifyVector(attributes()) &&
 992            verifier.VerifyVectorOfTables(attributes()) &&
 993            VerifyOffset(verifier, VT_DOCUMENTATION) && verifier.VerifyVector(documentation()) &&
 994            verifier.VerifyVectorOfStrings(documentation()) && verifier.EndTable();
 995   }
 996 };
 997
 998 struct ServiceBuilder
 999 {
1000   typedef Service Table;
1001   flatbuffers::FlatBufferBuilder &fbb_;
1002   flatbuffers::uoffset_t start_;
1003   void add_name(flatbuffers::Offset<flatbuffers::String> name)
1004   {
1005     fbb_.AddOffset(Service::VT_NAME, name);
1006   }
1007   void add_calls(
1008     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::RPCCall>>> calls)
1009   {
1010     fbb_.AddOffset(Service::VT_CALLS, calls);
1011   }
1012   void add_attributes(
1013     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes)
1014   {
1015     fbb_.AddOffset(Service::VT_ATTRIBUTES, attributes);
1016   }
1017   void add_documentation(
1018     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
1019       documentation)
1020   {
1021     fbb_.AddOffset(Service::VT_DOCUMENTATION, documentation);
1022   }
1023   explicit ServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
1024   {
1025     start_ = fbb_.StartTable();
1026   }
1027   flatbuffers::Offset<Service> Finish()
1028   {
1029     const auto end = fbb_.EndTable(start_);
1030     auto o = flatbuffers::Offset<Service>(end);
1031     fbb_.Required(o, Service::VT_NAME);
1032     return o;
1033   }
1034 };
1035
1036 inline flatbuffers::Offset<Service> CreateService(
1037   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> name = 0,
1038   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::RPCCall>>> calls = 0,
1039   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>> attributes =
1040     0,
1041   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> documentation =
1042     0)
1043 {
1044   ServiceBuilder builder_(_fbb);
1045   builder_.add_documentation(documentation);
1046   builder_.add_attributes(attributes);
1047   builder_.add_calls(calls);
1048   builder_.add_name(name);
1049   return builder_.Finish();
1050 }
1051
1052 inline flatbuffers::Offset<Service> CreateServiceDirect(
1053   flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr,
1054   std::vector<flatbuffers::Offset<reflection::RPCCall>> *calls = nullptr,
1055   std::vector<flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
1056   const std::vector<flatbuffers::Offset<flatbuffers::String>> *documentation = nullptr)
1057 {
1058   auto name__ = name ? _fbb.CreateString(name) : 0;
1059   auto calls__ = calls ? _fbb.CreateVectorOfSortedTables<reflection::RPCCall>(calls) : 0;
1060   auto attributes__ =
1061     attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
1062   auto documentation__ =
1063     documentation ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*documentation) : 0;
1064   return reflection::CreateService(_fbb, name__, calls__, attributes__, documentation__);
1065 }
1066
1067 struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
1068 {
1069   typedef SchemaBuilder Builder;
1070   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
1071   {
1072     VT_OBJECTS = 4,
1073     VT_ENUMS = 6,
1074     VT_FILE_IDENT = 8,
1075     VT_FILE_EXT = 10,
1076     VT_ROOT_TABLE = 12,
1077     VT_SERVICES = 14,
1078     VT_ADVANCED_FEATURES = 16
1079   };
1080   const flatbuffers::Vector<flatbuffers::Offset<reflection::Object>> *objects() const
1081   {
1082     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::Object>> *>(
1083       VT_OBJECTS);
1084   }
1085   const flatbuffers::Vector<flatbuffers::Offset<reflection::Enum>> *enums() const
1086   {
1087     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::Enum>> *>(VT_ENUMS);
1088   }
1089   const flatbuffers::String *file_ident() const
1090   {
1091     return GetPointer<const flatbuffers::String *>(VT_FILE_IDENT);
1092   }
1093   const flatbuffers::String *file_ext() const
1094   {
1095     return GetPointer<const flatbuffers::String *>(VT_FILE_EXT);
1096   }
1097   const reflection::Object *root_table() const
1098   {
1099     return GetPointer<const reflection::Object *>(VT_ROOT_TABLE);
1100   }
1101   const flatbuffers::Vector<flatbuffers::Offset<reflection::Service>> *services() const
1102   {
1103     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<reflection::Service>> *>(
1104       VT_SERVICES);
1105   }
1106   reflection::AdvancedFeatures advanced_features() const
1107   {
1108     return static_cast<reflection::AdvancedFeatures>(GetField<uint64_t>(VT_ADVANCED_FEATURES, 0));
1109   }
1110   bool Verify(flatbuffers::Verifier &verifier) const
1111   {
1112     return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_OBJECTS) &&
1113            verifier.VerifyVector(objects()) && verifier.VerifyVectorOfTables(objects()) &&
1114            VerifyOffsetRequired(verifier, VT_ENUMS) && verifier.VerifyVector(enums()) &&
1115            verifier.VerifyVectorOfTables(enums()) && VerifyOffset(verifier, VT_FILE_IDENT) &&
1116            verifier.VerifyString(file_ident()) && VerifyOffset(verifier, VT_FILE_EXT) &&
1117            verifier.VerifyString(file_ext()) && VerifyOffset(verifier, VT_ROOT_TABLE) &&
1118            verifier.VerifyTable(root_table()) && VerifyOffset(verifier, VT_SERVICES) &&
1119            verifier.VerifyVector(services()) && verifier.VerifyVectorOfTables(services()) &&
1120            VerifyField<uint64_t>(verifier, VT_ADVANCED_FEATURES) && verifier.EndTable();
1121   }
1122 };
1123
1124 struct SchemaBuilder
1125 {
1126   typedef Schema Table;
1127   flatbuffers::FlatBufferBuilder &fbb_;
1128   flatbuffers::uoffset_t start_;
1129   void add_objects(
1130     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Object>>> objects)
1131   {
1132     fbb_.AddOffset(Schema::VT_OBJECTS, objects);
1133   }
1134   void
1135   add_enums(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Enum>>> enums)
1136   {
1137     fbb_.AddOffset(Schema::VT_ENUMS, enums);
1138   }
1139   void add_file_ident(flatbuffers::Offset<flatbuffers::String> file_ident)
1140   {
1141     fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident);
1142   }
1143   void add_file_ext(flatbuffers::Offset<flatbuffers::String> file_ext)
1144   {
1145     fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext);
1146   }
1147   void add_root_table(flatbuffers::Offset<reflection::Object> root_table)
1148   {
1149     fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table);
1150   }
1151   void add_services(
1152     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Service>>> services)
1153   {
1154     fbb_.AddOffset(Schema::VT_SERVICES, services);
1155   }
1156   void add_advanced_features(reflection::AdvancedFeatures advanced_features)
1157   {
1158     fbb_.AddElement<uint64_t>(Schema::VT_ADVANCED_FEATURES,
1159                               static_cast<uint64_t>(advanced_features), 0);
1160   }
1161   explicit SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
1162   {
1163     start_ = fbb_.StartTable();
1164   }
1165   flatbuffers::Offset<Schema> Finish()
1166   {
1167     const auto end = fbb_.EndTable(start_);
1168     auto o = flatbuffers::Offset<Schema>(end);
1169     fbb_.Required(o, Schema::VT_OBJECTS);
1170     fbb_.Required(o, Schema::VT_ENUMS);
1171     return o;
1172   }
1173 };
1174
1175 inline flatbuffers::Offset<Schema> CreateSchema(
1176   flatbuffers::FlatBufferBuilder &_fbb,
1177   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Object>>> objects = 0,
1178   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Enum>>> enums = 0,
1179   flatbuffers::Offset<flatbuffers::String> file_ident = 0,
1180   flatbuffers::Offset<flatbuffers::String> file_ext = 0,
1181   flatbuffers::Offset<reflection::Object> root_table = 0,
1182   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Service>>> services = 0,
1183   reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0))
1184 {
1185   SchemaBuilder builder_(_fbb);
1186   builder_.add_advanced_features(advanced_features);
1187   builder_.add_services(services);
1188   builder_.add_root_table(root_table);
1189   builder_.add_file_ext(file_ext);
1190   builder_.add_file_ident(file_ident);
1191   builder_.add_enums(enums);
1192   builder_.add_objects(objects);
1193   return builder_.Finish();
1194 }
1195
1196 inline flatbuffers::Offset<Schema> CreateSchemaDirect(
1197   flatbuffers::FlatBufferBuilder &_fbb,
1198   std::vector<flatbuffers::Offset<reflection::Object>> *objects = nullptr,
1199   std::vector<flatbuffers::Offset<reflection::Enum>> *enums = nullptr,
1200   const char *file_ident = nullptr, const char *file_ext = nullptr,
1201   flatbuffers::Offset<reflection::Object> root_table = 0,
1202   std::vector<flatbuffers::Offset<reflection::Service>> *services = nullptr,
1203   reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0))
1204 {
1205   auto objects__ = objects ? _fbb.CreateVectorOfSortedTables<reflection::Object>(objects) : 0;
1206   auto enums__ = enums ? _fbb.CreateVectorOfSortedTables<reflection::Enum>(enums) : 0;
1207   auto file_ident__ = file_ident ? _fbb.CreateString(file_ident) : 0;
1208   auto file_ext__ = file_ext ? _fbb.CreateString(file_ext) : 0;
1209   auto services__ = services ? _fbb.CreateVectorOfSortedTables<reflection::Service>(services) : 0;
1210   return reflection::CreateSchema(_fbb, objects__, enums__, file_ident__, file_ext__, root_table,
1211                                   services__, advanced_features);
1212 }
1213
1214 inline const reflection::Schema *GetSchema(const void *buf)
1215 {
1216   return flatbuffers::GetRoot<reflection::Schema>(buf);
1217 }
1218
1219 inline const reflection::Schema *GetSizePrefixedSchema(const void *buf)
1220 {
1221   return flatbuffers::GetSizePrefixedRoot<reflection::Schema>(buf);
1222 }
1223
1224 inline const char *SchemaIdentifier() { return "BFBS"; }
1225
1226 inline bool SchemaBufferHasIdentifier(const void *buf)
1227 {
1228   return flatbuffers::BufferHasIdentifier(buf, SchemaIdentifier());
1229 }
1230
1231 inline bool VerifySchemaBuffer(flatbuffers::Verifier &verifier)
1232 {
1233   return verifier.VerifyBuffer<reflection::Schema>(SchemaIdentifier());
1234 }
1235
1236 inline bool VerifySizePrefixedSchemaBuffer(flatbuffers::Verifier &verifier)
1237 {
1238   return verifier.VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
1239 }
1240
1241 inline const char *SchemaExtension() { return "bfbs"; }
1242
1243 inline void FinishSchemaBuffer(flatbuffers::FlatBufferBuilder &fbb,
1244                                flatbuffers::Offset<reflection::Schema> root)
1245 {
1246   fbb.Finish(root, SchemaIdentifier());
1247 }
1248
1249 inline void FinishSizePrefixedSchemaBuffer(flatbuffers::FlatBufferBuilder &fbb,
1250                                            flatbuffers::Offset<reflection::Schema> root)
1251 {
1252   fbb.FinishSizePrefixed(root, SchemaIdentifier());
1253 }
1254
1255 } // namespace reflection
1256
1257 #endif // FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_