1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_EVOLUTIONV1_EVOLUTION_V1_H_
5 #define FLATBUFFERS_GENERATED_EVOLUTIONV1_EVOLUTION_V1_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 == 2 &&
12 FLATBUFFERS_VERSION_MINOR == 0 &&
13 FLATBUFFERS_VERSION_REVISION == 7,
14 "Non-compatible flatbuffers version included");
15
16 namespace Evolution {
17 namespace V1 {
18
19 struct TableA;
20 struct TableABuilder;
21
22 struct TableB;
23 struct TableBBuilder;
24
25 struct Struct;
26
27 struct Root;
28 struct RootBuilder;
29
30 enum class Enum : int8_t {
31 King = 0,
32 Queen = 1,
33 MIN = King,
34 MAX = Queen
35 };
36
EnumValuesEnum()37 inline const Enum (&EnumValuesEnum())[2] {
38 static const Enum values[] = {
39 Enum::King,
40 Enum::Queen
41 };
42 return values;
43 }
44
EnumNamesEnum()45 inline const char * const *EnumNamesEnum() {
46 static const char * const names[3] = {
47 "King",
48 "Queen",
49 nullptr
50 };
51 return names;
52 }
53
EnumNameEnum(Enum e)54 inline const char *EnumNameEnum(Enum e) {
55 if (flatbuffers::IsOutRange(e, Enum::King, Enum::Queen)) return "";
56 const size_t index = static_cast<size_t>(e);
57 return EnumNamesEnum()[index];
58 }
59
60 enum class Union : uint8_t {
61 NONE = 0,
62 TableA = 1,
63 TableB = 2,
64 MIN = NONE,
65 MAX = TableB
66 };
67
EnumValuesUnion()68 inline const Union (&EnumValuesUnion())[3] {
69 static const Union values[] = {
70 Union::NONE,
71 Union::TableA,
72 Union::TableB
73 };
74 return values;
75 }
76
EnumNamesUnion()77 inline const char * const *EnumNamesUnion() {
78 static const char * const names[4] = {
79 "NONE",
80 "TableA",
81 "TableB",
82 nullptr
83 };
84 return names;
85 }
86
EnumNameUnion(Union e)87 inline const char *EnumNameUnion(Union e) {
88 if (flatbuffers::IsOutRange(e, Union::NONE, Union::TableB)) return "";
89 const size_t index = static_cast<size_t>(e);
90 return EnumNamesUnion()[index];
91 }
92
93 template<typename T> struct UnionTraits {
94 static const Union enum_value = Union::NONE;
95 };
96
97 template<> struct UnionTraits<Evolution::V1::TableA> {
98 static const Union enum_value = Union::TableA;
99 };
100
101 template<> struct UnionTraits<Evolution::V1::TableB> {
102 static const Union enum_value = Union::TableB;
103 };
104
105 bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type);
106 bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types);
107
108 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
109 private:
110 int32_t a_;
111 int32_t padding0__;
112 double b_;
113
114 public:
115 Struct()
116 : a_(0),
117 padding0__(0),
118 b_(0) {
119 (void)padding0__;
120 }
121 Struct(int32_t _a, double _b)
122 : a_(flatbuffers::EndianScalar(_a)),
123 padding0__(0),
124 b_(flatbuffers::EndianScalar(_b)) {
125 (void)padding0__;
126 }
127 int32_t a() const {
128 return flatbuffers::EndianScalar(a_);
129 }
130 double b() const {
131 return flatbuffers::EndianScalar(b_);
132 }
133 };
134 FLATBUFFERS_STRUCT_END(Struct, 16);
135
136 inline bool operator==(const Struct &lhs, const Struct &rhs) {
137 return
138 (lhs.a() == rhs.a()) &&
139 (lhs.b() == rhs.b());
140 }
141
142 inline bool operator!=(const Struct &lhs, const Struct &rhs) {
143 return !(lhs == rhs);
144 }
145
146
147 struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
148 typedef TableABuilder Builder;
149 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
150 VT_A = 4,
151 VT_B = 6
152 };
153 float a() const {
154 return GetField<float>(VT_A, 0.0f);
155 }
156 int32_t b() const {
157 return GetField<int32_t>(VT_B, 0);
158 }
159 bool Verify(flatbuffers::Verifier &verifier) const {
160 return VerifyTableStart(verifier) &&
161 VerifyField<float>(verifier, VT_A, 4) &&
162 VerifyField<int32_t>(verifier, VT_B, 4) &&
163 verifier.EndTable();
164 }
165 };
166
167 struct TableABuilder {
168 typedef TableA Table;
169 flatbuffers::FlatBufferBuilder &fbb_;
170 flatbuffers::uoffset_t start_;
171 void add_a(float a) {
172 fbb_.AddElement<float>(TableA::VT_A, a, 0.0f);
173 }
174 void add_b(int32_t b) {
175 fbb_.AddElement<int32_t>(TableA::VT_B, b, 0);
176 }
177 explicit TableABuilder(flatbuffers::FlatBufferBuilder &_fbb)
178 : fbb_(_fbb) {
179 start_ = fbb_.StartTable();
180 }
181 flatbuffers::Offset<TableA> Finish() {
182 const auto end = fbb_.EndTable(start_);
183 auto o = flatbuffers::Offset<TableA>(end);
184 return o;
185 }
186 };
187
188 inline flatbuffers::Offset<TableA> CreateTableA(
189 flatbuffers::FlatBufferBuilder &_fbb,
190 float a = 0.0f,
191 int32_t b = 0) {
192 TableABuilder builder_(_fbb);
193 builder_.add_b(b);
194 builder_.add_a(a);
195 return builder_.Finish();
196 }
197
198 struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
199 typedef TableBBuilder Builder;
200 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
201 VT_A = 4
202 };
203 int32_t a() const {
204 return GetField<int32_t>(VT_A, 0);
205 }
206 bool Verify(flatbuffers::Verifier &verifier) const {
207 return VerifyTableStart(verifier) &&
208 VerifyField<int32_t>(verifier, VT_A, 4) &&
209 verifier.EndTable();
210 }
211 };
212
213 struct TableBBuilder {
214 typedef TableB Table;
215 flatbuffers::FlatBufferBuilder &fbb_;
216 flatbuffers::uoffset_t start_;
217 void add_a(int32_t a) {
218 fbb_.AddElement<int32_t>(TableB::VT_A, a, 0);
219 }
220 explicit TableBBuilder(flatbuffers::FlatBufferBuilder &_fbb)
221 : fbb_(_fbb) {
222 start_ = fbb_.StartTable();
223 }
224 flatbuffers::Offset<TableB> Finish() {
225 const auto end = fbb_.EndTable(start_);
226 auto o = flatbuffers::Offset<TableB>(end);
227 return o;
228 }
229 };
230
231 inline flatbuffers::Offset<TableB> CreateTableB(
232 flatbuffers::FlatBufferBuilder &_fbb,
233 int32_t a = 0) {
234 TableBBuilder builder_(_fbb);
235 builder_.add_a(a);
236 return builder_.Finish();
237 }
238
239 struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
240 typedef RootBuilder Builder;
241 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
242 VT_A = 4,
243 VT_B = 6,
244 VT_C_TYPE = 8,
245 VT_C = 10,
246 VT_D = 12,
247 VT_E = 14,
248 VT_F = 16,
249 VT_G = 18,
250 VT_H = 20,
251 VT_I = 22,
252 VT_J_TYPE = 24,
253 VT_J = 26
254 };
255 int32_t a() const {
256 return GetField<int32_t>(VT_A, 0);
257 }
258 bool b() const {
259 return GetField<uint8_t>(VT_B, 0) != 0;
260 }
261 Evolution::V1::Union c_type() const {
262 return static_cast<Evolution::V1::Union>(GetField<uint8_t>(VT_C_TYPE, 0));
263 }
264 const void *c() const {
265 return GetPointer<const void *>(VT_C);
266 }
267 template<typename T> const T *c_as() const;
268 const Evolution::V1::TableA *c_as_TableA() const {
269 return c_type() == Evolution::V1::Union::TableA ? static_cast<const Evolution::V1::TableA *>(c()) : nullptr;
270 }
271 const Evolution::V1::TableB *c_as_TableB() const {
272 return c_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(c()) : nullptr;
273 }
274 Evolution::V1::Enum d() const {
275 return static_cast<Evolution::V1::Enum>(GetField<int8_t>(VT_D, 0));
276 }
277 const Evolution::V1::TableA *e() const {
278 return GetPointer<const Evolution::V1::TableA *>(VT_E);
279 }
280 const Evolution::V1::Struct *f() const {
281 return GetStruct<const Evolution::V1::Struct *>(VT_F);
282 }
283 const flatbuffers::Vector<int32_t> *g() const {
284 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_G);
285 }
286 const flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>> *h() const {
287 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>> *>(VT_H);
288 }
289 int32_t i() const {
290 return GetField<int32_t>(VT_I, 1234);
291 }
292 Evolution::V1::Union j_type() const {
293 return static_cast<Evolution::V1::Union>(GetField<uint8_t>(VT_J_TYPE, 0));
294 }
295 const void *j() const {
296 return GetPointer<const void *>(VT_J);
297 }
298 template<typename T> const T *j_as() const;
299 const Evolution::V1::TableA *j_as_TableA() const {
300 return j_type() == Evolution::V1::Union::TableA ? static_cast<const Evolution::V1::TableA *>(j()) : nullptr;
301 }
302 const Evolution::V1::TableB *j_as_TableB() const {
303 return j_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(j()) : nullptr;
304 }
305 bool Verify(flatbuffers::Verifier &verifier) const {
306 return VerifyTableStart(verifier) &&
307 VerifyField<int32_t>(verifier, VT_A, 4) &&
308 VerifyField<uint8_t>(verifier, VT_B, 1) &&
309 VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) &&
310 VerifyOffset(verifier, VT_C) &&
311 VerifyUnion(verifier, c(), c_type()) &&
312 VerifyField<int8_t>(verifier, VT_D, 1) &&
313 VerifyOffset(verifier, VT_E) &&
314 verifier.VerifyTable(e()) &&
315 VerifyField<Evolution::V1::Struct>(verifier, VT_F, 8) &&
316 VerifyOffset(verifier, VT_G) &&
317 verifier.VerifyVector(g()) &&
318 VerifyOffset(verifier, VT_H) &&
319 verifier.VerifyVector(h()) &&
320 verifier.VerifyVectorOfTables(h()) &&
321 VerifyField<int32_t>(verifier, VT_I, 4) &&
322 VerifyField<uint8_t>(verifier, VT_J_TYPE, 1) &&
323 VerifyOffset(verifier, VT_J) &&
324 VerifyUnion(verifier, j(), j_type()) &&
325 verifier.EndTable();
326 }
327 };
328
329 template<> inline const Evolution::V1::TableA *Root::c_as<Evolution::V1::TableA>() const {
330 return c_as_TableA();
331 }
332
333 template<> inline const Evolution::V1::TableB *Root::c_as<Evolution::V1::TableB>() const {
334 return c_as_TableB();
335 }
336
337 template<> inline const Evolution::V1::TableA *Root::j_as<Evolution::V1::TableA>() const {
338 return j_as_TableA();
339 }
340
341 template<> inline const Evolution::V1::TableB *Root::j_as<Evolution::V1::TableB>() const {
342 return j_as_TableB();
343 }
344
345 struct RootBuilder {
346 typedef Root Table;
347 flatbuffers::FlatBufferBuilder &fbb_;
348 flatbuffers::uoffset_t start_;
349 void add_a(int32_t a) {
350 fbb_.AddElement<int32_t>(Root::VT_A, a, 0);
351 }
352 void add_b(bool b) {
353 fbb_.AddElement<uint8_t>(Root::VT_B, static_cast<uint8_t>(b), 0);
354 }
355 void add_c_type(Evolution::V1::Union c_type) {
356 fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0);
357 }
358 void add_c(flatbuffers::Offset<void> c) {
359 fbb_.AddOffset(Root::VT_C, c);
360 }
361 void add_d(Evolution::V1::Enum d) {
362 fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0);
363 }
364 void add_e(flatbuffers::Offset<Evolution::V1::TableA> e) {
365 fbb_.AddOffset(Root::VT_E, e);
366 }
367 void add_f(const Evolution::V1::Struct *f) {
368 fbb_.AddStruct(Root::VT_F, f);
369 }
370 void add_g(flatbuffers::Offset<flatbuffers::Vector<int32_t>> g) {
371 fbb_.AddOffset(Root::VT_G, g);
372 }
373 void add_h(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>>> h) {
374 fbb_.AddOffset(Root::VT_H, h);
375 }
376 void add_i(int32_t i) {
377 fbb_.AddElement<int32_t>(Root::VT_I, i, 1234);
378 }
379 void add_j_type(Evolution::V1::Union j_type) {
380 fbb_.AddElement<uint8_t>(Root::VT_J_TYPE, static_cast<uint8_t>(j_type), 0);
381 }
382 void add_j(flatbuffers::Offset<void> j) {
383 fbb_.AddOffset(Root::VT_J, j);
384 }
385 explicit RootBuilder(flatbuffers::FlatBufferBuilder &_fbb)
386 : fbb_(_fbb) {
387 start_ = fbb_.StartTable();
388 }
389 flatbuffers::Offset<Root> Finish() {
390 const auto end = fbb_.EndTable(start_);
391 auto o = flatbuffers::Offset<Root>(end);
392 return o;
393 }
394 };
395
396 inline flatbuffers::Offset<Root> CreateRoot(
397 flatbuffers::FlatBufferBuilder &_fbb,
398 int32_t a = 0,
399 bool b = false,
400 Evolution::V1::Union c_type = Evolution::V1::Union::NONE,
401 flatbuffers::Offset<void> c = 0,
402 Evolution::V1::Enum d = Evolution::V1::Enum::King,
403 flatbuffers::Offset<Evolution::V1::TableA> e = 0,
404 const Evolution::V1::Struct *f = nullptr,
405 flatbuffers::Offset<flatbuffers::Vector<int32_t>> g = 0,
406 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>>> h = 0,
407 int32_t i = 1234,
408 Evolution::V1::Union j_type = Evolution::V1::Union::NONE,
409 flatbuffers::Offset<void> j = 0) {
410 RootBuilder builder_(_fbb);
411 builder_.add_j(j);
412 builder_.add_i(i);
413 builder_.add_h(h);
414 builder_.add_g(g);
415 builder_.add_f(f);
416 builder_.add_e(e);
417 builder_.add_c(c);
418 builder_.add_a(a);
419 builder_.add_j_type(j_type);
420 builder_.add_d(d);
421 builder_.add_c_type(c_type);
422 builder_.add_b(b);
423 return builder_.Finish();
424 }
425
426 inline flatbuffers::Offset<Root> CreateRootDirect(
427 flatbuffers::FlatBufferBuilder &_fbb,
428 int32_t a = 0,
429 bool b = false,
430 Evolution::V1::Union c_type = Evolution::V1::Union::NONE,
431 flatbuffers::Offset<void> c = 0,
432 Evolution::V1::Enum d = Evolution::V1::Enum::King,
433 flatbuffers::Offset<Evolution::V1::TableA> e = 0,
434 const Evolution::V1::Struct *f = nullptr,
435 const std::vector<int32_t> *g = nullptr,
436 const std::vector<flatbuffers::Offset<Evolution::V1::TableB>> *h = nullptr,
437 int32_t i = 1234,
438 Evolution::V1::Union j_type = Evolution::V1::Union::NONE,
439 flatbuffers::Offset<void> j = 0) {
440 auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0;
441 auto h__ = h ? _fbb.CreateVector<flatbuffers::Offset<Evolution::V1::TableB>>(*h) : 0;
442 return Evolution::V1::CreateRoot(
443 _fbb,
444 a,
445 b,
446 c_type,
447 c,
448 d,
449 e,
450 f,
451 g__,
452 h__,
453 i,
454 j_type,
455 j);
456 }
457
458 inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type) {
459 switch (type) {
460 case Union::NONE: {
461 return true;
462 }
463 case Union::TableA: {
464 auto ptr = reinterpret_cast<const Evolution::V1::TableA *>(obj);
465 return verifier.VerifyTable(ptr);
466 }
467 case Union::TableB: {
468 auto ptr = reinterpret_cast<const Evolution::V1::TableB *>(obj);
469 return verifier.VerifyTable(ptr);
470 }
471 default: return true;
472 }
473 }
474
475 inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types) {
476 if (!values || !types) return !values && !types;
477 if (values->size() != types->size()) return false;
478 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
479 if (!VerifyUnion(
480 verifier, values->Get(i), types->GetEnum<Union>(i))) {
481 return false;
482 }
483 }
484 return true;
485 }
486
487 inline const Evolution::V1::Root *GetRoot(const void *buf) {
488 return flatbuffers::GetRoot<Evolution::V1::Root>(buf);
489 }
490
491 inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) {
492 return flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf);
493 }
494
495 inline bool VerifyRootBuffer(
496 flatbuffers::Verifier &verifier) {
497 return verifier.VerifyBuffer<Evolution::V1::Root>(nullptr);
498 }
499
500 inline bool VerifySizePrefixedRootBuffer(
501 flatbuffers::Verifier &verifier) {
502 return verifier.VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr);
503 }
504
505 inline void FinishRootBuffer(
506 flatbuffers::FlatBufferBuilder &fbb,
507 flatbuffers::Offset<Evolution::V1::Root> root) {
508 fbb.Finish(root);
509 }
510
511 inline void FinishSizePrefixedRootBuffer(
512 flatbuffers::FlatBufferBuilder &fbb,
513 flatbuffers::Offset<Evolution::V1::Root> root) {
514 fbb.FinishSizePrefixed(root);
515 }
516
517 } // namespace V1
518 } // namespace Evolution
519
520 #endif // FLATBUFFERS_GENERATED_EVOLUTIONV1_EVOLUTION_V1_H_
521