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.
11static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
12 FLATBUFFERS_VERSION_MINOR == 5 &&
13 FLATBUFFERS_VERSION_REVISION == 26,
14 "Non-compatible flatbuffers version included");
15
16namespace Evolution {
17namespace V1 {
18
19struct TableA;
20struct TableABuilder;
21
22struct TableB;
23struct TableBBuilder;
24
25struct Struct;
26
27struct Root;
28struct RootBuilder;
29
30enum class Enum : int8_t {
31 King = 0,
32 Queen = 1,
33 MIN = King,
34 MAX = Queen
35};
36
37inline const Enum (&EnumValuesEnum())[2] {
38 static const Enum values[] = {
39 Enum::King,
40 Enum::Queen
41 };
42 return values;
43}
44
45inline const char * const *EnumNamesEnum() {
46 static const char * const names[3] = {
47 "King",
48 "Queen",
49 nullptr
50 };
51 return names;
52}
53
54inline 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
60enum class Union : uint8_t {
61 NONE = 0,
62 TableA = 1,
63 TableB = 2,
64 MIN = NONE,
65 MAX = TableB
66};
67
68inline const Union (&EnumValuesUnion())[3] {
69 static const Union values[] = {
70 Union::NONE,
71 Union::TableA,
72 Union::TableB
73 };
74 return values;
75}
76
77inline 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
87inline 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
93template<typename T> struct UnionTraits {
94 static const Union enum_value = Union::NONE;
95};
96
97template<> struct UnionTraits<Evolution::V1::TableA> {
98 static const Union enum_value = Union::TableA;
99};
100
101template<> struct UnionTraits<Evolution::V1::TableB> {
102 static const Union enum_value = Union::TableB;
103};
104
105bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type);
106bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
107
108FLATBUFFERS_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};
134FLATBUFFERS_STRUCT_END(Struct, 16);
135
136inline bool operator==(const Struct &lhs, const Struct &rhs) {
137 return
138 (lhs.a() == rhs.a()) &&
139 (lhs.b() == rhs.b());
140}
141
142inline bool operator!=(const Struct &lhs, const Struct &rhs) {
143 return !(lhs == rhs);
144}
145
146
147struct 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
167struct 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
188inline ::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
198struct 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
213struct 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
231inline ::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
239struct 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
329template<> inline const Evolution::V1::TableA *Root::c_as<Evolution::V1::TableA>() const {
330 return c_as_TableA();
331}
332
333template<> inline const Evolution::V1::TableB *Root::c_as<Evolution::V1::TableB>() const {
334 return c_as_TableB();
335}
336
337template<> inline const Evolution::V1::TableA *Root::j_as<Evolution::V1::TableA>() const {
338 return j_as_TableA();
339}
340
341template<> inline const Evolution::V1::TableB *Root::j_as<Evolution::V1::TableB>() const {
342 return j_as_TableB();
343}
344
345struct 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
396inline ::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
426inline ::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
458inline 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
475inline 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
487inline const Evolution::V1::Root *GetRoot(const void *buf) {
488 return ::flatbuffers::GetRoot<Evolution::V1::Root>(buf);
489}
490
491inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) {
492 return ::flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf);
493}
494
495inline bool VerifyRootBuffer(
496 ::flatbuffers::Verifier &verifier) {
497 return verifier.VerifyBuffer<Evolution::V1::Root>(nullptr);
498}
499
500inline bool VerifySizePrefixedRootBuffer(
501 ::flatbuffers::Verifier &verifier) {
502 return verifier.VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr);
503}
504
505inline void FinishRootBuffer(
506 ::flatbuffers::FlatBufferBuilder &fbb,
507 ::flatbuffers::Offset<Evolution::V1::Root> root) {
508 fbb.Finish(root);
509}
510
511inline 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_
View as plain text