1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
5 #define FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
12 FLATBUFFERS_VERSION_MINOR == 1 &&
13 FLATBUFFERS_VERSION_REVISION == 24,
14 "Non-compatible flatbuffers version included");
15
16 namespace reflection {
17
18 struct Type;
19 struct TypeBuilder;
20
21 struct KeyValue;
22 struct KeyValueBuilder;
23
24 struct EnumVal;
25 struct EnumValBuilder;
26
27 struct Enum;
28 struct EnumBuilder;
29
30 struct Field;
31 struct FieldBuilder;
32
33 struct Object;
34 struct ObjectBuilder;
35
36 struct RPCCall;
37 struct RPCCallBuilder;
38
39 struct Service;
40 struct ServiceBuilder;
41
42 struct SchemaFile;
43 struct SchemaFileBuilder;
44
45 struct Schema;
46 struct SchemaBuilder;
47
48 enum BaseType {
49 None = 0,
50 UType = 1,
51 Bool = 2,
52 Byte = 3,
53 UByte = 4,
54 Short = 5,
55 UShort = 6,
56 Int = 7,
57 UInt = 8,
58 Long = 9,
59 ULong = 10,
60 Float = 11,
61 Double = 12,
62 String = 13,
63 Vector = 14,
64 Obj = 15,
65 Union = 16,
66 Array = 17,
67 Vector64 = 18,
68 MaxBaseType = 19
69 };
70
EnumValuesBaseType()71 inline const BaseType (&EnumValuesBaseType())[20] {
72 static const BaseType values[] = {
73 None,
74 UType,
75 Bool,
76 Byte,
77 UByte,
78 Short,
79 UShort,
80 Int,
81 UInt,
82 Long,
83 ULong,
84 Float,
85 Double,
86 String,
87 Vector,
88 Obj,
89 Union,
90 Array,
91 Vector64,
92 MaxBaseType
93 };
94 return values;
95 }
96
EnumNamesBaseType()97 inline const char * const *EnumNamesBaseType() {
98 static const char * const names[21] = {
99 "None",
100 "UType",
101 "Bool",
102 "Byte",
103 "UByte",
104 "Short",
105 "UShort",
106 "Int",
107 "UInt",
108 "Long",
109 "ULong",
110 "Float",
111 "Double",
112 "String",
113 "Vector",
114 "Obj",
115 "Union",
116 "Array",
117 "Vector64",
118 "MaxBaseType",
119 nullptr
120 };
121 return names;
122 }
123
EnumNameBaseType(BaseType e)124 inline const char *EnumNameBaseType(BaseType e) {
125 if (::flatbuffers::IsOutRange(e, None, MaxBaseType)) return "";
126 const size_t index = static_cast<size_t>(e);
127 return EnumNamesBaseType()[index];
128 }
129
130 /// New schema language features that are not supported by old code generators.
131 enum AdvancedFeatures {
132 AdvancedArrayFeatures = 1ULL,
133 AdvancedUnionFeatures = 2ULL,
134 OptionalScalars = 4ULL,
135 DefaultVectorsAndStrings = 8ULL
136 };
137
EnumValuesAdvancedFeatures()138 inline const AdvancedFeatures (&EnumValuesAdvancedFeatures())[4] {
139 static const AdvancedFeatures values[] = {
140 AdvancedArrayFeatures,
141 AdvancedUnionFeatures,
142 OptionalScalars,
143 DefaultVectorsAndStrings
144 };
145 return values;
146 }
147
EnumNamesAdvancedFeatures()148 inline const char * const *EnumNamesAdvancedFeatures() {
149 static const char * const names[9] = {
150 "AdvancedArrayFeatures",
151 "AdvancedUnionFeatures",
152 "",
153 "OptionalScalars",
154 "",
155 "",
156 "",
157 "DefaultVectorsAndStrings",
158 nullptr
159 };
160 return names;
161 }
162
EnumNameAdvancedFeatures(AdvancedFeatures e)163 inline const char *EnumNameAdvancedFeatures(AdvancedFeatures e) {
164 if (::flatbuffers::IsOutRange(e, AdvancedArrayFeatures, DefaultVectorsAndStrings)) return "";
165 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(AdvancedArrayFeatures);
166 return EnumNamesAdvancedFeatures()[index];
167 }
168
169 struct Type FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
170 typedef TypeBuilder Builder;
171 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
172 VT_BASE_TYPE = 4,
173 VT_ELEMENT = 6,
174 VT_INDEX = 8,
175 VT_FIXED_LENGTH = 10,
176 VT_BASE_SIZE = 12,
177 VT_ELEMENT_SIZE = 14
178 };
base_typeFLATBUFFERS_FINAL_CLASS179 reflection::BaseType base_type() const {
180 return static_cast<reflection::BaseType>(GetField<int8_t>(VT_BASE_TYPE, 0));
181 }
elementFLATBUFFERS_FINAL_CLASS182 reflection::BaseType element() const {
183 return static_cast<reflection::BaseType>(GetField<int8_t>(VT_ELEMENT, 0));
184 }
indexFLATBUFFERS_FINAL_CLASS185 int32_t index() const {
186 return GetField<int32_t>(VT_INDEX, -1);
187 }
fixed_lengthFLATBUFFERS_FINAL_CLASS188 uint16_t fixed_length() const {
189 return GetField<uint16_t>(VT_FIXED_LENGTH, 0);
190 }
191 /// The size (octets) of the `base_type` field.
base_sizeFLATBUFFERS_FINAL_CLASS192 uint32_t base_size() const {
193 return GetField<uint32_t>(VT_BASE_SIZE, 4);
194 }
195 /// The size (octets) of the `element` field, if present.
element_sizeFLATBUFFERS_FINAL_CLASS196 uint32_t element_size() const {
197 return GetField<uint32_t>(VT_ELEMENT_SIZE, 0);
198 }
VerifyFLATBUFFERS_FINAL_CLASS199 bool Verify(::flatbuffers::Verifier &verifier) const {
200 return VerifyTableStart(verifier) &&
201 VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
202 VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
203 VerifyField<int32_t>(verifier, VT_INDEX, 4) &&
204 VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH, 2) &&
205 VerifyField<uint32_t>(verifier, VT_BASE_SIZE, 4) &&
206 VerifyField<uint32_t>(verifier, VT_ELEMENT_SIZE, 4) &&
207 verifier.EndTable();
208 }
209 };
210
211 struct TypeBuilder {
212 typedef Type Table;
213 ::flatbuffers::FlatBufferBuilder &fbb_;
214 ::flatbuffers::uoffset_t start_;
add_base_typeTypeBuilder215 void add_base_type(reflection::BaseType base_type) {
216 fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0);
217 }
add_elementTypeBuilder218 void add_element(reflection::BaseType element) {
219 fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0);
220 }
add_indexTypeBuilder221 void add_index(int32_t index) {
222 fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1);
223 }
add_fixed_lengthTypeBuilder224 void add_fixed_length(uint16_t fixed_length) {
225 fbb_.AddElement<uint16_t>(Type::VT_FIXED_LENGTH, fixed_length, 0);
226 }
add_base_sizeTypeBuilder227 void add_base_size(uint32_t base_size) {
228 fbb_.AddElement<uint32_t>(Type::VT_BASE_SIZE, base_size, 4);
229 }
add_element_sizeTypeBuilder230 void add_element_size(uint32_t element_size) {
231 fbb_.AddElement<uint32_t>(Type::VT_ELEMENT_SIZE, element_size, 0);
232 }
TypeBuilderTypeBuilder233 explicit TypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
234 : fbb_(_fbb) {
235 start_ = fbb_.StartTable();
236 }
FinishTypeBuilder237 ::flatbuffers::Offset<Type> Finish() {
238 const auto end = fbb_.EndTable(start_);
239 auto o = ::flatbuffers::Offset<Type>(end);
240 return o;
241 }
242 };
243
244 inline ::flatbuffers::Offset<Type> CreateType(
245 ::flatbuffers::FlatBufferBuilder &_fbb,
246 reflection::BaseType base_type = reflection::None,
247 reflection::BaseType element = reflection::None,
248 int32_t index = -1,
249 uint16_t fixed_length = 0,
250 uint32_t base_size = 4,
251 uint32_t element_size = 0) {
252 TypeBuilder builder_(_fbb);
253 builder_.add_element_size(element_size);
254 builder_.add_base_size(base_size);
255 builder_.add_index(index);
256 builder_.add_fixed_length(fixed_length);
257 builder_.add_element(element);
258 builder_.add_base_type(base_type);
259 return builder_.Finish();
260 }
261
262 struct KeyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
263 typedef KeyValueBuilder Builder;
264 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
265 VT_KEY = 4,
266 VT_VALUE = 6
267 };
keyFLATBUFFERS_FINAL_CLASS268 const ::flatbuffers::String *key() const {
269 return GetPointer<const ::flatbuffers::String *>(VT_KEY);
270 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS271 bool KeyCompareLessThan(const KeyValue * const o) const {
272 return *key() < *o->key();
273 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS274 int KeyCompareWithValue(const char *_key) const {
275 return strcmp(key()->c_str(), _key);
276 }
277 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS278 int KeyCompareWithValue(const StringType& _key) const {
279 if (key()->c_str() < _key) return -1;
280 if (_key < key()->c_str()) return 1;
281 return 0;
282 }
valueFLATBUFFERS_FINAL_CLASS283 const ::flatbuffers::String *value() const {
284 return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
285 }
VerifyFLATBUFFERS_FINAL_CLASS286 bool Verify(::flatbuffers::Verifier &verifier) const {
287 return VerifyTableStart(verifier) &&
288 VerifyOffsetRequired(verifier, VT_KEY) &&
289 verifier.VerifyString(key()) &&
290 VerifyOffset(verifier, VT_VALUE) &&
291 verifier.VerifyString(value()) &&
292 verifier.EndTable();
293 }
294 };
295
296 struct KeyValueBuilder {
297 typedef KeyValue Table;
298 ::flatbuffers::FlatBufferBuilder &fbb_;
299 ::flatbuffers::uoffset_t start_;
add_keyKeyValueBuilder300 void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
301 fbb_.AddOffset(KeyValue::VT_KEY, key);
302 }
add_valueKeyValueBuilder303 void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
304 fbb_.AddOffset(KeyValue::VT_VALUE, value);
305 }
KeyValueBuilderKeyValueBuilder306 explicit KeyValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
307 : fbb_(_fbb) {
308 start_ = fbb_.StartTable();
309 }
FinishKeyValueBuilder310 ::flatbuffers::Offset<KeyValue> Finish() {
311 const auto end = fbb_.EndTable(start_);
312 auto o = ::flatbuffers::Offset<KeyValue>(end);
313 fbb_.Required(o, KeyValue::VT_KEY);
314 return o;
315 }
316 };
317
318 inline ::flatbuffers::Offset<KeyValue> CreateKeyValue(
319 ::flatbuffers::FlatBufferBuilder &_fbb,
320 ::flatbuffers::Offset<::flatbuffers::String> key = 0,
321 ::flatbuffers::Offset<::flatbuffers::String> value = 0) {
322 KeyValueBuilder builder_(_fbb);
323 builder_.add_value(value);
324 builder_.add_key(key);
325 return builder_.Finish();
326 }
327
328 inline ::flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
329 ::flatbuffers::FlatBufferBuilder &_fbb,
330 const char *key = nullptr,
331 const char *value = nullptr) {
332 auto key__ = key ? _fbb.CreateString(key) : 0;
333 auto value__ = value ? _fbb.CreateString(value) : 0;
334 return reflection::CreateKeyValue(
335 _fbb,
336 key__,
337 value__);
338 }
339
340 struct EnumVal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
341 typedef EnumValBuilder Builder;
342 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
343 VT_NAME = 4,
344 VT_VALUE = 6,
345 VT_UNION_TYPE = 10,
346 VT_DOCUMENTATION = 12,
347 VT_ATTRIBUTES = 14
348 };
nameFLATBUFFERS_FINAL_CLASS349 const ::flatbuffers::String *name() const {
350 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
351 }
valueFLATBUFFERS_FINAL_CLASS352 int64_t value() const {
353 return GetField<int64_t>(VT_VALUE, 0);
354 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS355 bool KeyCompareLessThan(const EnumVal * const o) const {
356 return value() < o->value();
357 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS358 int KeyCompareWithValue(int64_t _value) const {
359 return static_cast<int>(value() > _value) - static_cast<int>(value() < _value);
360 }
union_typeFLATBUFFERS_FINAL_CLASS361 const reflection::Type *union_type() const {
362 return GetPointer<const reflection::Type *>(VT_UNION_TYPE);
363 }
documentationFLATBUFFERS_FINAL_CLASS364 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
365 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
366 }
attributesFLATBUFFERS_FINAL_CLASS367 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
368 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
369 }
VerifyFLATBUFFERS_FINAL_CLASS370 bool Verify(::flatbuffers::Verifier &verifier) const {
371 return VerifyTableStart(verifier) &&
372 VerifyOffsetRequired(verifier, VT_NAME) &&
373 verifier.VerifyString(name()) &&
374 VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
375 VerifyOffset(verifier, VT_UNION_TYPE) &&
376 verifier.VerifyTable(union_type()) &&
377 VerifyOffset(verifier, VT_DOCUMENTATION) &&
378 verifier.VerifyVector(documentation()) &&
379 verifier.VerifyVectorOfStrings(documentation()) &&
380 VerifyOffset(verifier, VT_ATTRIBUTES) &&
381 verifier.VerifyVector(attributes()) &&
382 verifier.VerifyVectorOfTables(attributes()) &&
383 verifier.EndTable();
384 }
385 };
386
387 struct EnumValBuilder {
388 typedef EnumVal Table;
389 ::flatbuffers::FlatBufferBuilder &fbb_;
390 ::flatbuffers::uoffset_t start_;
add_nameEnumValBuilder391 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
392 fbb_.AddOffset(EnumVal::VT_NAME, name);
393 }
add_valueEnumValBuilder394 void add_value(int64_t value) {
395 fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0);
396 }
add_union_typeEnumValBuilder397 void add_union_type(::flatbuffers::Offset<reflection::Type> union_type) {
398 fbb_.AddOffset(EnumVal::VT_UNION_TYPE, union_type);
399 }
add_documentationEnumValBuilder400 void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
401 fbb_.AddOffset(EnumVal::VT_DOCUMENTATION, documentation);
402 }
add_attributesEnumValBuilder403 void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
404 fbb_.AddOffset(EnumVal::VT_ATTRIBUTES, attributes);
405 }
EnumValBuilderEnumValBuilder406 explicit EnumValBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
407 : fbb_(_fbb) {
408 start_ = fbb_.StartTable();
409 }
FinishEnumValBuilder410 ::flatbuffers::Offset<EnumVal> Finish() {
411 const auto end = fbb_.EndTable(start_);
412 auto o = ::flatbuffers::Offset<EnumVal>(end);
413 fbb_.Required(o, EnumVal::VT_NAME);
414 return o;
415 }
416 };
417
418 inline ::flatbuffers::Offset<EnumVal> CreateEnumVal(
419 ::flatbuffers::FlatBufferBuilder &_fbb,
420 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
421 int64_t value = 0,
422 ::flatbuffers::Offset<reflection::Type> union_type = 0,
423 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
424 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0) {
425 EnumValBuilder builder_(_fbb);
426 builder_.add_value(value);
427 builder_.add_attributes(attributes);
428 builder_.add_documentation(documentation);
429 builder_.add_union_type(union_type);
430 builder_.add_name(name);
431 return builder_.Finish();
432 }
433
434 inline ::flatbuffers::Offset<EnumVal> CreateEnumValDirect(
435 ::flatbuffers::FlatBufferBuilder &_fbb,
436 const char *name = nullptr,
437 int64_t value = 0,
438 ::flatbuffers::Offset<reflection::Type> union_type = 0,
439 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
440 std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr) {
441 auto name__ = name ? _fbb.CreateString(name) : 0;
442 auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
443 auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
444 return reflection::CreateEnumVal(
445 _fbb,
446 name__,
447 value,
448 union_type,
449 documentation__,
450 attributes__);
451 }
452
453 struct Enum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
454 typedef EnumBuilder Builder;
455 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
456 VT_NAME = 4,
457 VT_VALUES = 6,
458 VT_IS_UNION = 8,
459 VT_UNDERLYING_TYPE = 10,
460 VT_ATTRIBUTES = 12,
461 VT_DOCUMENTATION = 14,
462 VT_DECLARATION_FILE = 16
463 };
nameFLATBUFFERS_FINAL_CLASS464 const ::flatbuffers::String *name() const {
465 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
466 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS467 bool KeyCompareLessThan(const Enum * const o) const {
468 return *name() < *o->name();
469 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS470 int KeyCompareWithValue(const char *_name) const {
471 return strcmp(name()->c_str(), _name);
472 }
473 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS474 int KeyCompareWithValue(const StringType& _name) const {
475 if (name()->c_str() < _name) return -1;
476 if (_name < name()->c_str()) return 1;
477 return 0;
478 }
valuesFLATBUFFERS_FINAL_CLASS479 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *values() const {
480 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *>(VT_VALUES);
481 }
is_unionFLATBUFFERS_FINAL_CLASS482 bool is_union() const {
483 return GetField<uint8_t>(VT_IS_UNION, 0) != 0;
484 }
underlying_typeFLATBUFFERS_FINAL_CLASS485 const reflection::Type *underlying_type() const {
486 return GetPointer<const reflection::Type *>(VT_UNDERLYING_TYPE);
487 }
attributesFLATBUFFERS_FINAL_CLASS488 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
489 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
490 }
documentationFLATBUFFERS_FINAL_CLASS491 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
492 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
493 }
494 /// File that this Enum is declared in.
declaration_fileFLATBUFFERS_FINAL_CLASS495 const ::flatbuffers::String *declaration_file() const {
496 return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
497 }
VerifyFLATBUFFERS_FINAL_CLASS498 bool Verify(::flatbuffers::Verifier &verifier) const {
499 return VerifyTableStart(verifier) &&
500 VerifyOffsetRequired(verifier, VT_NAME) &&
501 verifier.VerifyString(name()) &&
502 VerifyOffsetRequired(verifier, VT_VALUES) &&
503 verifier.VerifyVector(values()) &&
504 verifier.VerifyVectorOfTables(values()) &&
505 VerifyField<uint8_t>(verifier, VT_IS_UNION, 1) &&
506 VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
507 verifier.VerifyTable(underlying_type()) &&
508 VerifyOffset(verifier, VT_ATTRIBUTES) &&
509 verifier.VerifyVector(attributes()) &&
510 verifier.VerifyVectorOfTables(attributes()) &&
511 VerifyOffset(verifier, VT_DOCUMENTATION) &&
512 verifier.VerifyVector(documentation()) &&
513 verifier.VerifyVectorOfStrings(documentation()) &&
514 VerifyOffset(verifier, VT_DECLARATION_FILE) &&
515 verifier.VerifyString(declaration_file()) &&
516 verifier.EndTable();
517 }
518 };
519
520 struct EnumBuilder {
521 typedef Enum Table;
522 ::flatbuffers::FlatBufferBuilder &fbb_;
523 ::flatbuffers::uoffset_t start_;
add_nameEnumBuilder524 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
525 fbb_.AddOffset(Enum::VT_NAME, name);
526 }
add_valuesEnumBuilder527 void add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values) {
528 fbb_.AddOffset(Enum::VT_VALUES, values);
529 }
add_is_unionEnumBuilder530 void add_is_union(bool is_union) {
531 fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0);
532 }
add_underlying_typeEnumBuilder533 void add_underlying_type(::flatbuffers::Offset<reflection::Type> underlying_type) {
534 fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type);
535 }
add_attributesEnumBuilder536 void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
537 fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes);
538 }
add_documentationEnumBuilder539 void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
540 fbb_.AddOffset(Enum::VT_DOCUMENTATION, documentation);
541 }
add_declaration_fileEnumBuilder542 void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
543 fbb_.AddOffset(Enum::VT_DECLARATION_FILE, declaration_file);
544 }
EnumBuilderEnumBuilder545 explicit EnumBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
546 : fbb_(_fbb) {
547 start_ = fbb_.StartTable();
548 }
FinishEnumBuilder549 ::flatbuffers::Offset<Enum> Finish() {
550 const auto end = fbb_.EndTable(start_);
551 auto o = ::flatbuffers::Offset<Enum>(end);
552 fbb_.Required(o, Enum::VT_NAME);
553 fbb_.Required(o, Enum::VT_VALUES);
554 fbb_.Required(o, Enum::VT_UNDERLYING_TYPE);
555 return o;
556 }
557 };
558
559 inline ::flatbuffers::Offset<Enum> CreateEnum(
560 ::flatbuffers::FlatBufferBuilder &_fbb,
561 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
562 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values = 0,
563 bool is_union = false,
564 ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
565 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
566 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
567 ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
568 EnumBuilder builder_(_fbb);
569 builder_.add_declaration_file(declaration_file);
570 builder_.add_documentation(documentation);
571 builder_.add_attributes(attributes);
572 builder_.add_underlying_type(underlying_type);
573 builder_.add_values(values);
574 builder_.add_name(name);
575 builder_.add_is_union(is_union);
576 return builder_.Finish();
577 }
578
579 inline ::flatbuffers::Offset<Enum> CreateEnumDirect(
580 ::flatbuffers::FlatBufferBuilder &_fbb,
581 const char *name = nullptr,
582 std::vector<::flatbuffers::Offset<reflection::EnumVal>> *values = nullptr,
583 bool is_union = false,
584 ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
585 std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
586 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
587 const char *declaration_file = nullptr) {
588 auto name__ = name ? _fbb.CreateString(name) : 0;
589 auto values__ = values ? _fbb.CreateVectorOfSortedTables<reflection::EnumVal>(values) : 0;
590 auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
591 auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
592 auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
593 return reflection::CreateEnum(
594 _fbb,
595 name__,
596 values__,
597 is_union,
598 underlying_type,
599 attributes__,
600 documentation__,
601 declaration_file__);
602 }
603
604 struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
605 typedef FieldBuilder Builder;
606 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
607 VT_NAME = 4,
608 VT_TYPE = 6,
609 VT_ID = 8,
610 VT_OFFSET = 10,
611 VT_DEFAULT_INTEGER = 12,
612 VT_DEFAULT_REAL = 14,
613 VT_DEPRECATED = 16,
614 VT_REQUIRED = 18,
615 VT_KEY = 20,
616 VT_ATTRIBUTES = 22,
617 VT_DOCUMENTATION = 24,
618 VT_OPTIONAL = 26,
619 VT_PADDING = 28,
620 VT_OFFSET64 = 30
621 };
nameFLATBUFFERS_FINAL_CLASS622 const ::flatbuffers::String *name() const {
623 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
624 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS625 bool KeyCompareLessThan(const Field * const o) const {
626 return *name() < *o->name();
627 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS628 int KeyCompareWithValue(const char *_name) const {
629 return strcmp(name()->c_str(), _name);
630 }
631 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS632 int KeyCompareWithValue(const StringType& _name) const {
633 if (name()->c_str() < _name) return -1;
634 if (_name < name()->c_str()) return 1;
635 return 0;
636 }
typeFLATBUFFERS_FINAL_CLASS637 const reflection::Type *type() const {
638 return GetPointer<const reflection::Type *>(VT_TYPE);
639 }
idFLATBUFFERS_FINAL_CLASS640 uint16_t id() const {
641 return GetField<uint16_t>(VT_ID, 0);
642 }
offsetFLATBUFFERS_FINAL_CLASS643 uint16_t offset() const {
644 return GetField<uint16_t>(VT_OFFSET, 0);
645 }
default_integerFLATBUFFERS_FINAL_CLASS646 int64_t default_integer() const {
647 return GetField<int64_t>(VT_DEFAULT_INTEGER, 0);
648 }
default_realFLATBUFFERS_FINAL_CLASS649 double default_real() const {
650 return GetField<double>(VT_DEFAULT_REAL, 0.0);
651 }
deprecatedFLATBUFFERS_FINAL_CLASS652 bool deprecated() const {
653 return GetField<uint8_t>(VT_DEPRECATED, 0) != 0;
654 }
requiredFLATBUFFERS_FINAL_CLASS655 bool required() const {
656 return GetField<uint8_t>(VT_REQUIRED, 0) != 0;
657 }
keyFLATBUFFERS_FINAL_CLASS658 bool key() const {
659 return GetField<uint8_t>(VT_KEY, 0) != 0;
660 }
attributesFLATBUFFERS_FINAL_CLASS661 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
662 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
663 }
documentationFLATBUFFERS_FINAL_CLASS664 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
665 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
666 }
optionalFLATBUFFERS_FINAL_CLASS667 bool optional() const {
668 return GetField<uint8_t>(VT_OPTIONAL, 0) != 0;
669 }
670 /// Number of padding octets to always add after this field. Structs only.
paddingFLATBUFFERS_FINAL_CLASS671 uint16_t padding() const {
672 return GetField<uint16_t>(VT_PADDING, 0);
673 }
674 /// If the field uses 64-bit offsets.
offset64FLATBUFFERS_FINAL_CLASS675 bool offset64() const {
676 return GetField<uint8_t>(VT_OFFSET64, 0) != 0;
677 }
VerifyFLATBUFFERS_FINAL_CLASS678 bool Verify(::flatbuffers::Verifier &verifier) const {
679 return VerifyTableStart(verifier) &&
680 VerifyOffsetRequired(verifier, VT_NAME) &&
681 verifier.VerifyString(name()) &&
682 VerifyOffsetRequired(verifier, VT_TYPE) &&
683 verifier.VerifyTable(type()) &&
684 VerifyField<uint16_t>(verifier, VT_ID, 2) &&
685 VerifyField<uint16_t>(verifier, VT_OFFSET, 2) &&
686 VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER, 8) &&
687 VerifyField<double>(verifier, VT_DEFAULT_REAL, 8) &&
688 VerifyField<uint8_t>(verifier, VT_DEPRECATED, 1) &&
689 VerifyField<uint8_t>(verifier, VT_REQUIRED, 1) &&
690 VerifyField<uint8_t>(verifier, VT_KEY, 1) &&
691 VerifyOffset(verifier, VT_ATTRIBUTES) &&
692 verifier.VerifyVector(attributes()) &&
693 verifier.VerifyVectorOfTables(attributes()) &&
694 VerifyOffset(verifier, VT_DOCUMENTATION) &&
695 verifier.VerifyVector(documentation()) &&
696 verifier.VerifyVectorOfStrings(documentation()) &&
697 VerifyField<uint8_t>(verifier, VT_OPTIONAL, 1) &&
698 VerifyField<uint16_t>(verifier, VT_PADDING, 2) &&
699 VerifyField<uint8_t>(verifier, VT_OFFSET64, 1) &&
700 verifier.EndTable();
701 }
702 };
703
704 struct FieldBuilder {
705 typedef Field Table;
706 ::flatbuffers::FlatBufferBuilder &fbb_;
707 ::flatbuffers::uoffset_t start_;
add_nameFieldBuilder708 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
709 fbb_.AddOffset(Field::VT_NAME, name);
710 }
add_typeFieldBuilder711 void add_type(::flatbuffers::Offset<reflection::Type> type) {
712 fbb_.AddOffset(Field::VT_TYPE, type);
713 }
add_idFieldBuilder714 void add_id(uint16_t id) {
715 fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0);
716 }
add_offsetFieldBuilder717 void add_offset(uint16_t offset) {
718 fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0);
719 }
add_default_integerFieldBuilder720 void add_default_integer(int64_t default_integer) {
721 fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0);
722 }
add_default_realFieldBuilder723 void add_default_real(double default_real) {
724 fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0);
725 }
add_deprecatedFieldBuilder726 void add_deprecated(bool deprecated) {
727 fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0);
728 }
add_requiredFieldBuilder729 void add_required(bool required) {
730 fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0);
731 }
add_keyFieldBuilder732 void add_key(bool key) {
733 fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0);
734 }
add_attributesFieldBuilder735 void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
736 fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes);
737 }
add_documentationFieldBuilder738 void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
739 fbb_.AddOffset(Field::VT_DOCUMENTATION, documentation);
740 }
add_optionalFieldBuilder741 void add_optional(bool optional) {
742 fbb_.AddElement<uint8_t>(Field::VT_OPTIONAL, static_cast<uint8_t>(optional), 0);
743 }
add_paddingFieldBuilder744 void add_padding(uint16_t padding) {
745 fbb_.AddElement<uint16_t>(Field::VT_PADDING, padding, 0);
746 }
add_offset64FieldBuilder747 void add_offset64(bool offset64) {
748 fbb_.AddElement<uint8_t>(Field::VT_OFFSET64, static_cast<uint8_t>(offset64), 0);
749 }
FieldBuilderFieldBuilder750 explicit FieldBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
751 : fbb_(_fbb) {
752 start_ = fbb_.StartTable();
753 }
FinishFieldBuilder754 ::flatbuffers::Offset<Field> Finish() {
755 const auto end = fbb_.EndTable(start_);
756 auto o = ::flatbuffers::Offset<Field>(end);
757 fbb_.Required(o, Field::VT_NAME);
758 fbb_.Required(o, Field::VT_TYPE);
759 return o;
760 }
761 };
762
763 inline ::flatbuffers::Offset<Field> CreateField(
764 ::flatbuffers::FlatBufferBuilder &_fbb,
765 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
766 ::flatbuffers::Offset<reflection::Type> type = 0,
767 uint16_t id = 0,
768 uint16_t offset = 0,
769 int64_t default_integer = 0,
770 double default_real = 0.0,
771 bool deprecated = false,
772 bool required = false,
773 bool key = false,
774 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
775 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
776 bool optional = false,
777 uint16_t padding = 0,
778 bool offset64 = false) {
779 FieldBuilder builder_(_fbb);
780 builder_.add_default_real(default_real);
781 builder_.add_default_integer(default_integer);
782 builder_.add_documentation(documentation);
783 builder_.add_attributes(attributes);
784 builder_.add_type(type);
785 builder_.add_name(name);
786 builder_.add_padding(padding);
787 builder_.add_offset(offset);
788 builder_.add_id(id);
789 builder_.add_offset64(offset64);
790 builder_.add_optional(optional);
791 builder_.add_key(key);
792 builder_.add_required(required);
793 builder_.add_deprecated(deprecated);
794 return builder_.Finish();
795 }
796
797 inline ::flatbuffers::Offset<Field> CreateFieldDirect(
798 ::flatbuffers::FlatBufferBuilder &_fbb,
799 const char *name = nullptr,
800 ::flatbuffers::Offset<reflection::Type> type = 0,
801 uint16_t id = 0,
802 uint16_t offset = 0,
803 int64_t default_integer = 0,
804 double default_real = 0.0,
805 bool deprecated = false,
806 bool required = false,
807 bool key = false,
808 std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
809 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
810 bool optional = false,
811 uint16_t padding = 0,
812 bool offset64 = false) {
813 auto name__ = name ? _fbb.CreateString(name) : 0;
814 auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
815 auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
816 return reflection::CreateField(
817 _fbb,
818 name__,
819 type,
820 id,
821 offset,
822 default_integer,
823 default_real,
824 deprecated,
825 required,
826 key,
827 attributes__,
828 documentation__,
829 optional,
830 padding,
831 offset64);
832 }
833
834 struct Object FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
835 typedef ObjectBuilder Builder;
836 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
837 VT_NAME = 4,
838 VT_FIELDS = 6,
839 VT_IS_STRUCT = 8,
840 VT_MINALIGN = 10,
841 VT_BYTESIZE = 12,
842 VT_ATTRIBUTES = 14,
843 VT_DOCUMENTATION = 16,
844 VT_DECLARATION_FILE = 18
845 };
nameFLATBUFFERS_FINAL_CLASS846 const ::flatbuffers::String *name() const {
847 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
848 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS849 bool KeyCompareLessThan(const Object * const o) const {
850 return *name() < *o->name();
851 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS852 int KeyCompareWithValue(const char *_name) const {
853 return strcmp(name()->c_str(), _name);
854 }
855 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS856 int KeyCompareWithValue(const StringType& _name) const {
857 if (name()->c_str() < _name) return -1;
858 if (_name < name()->c_str()) return 1;
859 return 0;
860 }
fieldsFLATBUFFERS_FINAL_CLASS861 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *fields() const {
862 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *>(VT_FIELDS);
863 }
is_structFLATBUFFERS_FINAL_CLASS864 bool is_struct() const {
865 return GetField<uint8_t>(VT_IS_STRUCT, 0) != 0;
866 }
minalignFLATBUFFERS_FINAL_CLASS867 int32_t minalign() const {
868 return GetField<int32_t>(VT_MINALIGN, 0);
869 }
bytesizeFLATBUFFERS_FINAL_CLASS870 int32_t bytesize() const {
871 return GetField<int32_t>(VT_BYTESIZE, 0);
872 }
attributesFLATBUFFERS_FINAL_CLASS873 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
874 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
875 }
documentationFLATBUFFERS_FINAL_CLASS876 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
877 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
878 }
879 /// File that this Object is declared in.
declaration_fileFLATBUFFERS_FINAL_CLASS880 const ::flatbuffers::String *declaration_file() const {
881 return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
882 }
VerifyFLATBUFFERS_FINAL_CLASS883 bool Verify(::flatbuffers::Verifier &verifier) const {
884 return VerifyTableStart(verifier) &&
885 VerifyOffsetRequired(verifier, VT_NAME) &&
886 verifier.VerifyString(name()) &&
887 VerifyOffsetRequired(verifier, VT_FIELDS) &&
888 verifier.VerifyVector(fields()) &&
889 verifier.VerifyVectorOfTables(fields()) &&
890 VerifyField<uint8_t>(verifier, VT_IS_STRUCT, 1) &&
891 VerifyField<int32_t>(verifier, VT_MINALIGN, 4) &&
892 VerifyField<int32_t>(verifier, VT_BYTESIZE, 4) &&
893 VerifyOffset(verifier, VT_ATTRIBUTES) &&
894 verifier.VerifyVector(attributes()) &&
895 verifier.VerifyVectorOfTables(attributes()) &&
896 VerifyOffset(verifier, VT_DOCUMENTATION) &&
897 verifier.VerifyVector(documentation()) &&
898 verifier.VerifyVectorOfStrings(documentation()) &&
899 VerifyOffset(verifier, VT_DECLARATION_FILE) &&
900 verifier.VerifyString(declaration_file()) &&
901 verifier.EndTable();
902 }
903 };
904
905 struct ObjectBuilder {
906 typedef Object Table;
907 ::flatbuffers::FlatBufferBuilder &fbb_;
908 ::flatbuffers::uoffset_t start_;
add_nameObjectBuilder909 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
910 fbb_.AddOffset(Object::VT_NAME, name);
911 }
add_fieldsObjectBuilder912 void add_fields(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields) {
913 fbb_.AddOffset(Object::VT_FIELDS, fields);
914 }
add_is_structObjectBuilder915 void add_is_struct(bool is_struct) {
916 fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0);
917 }
add_minalignObjectBuilder918 void add_minalign(int32_t minalign) {
919 fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0);
920 }
add_bytesizeObjectBuilder921 void add_bytesize(int32_t bytesize) {
922 fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0);
923 }
add_attributesObjectBuilder924 void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
925 fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes);
926 }
add_documentationObjectBuilder927 void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
928 fbb_.AddOffset(Object::VT_DOCUMENTATION, documentation);
929 }
add_declaration_fileObjectBuilder930 void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
931 fbb_.AddOffset(Object::VT_DECLARATION_FILE, declaration_file);
932 }
ObjectBuilderObjectBuilder933 explicit ObjectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
934 : fbb_(_fbb) {
935 start_ = fbb_.StartTable();
936 }
FinishObjectBuilder937 ::flatbuffers::Offset<Object> Finish() {
938 const auto end = fbb_.EndTable(start_);
939 auto o = ::flatbuffers::Offset<Object>(end);
940 fbb_.Required(o, Object::VT_NAME);
941 fbb_.Required(o, Object::VT_FIELDS);
942 return o;
943 }
944 };
945
946 inline ::flatbuffers::Offset<Object> CreateObject(
947 ::flatbuffers::FlatBufferBuilder &_fbb,
948 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
949 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields = 0,
950 bool is_struct = false,
951 int32_t minalign = 0,
952 int32_t bytesize = 0,
953 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
954 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
955 ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
956 ObjectBuilder builder_(_fbb);
957 builder_.add_declaration_file(declaration_file);
958 builder_.add_documentation(documentation);
959 builder_.add_attributes(attributes);
960 builder_.add_bytesize(bytesize);
961 builder_.add_minalign(minalign);
962 builder_.add_fields(fields);
963 builder_.add_name(name);
964 builder_.add_is_struct(is_struct);
965 return builder_.Finish();
966 }
967
968 inline ::flatbuffers::Offset<Object> CreateObjectDirect(
969 ::flatbuffers::FlatBufferBuilder &_fbb,
970 const char *name = nullptr,
971 std::vector<::flatbuffers::Offset<reflection::Field>> *fields = nullptr,
972 bool is_struct = false,
973 int32_t minalign = 0,
974 int32_t bytesize = 0,
975 std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
976 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
977 const char *declaration_file = nullptr) {
978 auto name__ = name ? _fbb.CreateString(name) : 0;
979 auto fields__ = fields ? _fbb.CreateVectorOfSortedTables<reflection::Field>(fields) : 0;
980 auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
981 auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
982 auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
983 return reflection::CreateObject(
984 _fbb,
985 name__,
986 fields__,
987 is_struct,
988 minalign,
989 bytesize,
990 attributes__,
991 documentation__,
992 declaration_file__);
993 }
994
995 struct RPCCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
996 typedef RPCCallBuilder Builder;
997 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
998 VT_NAME = 4,
999 VT_REQUEST = 6,
1000 VT_RESPONSE = 8,
1001 VT_ATTRIBUTES = 10,
1002 VT_DOCUMENTATION = 12
1003 };
nameFLATBUFFERS_FINAL_CLASS1004 const ::flatbuffers::String *name() const {
1005 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
1006 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS1007 bool KeyCompareLessThan(const RPCCall * const o) const {
1008 return *name() < *o->name();
1009 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS1010 int KeyCompareWithValue(const char *_name) const {
1011 return strcmp(name()->c_str(), _name);
1012 }
1013 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS1014 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 }
requestFLATBUFFERS_FINAL_CLASS1019 const reflection::Object *request() const {
1020 return GetPointer<const reflection::Object *>(VT_REQUEST);
1021 }
responseFLATBUFFERS_FINAL_CLASS1022 const reflection::Object *response() const {
1023 return GetPointer<const reflection::Object *>(VT_RESPONSE);
1024 }
attributesFLATBUFFERS_FINAL_CLASS1025 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
1026 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
1027 }
documentationFLATBUFFERS_FINAL_CLASS1028 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
1029 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
1030 }
VerifyFLATBUFFERS_FINAL_CLASS1031 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_;
add_nameRPCCallBuilder1053 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
1054 fbb_.AddOffset(RPCCall::VT_NAME, name);
1055 }
add_requestRPCCallBuilder1056 void add_request(::flatbuffers::Offset<reflection::Object> request) {
1057 fbb_.AddOffset(RPCCall::VT_REQUEST, request);
1058 }
add_responseRPCCallBuilder1059 void add_response(::flatbuffers::Offset<reflection::Object> response) {
1060 fbb_.AddOffset(RPCCall::VT_RESPONSE, response);
1061 }
add_attributesRPCCallBuilder1062 void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
1063 fbb_.AddOffset(RPCCall::VT_ATTRIBUTES, attributes);
1064 }
add_documentationRPCCallBuilder1065 void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
1066 fbb_.AddOffset(RPCCall::VT_DOCUMENTATION, documentation);
1067 }
RPCCallBuilderRPCCallBuilder1068 explicit RPCCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1069 : fbb_(_fbb) {
1070 start_ = fbb_.StartTable();
1071 }
FinishRPCCallBuilder1072 ::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 };
nameFLATBUFFERS_FINAL_CLASS1126 const ::flatbuffers::String *name() const {
1127 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
1128 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS1129 bool KeyCompareLessThan(const Service * const o) const {
1130 return *name() < *o->name();
1131 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS1132 int KeyCompareWithValue(const char *_name) const {
1133 return strcmp(name()->c_str(), _name);
1134 }
1135 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS1136 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 }
callsFLATBUFFERS_FINAL_CLASS1141 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *calls() const {
1142 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *>(VT_CALLS);
1143 }
attributesFLATBUFFERS_FINAL_CLASS1144 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
1145 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
1146 }
documentationFLATBUFFERS_FINAL_CLASS1147 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.
declaration_fileFLATBUFFERS_FINAL_CLASS1151 const ::flatbuffers::String *declaration_file() const {
1152 return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
1153 }
VerifyFLATBUFFERS_FINAL_CLASS1154 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_;
add_nameServiceBuilder1177 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
1178 fbb_.AddOffset(Service::VT_NAME, name);
1179 }
add_callsServiceBuilder1180 void add_calls(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>>> calls) {
1181 fbb_.AddOffset(Service::VT_CALLS, calls);
1182 }
add_attributesServiceBuilder1183 void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
1184 fbb_.AddOffset(Service::VT_ATTRIBUTES, attributes);
1185 }
add_documentationServiceBuilder1186 void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
1187 fbb_.AddOffset(Service::VT_DOCUMENTATION, documentation);
1188 }
add_declaration_fileServiceBuilder1189 void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
1190 fbb_.AddOffset(Service::VT_DECLARATION_FILE, declaration_file);
1191 }
ServiceBuilderServiceBuilder1192 explicit ServiceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1193 : fbb_(_fbb) {
1194 start_ = fbb_.StartTable();
1195 }
FinishServiceBuilder1196 ::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.
filenameFLATBUFFERS_FINAL_CLASS1251 const ::flatbuffers::String *filename() const {
1252 return GetPointer<const ::flatbuffers::String *>(VT_FILENAME);
1253 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS1254 bool KeyCompareLessThan(const SchemaFile * const o) const {
1255 return *filename() < *o->filename();
1256 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS1257 int KeyCompareWithValue(const char *_filename) const {
1258 return strcmp(filename()->c_str(), _filename);
1259 }
1260 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS1261 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.
included_filenamesFLATBUFFERS_FINAL_CLASS1267 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames() const {
1268 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INCLUDED_FILENAMES);
1269 }
VerifyFLATBUFFERS_FINAL_CLASS1270 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_;
add_filenameSchemaFileBuilder1285 void add_filename(::flatbuffers::Offset<::flatbuffers::String> filename) {
1286 fbb_.AddOffset(SchemaFile::VT_FILENAME, filename);
1287 }
add_included_filenamesSchemaFileBuilder1288 void add_included_filenames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> included_filenames) {
1289 fbb_.AddOffset(SchemaFile::VT_INCLUDED_FILENAMES, included_filenames);
1290 }
SchemaFileBuilderSchemaFileBuilder1291 explicit SchemaFileBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1292 : fbb_(_fbb) {
1293 start_ = fbb_.StartTable();
1294 }
FinishSchemaFileBuilder1295 ::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 };
objectsFLATBUFFERS_FINAL_CLASS1337 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *objects() const {
1338 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *>(VT_OBJECTS);
1339 }
enumsFLATBUFFERS_FINAL_CLASS1340 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *enums() const {
1341 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *>(VT_ENUMS);
1342 }
file_identFLATBUFFERS_FINAL_CLASS1343 const ::flatbuffers::String *file_ident() const {
1344 return GetPointer<const ::flatbuffers::String *>(VT_FILE_IDENT);
1345 }
file_extFLATBUFFERS_FINAL_CLASS1346 const ::flatbuffers::String *file_ext() const {
1347 return GetPointer<const ::flatbuffers::String *>(VT_FILE_EXT);
1348 }
root_tableFLATBUFFERS_FINAL_CLASS1349 const reflection::Object *root_table() const {
1350 return GetPointer<const reflection::Object *>(VT_ROOT_TABLE);
1351 }
servicesFLATBUFFERS_FINAL_CLASS1352 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *services() const {
1353 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *>(VT_SERVICES);
1354 }
advanced_featuresFLATBUFFERS_FINAL_CLASS1355 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.
fbs_filesFLATBUFFERS_FINAL_CLASS1360 const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files() const {
1361 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *>(VT_FBS_FILES);
1362 }
VerifyFLATBUFFERS_FINAL_CLASS1363 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_;
add_objectsSchemaBuilder1392 void add_objects(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>>> objects) {
1393 fbb_.AddOffset(Schema::VT_OBJECTS, objects);
1394 }
add_enumsSchemaBuilder1395 void add_enums(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>>> enums) {
1396 fbb_.AddOffset(Schema::VT_ENUMS, enums);
1397 }
add_file_identSchemaBuilder1398 void add_file_ident(::flatbuffers::Offset<::flatbuffers::String> file_ident) {
1399 fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident);
1400 }
add_file_extSchemaBuilder1401 void add_file_ext(::flatbuffers::Offset<::flatbuffers::String> file_ext) {
1402 fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext);
1403 }
add_root_tableSchemaBuilder1404 void add_root_table(::flatbuffers::Offset<reflection::Object> root_table) {
1405 fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table);
1406 }
add_servicesSchemaBuilder1407 void add_services(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>>> services) {
1408 fbb_.AddOffset(Schema::VT_SERVICES, services);
1409 }
add_advanced_featuresSchemaBuilder1410 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 }
add_fbs_filesSchemaBuilder1413 void add_fbs_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>>> fbs_files) {
1414 fbb_.AddOffset(Schema::VT_FBS_FILES, fbs_files);
1415 }
SchemaBuilderSchemaBuilder1416 explicit SchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1417 : fbb_(_fbb) {
1418 start_ = fbb_.StartTable();
1419 }
FinishSchemaBuilder1420 ::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
GetSchema(const void * buf)1479 inline const reflection::Schema *GetSchema(const void *buf) {
1480 return ::flatbuffers::GetRoot<reflection::Schema>(buf);
1481 }
1482
GetSizePrefixedSchema(const void * buf)1483 inline const reflection::Schema *GetSizePrefixedSchema(const void *buf) {
1484 return ::flatbuffers::GetSizePrefixedRoot<reflection::Schema>(buf);
1485 }
1486
SchemaIdentifier()1487 inline const char *SchemaIdentifier() {
1488 return "BFBS";
1489 }
1490
SchemaBufferHasIdentifier(const void * buf)1491 inline bool SchemaBufferHasIdentifier(const void *buf) {
1492 return ::flatbuffers::BufferHasIdentifier(
1493 buf, SchemaIdentifier());
1494 }
1495
SizePrefixedSchemaBufferHasIdentifier(const void * buf)1496 inline bool SizePrefixedSchemaBufferHasIdentifier(const void *buf) {
1497 return ::flatbuffers::BufferHasIdentifier(
1498 buf, SchemaIdentifier(), true);
1499 }
1500
VerifySchemaBuffer(::flatbuffers::Verifier & verifier)1501 inline bool VerifySchemaBuffer(
1502 ::flatbuffers::Verifier &verifier) {
1503 return verifier.VerifyBuffer<reflection::Schema>(SchemaIdentifier());
1504 }
1505
VerifySizePrefixedSchemaBuffer(::flatbuffers::Verifier & verifier)1506 inline bool VerifySizePrefixedSchemaBuffer(
1507 ::flatbuffers::Verifier &verifier) {
1508 return verifier.VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
1509 }
1510
SchemaExtension()1511 inline const char *SchemaExtension() {
1512 return "bfbs";
1513 }
1514
FinishSchemaBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<reflection::Schema> root)1515 inline void FinishSchemaBuffer(
1516 ::flatbuffers::FlatBufferBuilder &fbb,
1517 ::flatbuffers::Offset<reflection::Schema> root) {
1518 fbb.Finish(root, SchemaIdentifier());
1519 }
1520
FinishSizePrefixedSchemaBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<reflection::Schema> root)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_
1530