1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_KEYFIELDSAMPLE_KEYFIELD_SAMPLE_H_
5 #define FLATBUFFERS_GENERATED_KEYFIELDSAMPLE_KEYFIELD_SAMPLE_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 keyfield {
17 namespace sample {
18
19 struct Baz;
20
21 struct Bar;
22
23 struct Color;
24
25 struct Apple;
26
27 struct Fruit;
28
29 struct Rice;
30
31 struct Grain;
32
33 struct FooTable;
34 struct FooTableBuilder;
35 struct FooTableT;
36
37 bool operator==(const Baz &lhs, const Baz &rhs);
38 bool operator!=(const Baz &lhs, const Baz &rhs);
39 bool operator==(const Bar &lhs, const Bar &rhs);
40 bool operator!=(const Bar &lhs, const Bar &rhs);
41 bool operator==(const Color &lhs, const Color &rhs);
42 bool operator!=(const Color &lhs, const Color &rhs);
43 bool operator==(const Apple &lhs, const Apple &rhs);
44 bool operator!=(const Apple &lhs, const Apple &rhs);
45 bool operator==(const Fruit &lhs, const Fruit &rhs);
46 bool operator!=(const Fruit &lhs, const Fruit &rhs);
47 bool operator==(const Rice &lhs, const Rice &rhs);
48 bool operator!=(const Rice &lhs, const Rice &rhs);
49 bool operator==(const Grain &lhs, const Grain &rhs);
50 bool operator!=(const Grain &lhs, const Grain &rhs);
51 bool operator==(const FooTableT &lhs, const FooTableT &rhs);
52 bool operator!=(const FooTableT &lhs, const FooTableT &rhs);
53
54 inline const ::flatbuffers::TypeTable *BazTypeTable();
55
56 inline const ::flatbuffers::TypeTable *BarTypeTable();
57
58 inline const ::flatbuffers::TypeTable *ColorTypeTable();
59
60 inline const ::flatbuffers::TypeTable *AppleTypeTable();
61
62 inline const ::flatbuffers::TypeTable *FruitTypeTable();
63
64 inline const ::flatbuffers::TypeTable *RiceTypeTable();
65
66 inline const ::flatbuffers::TypeTable *GrainTypeTable();
67
68 inline const ::flatbuffers::TypeTable *FooTableTypeTable();
69
70 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
71 private:
72 uint8_t a_[4];
73 uint8_t b_;
74
75 public:
MiniReflectTypeTable()76 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
77 return BazTypeTable();
78 }
Baz()79 Baz()
80 : a_(),
81 b_(0) {
82 }
Baz(uint8_t _b)83 Baz(uint8_t _b)
84 : a_(),
85 b_(::flatbuffers::EndianScalar(_b)) {
86 }
Baz(::flatbuffers::span<const uint8_t,4> _a,uint8_t _b)87 Baz(::flatbuffers::span<const uint8_t, 4> _a, uint8_t _b)
88 : b_(::flatbuffers::EndianScalar(_b)) {
89 ::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
90 }
a()91 const ::flatbuffers::Array<uint8_t, 4> *a() const {
92 return &::flatbuffers::CastToArray(a_);
93 }
mutable_a()94 ::flatbuffers::Array<uint8_t, 4> *mutable_a() {
95 return &::flatbuffers::CastToArray(a_);
96 }
KeyCompareLessThan(const Baz * const o)97 bool KeyCompareLessThan(const Baz * const o) const {
98 return KeyCompareWithValue(o->a()) < 0;
99 }
KeyCompareWithValue(const::flatbuffers::Array<uint8_t,4> * _a)100 int KeyCompareWithValue(const ::flatbuffers::Array<uint8_t, 4> *_a) const {
101 const ::flatbuffers::Array<uint8_t, 4> *curr_a = a();
102 for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
103 const auto lhs = curr_a->Get(i);
104 const auto rhs = _a->Get(i);
105 if (lhs != rhs)
106 return static_cast<int>(lhs > rhs) - static_cast<int>(lhs < rhs);
107 }
108 return 0;
109 }
b()110 uint8_t b() const {
111 return ::flatbuffers::EndianScalar(b_);
112 }
mutate_b(uint8_t _b)113 void mutate_b(uint8_t _b) {
114 ::flatbuffers::WriteScalar(&b_, _b);
115 }
116 };
117 FLATBUFFERS_STRUCT_END(Baz, 5);
118
119 inline bool operator==(const Baz &lhs, const Baz &rhs) {
120 return
121 (*lhs.a() == *rhs.a()) &&
122 (lhs.b() == rhs.b());
123 }
124
125 inline bool operator!=(const Baz &lhs, const Baz &rhs) {
126 return !(lhs == rhs);
127 }
128
129
130 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS {
131 private:
132 float a_[3];
133 uint8_t b_;
134 int8_t padding0__; int16_t padding1__;
135
136 public:
MiniReflectTypeTable()137 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
138 return BarTypeTable();
139 }
Bar()140 Bar()
141 : a_(),
142 b_(0),
143 padding0__(0),
144 padding1__(0) {
145 (void)padding0__;
146 (void)padding1__;
147 }
Bar(uint8_t _b)148 Bar(uint8_t _b)
149 : a_(),
150 b_(::flatbuffers::EndianScalar(_b)),
151 padding0__(0),
152 padding1__(0) {
153 (void)padding0__;
154 (void)padding1__;
155 }
Bar(::flatbuffers::span<const float,3> _a,uint8_t _b)156 Bar(::flatbuffers::span<const float, 3> _a, uint8_t _b)
157 : b_(::flatbuffers::EndianScalar(_b)),
158 padding0__(0),
159 padding1__(0) {
160 ::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
161 (void)padding0__;
162 (void)padding1__;
163 }
a()164 const ::flatbuffers::Array<float, 3> *a() const {
165 return &::flatbuffers::CastToArray(a_);
166 }
mutable_a()167 ::flatbuffers::Array<float, 3> *mutable_a() {
168 return &::flatbuffers::CastToArray(a_);
169 }
KeyCompareLessThan(const Bar * const o)170 bool KeyCompareLessThan(const Bar * const o) const {
171 return KeyCompareWithValue(o->a()) < 0;
172 }
KeyCompareWithValue(const::flatbuffers::Array<float,3> * _a)173 int KeyCompareWithValue(const ::flatbuffers::Array<float, 3> *_a) const {
174 const ::flatbuffers::Array<float, 3> *curr_a = a();
175 for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
176 const auto lhs = curr_a->Get(i);
177 const auto rhs = _a->Get(i);
178 if (lhs != rhs)
179 return static_cast<int>(lhs > rhs) - static_cast<int>(lhs < rhs);
180 }
181 return 0;
182 }
b()183 uint8_t b() const {
184 return ::flatbuffers::EndianScalar(b_);
185 }
mutate_b(uint8_t _b)186 void mutate_b(uint8_t _b) {
187 ::flatbuffers::WriteScalar(&b_, _b);
188 }
189 };
190 FLATBUFFERS_STRUCT_END(Bar, 16);
191
192 inline bool operator==(const Bar &lhs, const Bar &rhs) {
193 return
194 (*lhs.a() == *rhs.a()) &&
195 (lhs.b() == rhs.b());
196 }
197
198 inline bool operator!=(const Bar &lhs, const Bar &rhs) {
199 return !(lhs == rhs);
200 }
201
202
203 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Color FLATBUFFERS_FINAL_CLASS {
204 private:
205 float rgb_[3];
206 uint8_t tag_;
207 int8_t padding0__; int16_t padding1__;
208
209 public:
MiniReflectTypeTable()210 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
211 return ColorTypeTable();
212 }
Color()213 Color()
214 : rgb_(),
215 tag_(0),
216 padding0__(0),
217 padding1__(0) {
218 (void)padding0__;
219 (void)padding1__;
220 }
Color(uint8_t _tag)221 Color(uint8_t _tag)
222 : rgb_(),
223 tag_(::flatbuffers::EndianScalar(_tag)),
224 padding0__(0),
225 padding1__(0) {
226 (void)padding0__;
227 (void)padding1__;
228 }
Color(::flatbuffers::span<const float,3> _rgb,uint8_t _tag)229 Color(::flatbuffers::span<const float, 3> _rgb, uint8_t _tag)
230 : tag_(::flatbuffers::EndianScalar(_tag)),
231 padding0__(0),
232 padding1__(0) {
233 ::flatbuffers::CastToArray(rgb_).CopyFromSpan(_rgb);
234 (void)padding0__;
235 (void)padding1__;
236 }
rgb()237 const ::flatbuffers::Array<float, 3> *rgb() const {
238 return &::flatbuffers::CastToArray(rgb_);
239 }
mutable_rgb()240 ::flatbuffers::Array<float, 3> *mutable_rgb() {
241 return &::flatbuffers::CastToArray(rgb_);
242 }
KeyCompareLessThan(const Color * const o)243 bool KeyCompareLessThan(const Color * const o) const {
244 return KeyCompareWithValue(o->rgb()) < 0;
245 }
KeyCompareWithValue(const::flatbuffers::Array<float,3> * _rgb)246 int KeyCompareWithValue(const ::flatbuffers::Array<float, 3> *_rgb) const {
247 const ::flatbuffers::Array<float, 3> *curr_rgb = rgb();
248 for (::flatbuffers::uoffset_t i = 0; i < curr_rgb->size(); i++) {
249 const auto lhs = curr_rgb->Get(i);
250 const auto rhs = _rgb->Get(i);
251 if (lhs != rhs)
252 return static_cast<int>(lhs > rhs) - static_cast<int>(lhs < rhs);
253 }
254 return 0;
255 }
tag()256 uint8_t tag() const {
257 return ::flatbuffers::EndianScalar(tag_);
258 }
mutate_tag(uint8_t _tag)259 void mutate_tag(uint8_t _tag) {
260 ::flatbuffers::WriteScalar(&tag_, _tag);
261 }
262 };
263 FLATBUFFERS_STRUCT_END(Color, 16);
264
265 inline bool operator==(const Color &lhs, const Color &rhs) {
266 return
267 (*lhs.rgb() == *rhs.rgb()) &&
268 (lhs.tag() == rhs.tag());
269 }
270
271 inline bool operator!=(const Color &lhs, const Color &rhs) {
272 return !(lhs == rhs);
273 }
274
275
276 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Apple FLATBUFFERS_FINAL_CLASS {
277 private:
278 uint8_t tag_;
279 int8_t padding0__; int16_t padding1__;
280 keyfield::sample::Color color_;
281
282 public:
MiniReflectTypeTable()283 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
284 return AppleTypeTable();
285 }
Apple()286 Apple()
287 : tag_(0),
288 padding0__(0),
289 padding1__(0),
290 color_() {
291 (void)padding0__;
292 (void)padding1__;
293 }
Apple(uint8_t _tag,const keyfield::sample::Color & _color)294 Apple(uint8_t _tag, const keyfield::sample::Color &_color)
295 : tag_(::flatbuffers::EndianScalar(_tag)),
296 padding0__(0),
297 padding1__(0),
298 color_(_color) {
299 (void)padding0__;
300 (void)padding1__;
301 }
tag()302 uint8_t tag() const {
303 return ::flatbuffers::EndianScalar(tag_);
304 }
mutate_tag(uint8_t _tag)305 void mutate_tag(uint8_t _tag) {
306 ::flatbuffers::WriteScalar(&tag_, _tag);
307 }
color()308 const keyfield::sample::Color &color() const {
309 return color_;
310 }
mutable_color()311 keyfield::sample::Color &mutable_color() {
312 return color_;
313 }
KeyCompareLessThan(const Apple * const o)314 bool KeyCompareLessThan(const Apple * const o) const {
315 return KeyCompareWithValue(o->color()) < 0;
316 }
KeyCompareWithValue(const keyfield::sample::Color & _color)317 int KeyCompareWithValue(const keyfield::sample::Color &_color) const {
318 const auto &lhs_color = color();
319 const auto &rhs_color = _color;
320 const auto rhs_color_rgb = rhs_color.rgb();
321 const auto rgb_compare_result = lhs_color.KeyCompareWithValue(rhs_color_rgb);
322 if (rgb_compare_result != 0)
323 return rgb_compare_result;
324 const auto lhs_color_tag = lhs_color.tag();
325 const auto rhs_color_tag = rhs_color.tag();
326 if (lhs_color_tag != rhs_color_tag)
327 return static_cast<int>(lhs_color_tag > rhs_color_tag) - static_cast<int>(lhs_color_tag < rhs_color_tag);
328 return 0;
329 }
330 };
331 FLATBUFFERS_STRUCT_END(Apple, 20);
332
333 inline bool operator==(const Apple &lhs, const Apple &rhs) {
334 return
335 (lhs.tag() == rhs.tag()) &&
336 (lhs.color() == rhs.color());
337 }
338
339 inline bool operator!=(const Apple &lhs, const Apple &rhs) {
340 return !(lhs == rhs);
341 }
342
343
344 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Fruit FLATBUFFERS_FINAL_CLASS {
345 private:
346 keyfield::sample::Apple a_;
347 uint8_t b_;
348 int8_t padding0__; int16_t padding1__;
349
350 public:
MiniReflectTypeTable()351 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
352 return FruitTypeTable();
353 }
Fruit()354 Fruit()
355 : a_(),
356 b_(0),
357 padding0__(0),
358 padding1__(0) {
359 (void)padding0__;
360 (void)padding1__;
361 }
Fruit(const keyfield::sample::Apple & _a,uint8_t _b)362 Fruit(const keyfield::sample::Apple &_a, uint8_t _b)
363 : a_(_a),
364 b_(::flatbuffers::EndianScalar(_b)),
365 padding0__(0),
366 padding1__(0) {
367 (void)padding0__;
368 (void)padding1__;
369 }
a()370 const keyfield::sample::Apple &a() const {
371 return a_;
372 }
mutable_a()373 keyfield::sample::Apple &mutable_a() {
374 return a_;
375 }
KeyCompareLessThan(const Fruit * const o)376 bool KeyCompareLessThan(const Fruit * const o) const {
377 return KeyCompareWithValue(o->a()) < 0;
378 }
KeyCompareWithValue(const keyfield::sample::Apple & _a)379 int KeyCompareWithValue(const keyfield::sample::Apple &_a) const {
380 const auto &lhs_a = a();
381 const auto &rhs_a = _a;
382 const auto lhs_a_tag = lhs_a.tag();
383 const auto rhs_a_tag = rhs_a.tag();
384 if (lhs_a_tag != rhs_a_tag)
385 return static_cast<int>(lhs_a_tag > rhs_a_tag) - static_cast<int>(lhs_a_tag < rhs_a_tag);
386 const auto rhs_a_color = rhs_a.color();
387 const auto color_compare_result = lhs_a.KeyCompareWithValue(rhs_a_color);
388 if (color_compare_result != 0)
389 return color_compare_result;
390 return 0;
391 }
b()392 uint8_t b() const {
393 return ::flatbuffers::EndianScalar(b_);
394 }
mutate_b(uint8_t _b)395 void mutate_b(uint8_t _b) {
396 ::flatbuffers::WriteScalar(&b_, _b);
397 }
398 };
399 FLATBUFFERS_STRUCT_END(Fruit, 24);
400
401 inline bool operator==(const Fruit &lhs, const Fruit &rhs) {
402 return
403 (lhs.a() == rhs.a()) &&
404 (lhs.b() == rhs.b());
405 }
406
407 inline bool operator!=(const Fruit &lhs, const Fruit &rhs) {
408 return !(lhs == rhs);
409 }
410
411
412 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rice FLATBUFFERS_FINAL_CLASS {
413 private:
414 uint8_t origin_[3];
415 int8_t padding0__;
416 uint32_t quantity_;
417
418 public:
MiniReflectTypeTable()419 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
420 return RiceTypeTable();
421 }
Rice()422 Rice()
423 : origin_(),
424 padding0__(0),
425 quantity_(0) {
426 (void)padding0__;
427 }
Rice(uint32_t _quantity)428 Rice(uint32_t _quantity)
429 : origin_(),
430 padding0__(0),
431 quantity_(::flatbuffers::EndianScalar(_quantity)) {
432 (void)padding0__;
433 }
Rice(::flatbuffers::span<const uint8_t,3> _origin,uint32_t _quantity)434 Rice(::flatbuffers::span<const uint8_t, 3> _origin, uint32_t _quantity)
435 : padding0__(0),
436 quantity_(::flatbuffers::EndianScalar(_quantity)) {
437 ::flatbuffers::CastToArray(origin_).CopyFromSpan(_origin);
438 (void)padding0__;
439 }
origin()440 const ::flatbuffers::Array<uint8_t, 3> *origin() const {
441 return &::flatbuffers::CastToArray(origin_);
442 }
mutable_origin()443 ::flatbuffers::Array<uint8_t, 3> *mutable_origin() {
444 return &::flatbuffers::CastToArray(origin_);
445 }
quantity()446 uint32_t quantity() const {
447 return ::flatbuffers::EndianScalar(quantity_);
448 }
mutate_quantity(uint32_t _quantity)449 void mutate_quantity(uint32_t _quantity) {
450 ::flatbuffers::WriteScalar(&quantity_, _quantity);
451 }
452 };
453 FLATBUFFERS_STRUCT_END(Rice, 8);
454
455 inline bool operator==(const Rice &lhs, const Rice &rhs) {
456 return
457 (*lhs.origin() == *rhs.origin()) &&
458 (lhs.quantity() == rhs.quantity());
459 }
460
461 inline bool operator!=(const Rice &lhs, const Rice &rhs) {
462 return !(lhs == rhs);
463 }
464
465
466 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Grain FLATBUFFERS_FINAL_CLASS {
467 private:
468 keyfield::sample::Rice a_[3];
469 uint8_t tag_;
470 int8_t padding0__; int16_t padding1__;
471
472 public:
MiniReflectTypeTable()473 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
474 return GrainTypeTable();
475 }
Grain()476 Grain()
477 : a_(),
478 tag_(0),
479 padding0__(0),
480 padding1__(0) {
481 (void)padding0__;
482 (void)padding1__;
483 }
Grain(uint8_t _tag)484 Grain(uint8_t _tag)
485 : a_(),
486 tag_(::flatbuffers::EndianScalar(_tag)),
487 padding0__(0),
488 padding1__(0) {
489 (void)padding0__;
490 (void)padding1__;
491 }
Grain(::flatbuffers::span<const keyfield::sample::Rice,3> _a,uint8_t _tag)492 Grain(::flatbuffers::span<const keyfield::sample::Rice, 3> _a, uint8_t _tag)
493 : tag_(::flatbuffers::EndianScalar(_tag)),
494 padding0__(0),
495 padding1__(0) {
496 ::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
497 (void)padding0__;
498 (void)padding1__;
499 }
a()500 const ::flatbuffers::Array<keyfield::sample::Rice, 3> *a() const {
501 return &::flatbuffers::CastToArray(a_);
502 }
mutable_a()503 ::flatbuffers::Array<keyfield::sample::Rice, 3> *mutable_a() {
504 return &::flatbuffers::CastToArray(a_);
505 }
KeyCompareLessThan(const Grain * const o)506 bool KeyCompareLessThan(const Grain * const o) const {
507 return KeyCompareWithValue(o->a()) < 0;
508 }
KeyCompareWithValue(const::flatbuffers::Array<keyfield::sample::Rice,3> * _a)509 int KeyCompareWithValue(const ::flatbuffers::Array<keyfield::sample::Rice, 3> *_a) const {
510 const ::flatbuffers::Array<keyfield::sample::Rice, 3> *curr_a = a();
511 for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
512 const auto &lhs_a = *(curr_a->Get(i));
513 const auto &rhs_a = *(_a->Get(i));
514 const auto lhs_a_origin = lhs_a.origin();
515 const auto rhs_a_origin = rhs_a.origin();
516 for (::flatbuffers::uoffset_t i = 0; i < lhs_a_origin->size(); i++) {
517 const auto lhs_a_origin_elem = lhs_a_origin->Get(i);
518 const auto rhs_a_origin_elem = rhs_a_origin->Get(i);
519 if (lhs_a_origin_elem != rhs_a_origin_elem)
520 return static_cast<int>(lhs_a_origin_elem > rhs_a_origin_elem) - static_cast<int>(lhs_a_origin_elem < rhs_a_origin_elem);
521 }
522 const auto lhs_a_quantity = lhs_a.quantity();
523 const auto rhs_a_quantity = rhs_a.quantity();
524 if (lhs_a_quantity != rhs_a_quantity)
525 return static_cast<int>(lhs_a_quantity > rhs_a_quantity) - static_cast<int>(lhs_a_quantity < rhs_a_quantity);
526 }
527 return 0;
528 }
tag()529 uint8_t tag() const {
530 return ::flatbuffers::EndianScalar(tag_);
531 }
mutate_tag(uint8_t _tag)532 void mutate_tag(uint8_t _tag) {
533 ::flatbuffers::WriteScalar(&tag_, _tag);
534 }
535 };
536 FLATBUFFERS_STRUCT_END(Grain, 28);
537
538 inline bool operator==(const Grain &lhs, const Grain &rhs) {
539 return
540 (*lhs.a() == *rhs.a()) &&
541 (lhs.tag() == rhs.tag());
542 }
543
544 inline bool operator!=(const Grain &lhs, const Grain &rhs) {
545 return !(lhs == rhs);
546 }
547
548
549 struct FooTableT : public ::flatbuffers::NativeTable {
550 typedef FooTable TableType;
551 int32_t a = 0;
552 int32_t b = 0;
553 std::string c{};
554 std::vector<keyfield::sample::Baz> d{};
555 std::vector<keyfield::sample::Bar> e{};
556 std::vector<keyfield::sample::Apple> f{};
557 std::vector<keyfield::sample::Fruit> g{};
558 std::vector<keyfield::sample::Grain> h{};
559 };
560
561 struct FooTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
562 typedef FooTableT NativeTableType;
563 typedef FooTableBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS564 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
565 return FooTableTypeTable();
566 }
567 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
568 VT_A = 4,
569 VT_B = 6,
570 VT_C = 8,
571 VT_D = 10,
572 VT_E = 12,
573 VT_F = 14,
574 VT_G = 16,
575 VT_H = 18
576 };
aFLATBUFFERS_FINAL_CLASS577 int32_t a() const {
578 return GetField<int32_t>(VT_A, 0);
579 }
580 bool mutate_a(int32_t _a = 0) {
581 return SetField<int32_t>(VT_A, _a, 0);
582 }
bFLATBUFFERS_FINAL_CLASS583 int32_t b() const {
584 return GetField<int32_t>(VT_B, 0);
585 }
586 bool mutate_b(int32_t _b = 0) {
587 return SetField<int32_t>(VT_B, _b, 0);
588 }
cFLATBUFFERS_FINAL_CLASS589 const ::flatbuffers::String *c() const {
590 return GetPointer<const ::flatbuffers::String *>(VT_C);
591 }
mutable_cFLATBUFFERS_FINAL_CLASS592 ::flatbuffers::String *mutable_c() {
593 return GetPointer<::flatbuffers::String *>(VT_C);
594 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS595 bool KeyCompareLessThan(const FooTable * const o) const {
596 return *c() < *o->c();
597 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS598 int KeyCompareWithValue(const char *_c) const {
599 return strcmp(c()->c_str(), _c);
600 }
601 template<typename StringType>
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS602 int KeyCompareWithValue(const StringType& _c) const {
603 if (c()->c_str() < _c) return -1;
604 if (_c < c()->c_str()) return 1;
605 return 0;
606 }
dFLATBUFFERS_FINAL_CLASS607 const ::flatbuffers::Vector<const keyfield::sample::Baz *> *d() const {
608 return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
609 }
mutable_dFLATBUFFERS_FINAL_CLASS610 ::flatbuffers::Vector<const keyfield::sample::Baz *> *mutable_d() {
611 return GetPointer<::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
612 }
eFLATBUFFERS_FINAL_CLASS613 const ::flatbuffers::Vector<const keyfield::sample::Bar *> *e() const {
614 return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
615 }
mutable_eFLATBUFFERS_FINAL_CLASS616 ::flatbuffers::Vector<const keyfield::sample::Bar *> *mutable_e() {
617 return GetPointer<::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
618 }
fFLATBUFFERS_FINAL_CLASS619 const ::flatbuffers::Vector<const keyfield::sample::Apple *> *f() const {
620 return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Apple *> *>(VT_F);
621 }
mutable_fFLATBUFFERS_FINAL_CLASS622 ::flatbuffers::Vector<const keyfield::sample::Apple *> *mutable_f() {
623 return GetPointer<::flatbuffers::Vector<const keyfield::sample::Apple *> *>(VT_F);
624 }
gFLATBUFFERS_FINAL_CLASS625 const ::flatbuffers::Vector<const keyfield::sample::Fruit *> *g() const {
626 return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Fruit *> *>(VT_G);
627 }
mutable_gFLATBUFFERS_FINAL_CLASS628 ::flatbuffers::Vector<const keyfield::sample::Fruit *> *mutable_g() {
629 return GetPointer<::flatbuffers::Vector<const keyfield::sample::Fruit *> *>(VT_G);
630 }
hFLATBUFFERS_FINAL_CLASS631 const ::flatbuffers::Vector<const keyfield::sample::Grain *> *h() const {
632 return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Grain *> *>(VT_H);
633 }
mutable_hFLATBUFFERS_FINAL_CLASS634 ::flatbuffers::Vector<const keyfield::sample::Grain *> *mutable_h() {
635 return GetPointer<::flatbuffers::Vector<const keyfield::sample::Grain *> *>(VT_H);
636 }
VerifyFLATBUFFERS_FINAL_CLASS637 bool Verify(::flatbuffers::Verifier &verifier) const {
638 return VerifyTableStart(verifier) &&
639 VerifyField<int32_t>(verifier, VT_A, 4) &&
640 VerifyField<int32_t>(verifier, VT_B, 4) &&
641 VerifyOffsetRequired(verifier, VT_C) &&
642 verifier.VerifyString(c()) &&
643 VerifyOffset(verifier, VT_D) &&
644 verifier.VerifyVector(d()) &&
645 VerifyOffset(verifier, VT_E) &&
646 verifier.VerifyVector(e()) &&
647 VerifyOffset(verifier, VT_F) &&
648 verifier.VerifyVector(f()) &&
649 VerifyOffset(verifier, VT_G) &&
650 verifier.VerifyVector(g()) &&
651 VerifyOffset(verifier, VT_H) &&
652 verifier.VerifyVector(h()) &&
653 verifier.EndTable();
654 }
655 FooTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
656 void UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
657 static ::flatbuffers::Offset<FooTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
658 };
659
660 struct FooTableBuilder {
661 typedef FooTable Table;
662 ::flatbuffers::FlatBufferBuilder &fbb_;
663 ::flatbuffers::uoffset_t start_;
add_aFooTableBuilder664 void add_a(int32_t a) {
665 fbb_.AddElement<int32_t>(FooTable::VT_A, a, 0);
666 }
add_bFooTableBuilder667 void add_b(int32_t b) {
668 fbb_.AddElement<int32_t>(FooTable::VT_B, b, 0);
669 }
add_cFooTableBuilder670 void add_c(::flatbuffers::Offset<::flatbuffers::String> c) {
671 fbb_.AddOffset(FooTable::VT_C, c);
672 }
add_dFooTableBuilder673 void add_d(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d) {
674 fbb_.AddOffset(FooTable::VT_D, d);
675 }
add_eFooTableBuilder676 void add_e(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e) {
677 fbb_.AddOffset(FooTable::VT_E, e);
678 }
add_fFooTableBuilder679 void add_f(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Apple *>> f) {
680 fbb_.AddOffset(FooTable::VT_F, f);
681 }
add_gFooTableBuilder682 void add_g(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Fruit *>> g) {
683 fbb_.AddOffset(FooTable::VT_G, g);
684 }
add_hFooTableBuilder685 void add_h(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Grain *>> h) {
686 fbb_.AddOffset(FooTable::VT_H, h);
687 }
FooTableBuilderFooTableBuilder688 explicit FooTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
689 : fbb_(_fbb) {
690 start_ = fbb_.StartTable();
691 }
FinishFooTableBuilder692 ::flatbuffers::Offset<FooTable> Finish() {
693 const auto end = fbb_.EndTable(start_);
694 auto o = ::flatbuffers::Offset<FooTable>(end);
695 fbb_.Required(o, FooTable::VT_C);
696 return o;
697 }
698 };
699
700 inline ::flatbuffers::Offset<FooTable> CreateFooTable(
701 ::flatbuffers::FlatBufferBuilder &_fbb,
702 int32_t a = 0,
703 int32_t b = 0,
704 ::flatbuffers::Offset<::flatbuffers::String> c = 0,
705 ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d = 0,
706 ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e = 0,
707 ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Apple *>> f = 0,
708 ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Fruit *>> g = 0,
709 ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Grain *>> h = 0) {
710 FooTableBuilder builder_(_fbb);
711 builder_.add_h(h);
712 builder_.add_g(g);
713 builder_.add_f(f);
714 builder_.add_e(e);
715 builder_.add_d(d);
716 builder_.add_c(c);
717 builder_.add_b(b);
718 builder_.add_a(a);
719 return builder_.Finish();
720 }
721
722 inline ::flatbuffers::Offset<FooTable> CreateFooTableDirect(
723 ::flatbuffers::FlatBufferBuilder &_fbb,
724 int32_t a = 0,
725 int32_t b = 0,
726 const char *c = nullptr,
727 std::vector<keyfield::sample::Baz> *d = nullptr,
728 std::vector<keyfield::sample::Bar> *e = nullptr,
729 std::vector<keyfield::sample::Apple> *f = nullptr,
730 std::vector<keyfield::sample::Fruit> *g = nullptr,
731 std::vector<keyfield::sample::Grain> *h = nullptr) {
732 auto c__ = c ? _fbb.CreateString(c) : 0;
733 auto d__ = d ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Baz>(d) : 0;
734 auto e__ = e ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Bar>(e) : 0;
735 auto f__ = f ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Apple>(f) : 0;
736 auto g__ = g ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Fruit>(g) : 0;
737 auto h__ = h ? _fbb.CreateVectorOfSortedStructs<keyfield::sample::Grain>(h) : 0;
738 return keyfield::sample::CreateFooTable(
739 _fbb,
740 a,
741 b,
742 c__,
743 d__,
744 e__,
745 f__,
746 g__,
747 h__);
748 }
749
750 ::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
751
752
753 inline bool operator==(const FooTableT &lhs, const FooTableT &rhs) {
754 return
755 (lhs.a == rhs.a) &&
756 (lhs.b == rhs.b) &&
757 (lhs.c == rhs.c) &&
758 (lhs.d == rhs.d) &&
759 (lhs.e == rhs.e) &&
760 (lhs.f == rhs.f) &&
761 (lhs.g == rhs.g) &&
762 (lhs.h == rhs.h);
763 }
764
765 inline bool operator!=(const FooTableT &lhs, const FooTableT &rhs) {
766 return !(lhs == rhs);
767 }
768
769
UnPack(const::flatbuffers::resolver_function_t * _resolver)770 inline FooTableT *FooTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
771 auto _o = std::unique_ptr<FooTableT>(new FooTableT());
772 UnPackTo(_o.get(), _resolver);
773 return _o.release();
774 }
775
UnPackTo(FooTableT * _o,const::flatbuffers::resolver_function_t * _resolver)776 inline void FooTable::UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
777 (void)_o;
778 (void)_resolver;
779 { auto _e = a(); _o->a = _e; }
780 { auto _e = b(); _o->b = _e; }
781 { auto _e = c(); if (_e) _o->c = _e->str(); }
782 { auto _e = d(); if (_e) { _o->d.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->d[_i] = *_e->Get(_i); } } else { _o->d.resize(0); } }
783 { auto _e = e(); if (_e) { _o->e.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->e[_i] = *_e->Get(_i); } } else { _o->e.resize(0); } }
784 { auto _e = f(); if (_e) { _o->f.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->f[_i] = *_e->Get(_i); } } else { _o->f.resize(0); } }
785 { auto _e = g(); if (_e) { _o->g.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->g[_i] = *_e->Get(_i); } } else { _o->g.resize(0); } }
786 { auto _e = h(); if (_e) { _o->h.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->h[_i] = *_e->Get(_i); } } else { _o->h.resize(0); } }
787 }
788
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const FooTableT * _o,const::flatbuffers::rehasher_function_t * _rehasher)789 inline ::flatbuffers::Offset<FooTable> FooTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
790 return CreateFooTable(_fbb, _o, _rehasher);
791 }
792
CreateFooTable(::flatbuffers::FlatBufferBuilder & _fbb,const FooTableT * _o,const::flatbuffers::rehasher_function_t * _rehasher)793 inline ::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
794 (void)_rehasher;
795 (void)_o;
796 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FooTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
797 auto _a = _o->a;
798 auto _b = _o->b;
799 auto _c = _fbb.CreateString(_o->c);
800 auto _d = _o->d.size() ? _fbb.CreateVectorOfStructs(_o->d) : 0;
801 auto _e = _o->e.size() ? _fbb.CreateVectorOfStructs(_o->e) : 0;
802 auto _f = _o->f.size() ? _fbb.CreateVectorOfStructs(_o->f) : 0;
803 auto _g = _o->g.size() ? _fbb.CreateVectorOfStructs(_o->g) : 0;
804 auto _h = _o->h.size() ? _fbb.CreateVectorOfStructs(_o->h) : 0;
805 return keyfield::sample::CreateFooTable(
806 _fbb,
807 _a,
808 _b,
809 _c,
810 _d,
811 _e,
812 _f,
813 _g,
814 _h);
815 }
816
BazTypeTable()817 inline const ::flatbuffers::TypeTable *BazTypeTable() {
818 static const ::flatbuffers::TypeCode type_codes[] = {
819 { ::flatbuffers::ET_UCHAR, 1, -1 },
820 { ::flatbuffers::ET_UCHAR, 0, -1 }
821 };
822 static const int16_t array_sizes[] = { 4, };
823 static const int64_t values[] = { 0, 4, 5 };
824 static const char * const names[] = {
825 "a",
826 "b"
827 };
828 static const ::flatbuffers::TypeTable tt = {
829 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
830 };
831 return &tt;
832 }
833
BarTypeTable()834 inline const ::flatbuffers::TypeTable *BarTypeTable() {
835 static const ::flatbuffers::TypeCode type_codes[] = {
836 { ::flatbuffers::ET_FLOAT, 1, -1 },
837 { ::flatbuffers::ET_UCHAR, 0, -1 }
838 };
839 static const int16_t array_sizes[] = { 3, };
840 static const int64_t values[] = { 0, 12, 16 };
841 static const char * const names[] = {
842 "a",
843 "b"
844 };
845 static const ::flatbuffers::TypeTable tt = {
846 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
847 };
848 return &tt;
849 }
850
ColorTypeTable()851 inline const ::flatbuffers::TypeTable *ColorTypeTable() {
852 static const ::flatbuffers::TypeCode type_codes[] = {
853 { ::flatbuffers::ET_FLOAT, 1, -1 },
854 { ::flatbuffers::ET_UCHAR, 0, -1 }
855 };
856 static const int16_t array_sizes[] = { 3, };
857 static const int64_t values[] = { 0, 12, 16 };
858 static const char * const names[] = {
859 "rgb",
860 "tag"
861 };
862 static const ::flatbuffers::TypeTable tt = {
863 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
864 };
865 return &tt;
866 }
867
AppleTypeTable()868 inline const ::flatbuffers::TypeTable *AppleTypeTable() {
869 static const ::flatbuffers::TypeCode type_codes[] = {
870 { ::flatbuffers::ET_UCHAR, 0, -1 },
871 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
872 };
873 static const ::flatbuffers::TypeFunction type_refs[] = {
874 keyfield::sample::ColorTypeTable
875 };
876 static const int64_t values[] = { 0, 4, 20 };
877 static const char * const names[] = {
878 "tag",
879 "color"
880 };
881 static const ::flatbuffers::TypeTable tt = {
882 ::flatbuffers::ST_STRUCT, 2, type_codes, type_refs, nullptr, values, names
883 };
884 return &tt;
885 }
886
FruitTypeTable()887 inline const ::flatbuffers::TypeTable *FruitTypeTable() {
888 static const ::flatbuffers::TypeCode type_codes[] = {
889 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
890 { ::flatbuffers::ET_UCHAR, 0, -1 }
891 };
892 static const ::flatbuffers::TypeFunction type_refs[] = {
893 keyfield::sample::AppleTypeTable
894 };
895 static const int64_t values[] = { 0, 20, 24 };
896 static const char * const names[] = {
897 "a",
898 "b"
899 };
900 static const ::flatbuffers::TypeTable tt = {
901 ::flatbuffers::ST_STRUCT, 2, type_codes, type_refs, nullptr, values, names
902 };
903 return &tt;
904 }
905
RiceTypeTable()906 inline const ::flatbuffers::TypeTable *RiceTypeTable() {
907 static const ::flatbuffers::TypeCode type_codes[] = {
908 { ::flatbuffers::ET_UCHAR, 1, -1 },
909 { ::flatbuffers::ET_UINT, 0, -1 }
910 };
911 static const int16_t array_sizes[] = { 3, };
912 static const int64_t values[] = { 0, 4, 8 };
913 static const char * const names[] = {
914 "origin",
915 "quantity"
916 };
917 static const ::flatbuffers::TypeTable tt = {
918 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
919 };
920 return &tt;
921 }
922
GrainTypeTable()923 inline const ::flatbuffers::TypeTable *GrainTypeTable() {
924 static const ::flatbuffers::TypeCode type_codes[] = {
925 { ::flatbuffers::ET_SEQUENCE, 1, 0 },
926 { ::flatbuffers::ET_UCHAR, 0, -1 }
927 };
928 static const ::flatbuffers::TypeFunction type_refs[] = {
929 keyfield::sample::RiceTypeTable
930 };
931 static const int16_t array_sizes[] = { 3, };
932 static const int64_t values[] = { 0, 24, 28 };
933 static const char * const names[] = {
934 "a",
935 "tag"
936 };
937 static const ::flatbuffers::TypeTable tt = {
938 ::flatbuffers::ST_STRUCT, 2, type_codes, type_refs, array_sizes, values, names
939 };
940 return &tt;
941 }
942
FooTableTypeTable()943 inline const ::flatbuffers::TypeTable *FooTableTypeTable() {
944 static const ::flatbuffers::TypeCode type_codes[] = {
945 { ::flatbuffers::ET_INT, 0, -1 },
946 { ::flatbuffers::ET_INT, 0, -1 },
947 { ::flatbuffers::ET_STRING, 0, -1 },
948 { ::flatbuffers::ET_SEQUENCE, 1, 0 },
949 { ::flatbuffers::ET_SEQUENCE, 1, 1 },
950 { ::flatbuffers::ET_SEQUENCE, 1, 2 },
951 { ::flatbuffers::ET_SEQUENCE, 1, 3 },
952 { ::flatbuffers::ET_SEQUENCE, 1, 4 }
953 };
954 static const ::flatbuffers::TypeFunction type_refs[] = {
955 keyfield::sample::BazTypeTable,
956 keyfield::sample::BarTypeTable,
957 keyfield::sample::AppleTypeTable,
958 keyfield::sample::FruitTypeTable,
959 keyfield::sample::GrainTypeTable
960 };
961 static const char * const names[] = {
962 "a",
963 "b",
964 "c",
965 "d",
966 "e",
967 "f",
968 "g",
969 "h"
970 };
971 static const ::flatbuffers::TypeTable tt = {
972 ::flatbuffers::ST_TABLE, 8, type_codes, type_refs, nullptr, nullptr, names
973 };
974 return &tt;
975 }
976
GetFooTable(const void * buf)977 inline const keyfield::sample::FooTable *GetFooTable(const void *buf) {
978 return ::flatbuffers::GetRoot<keyfield::sample::FooTable>(buf);
979 }
980
GetSizePrefixedFooTable(const void * buf)981 inline const keyfield::sample::FooTable *GetSizePrefixedFooTable(const void *buf) {
982 return ::flatbuffers::GetSizePrefixedRoot<keyfield::sample::FooTable>(buf);
983 }
984
GetMutableFooTable(void * buf)985 inline FooTable *GetMutableFooTable(void *buf) {
986 return ::flatbuffers::GetMutableRoot<FooTable>(buf);
987 }
988
GetMutableSizePrefixedFooTable(void * buf)989 inline keyfield::sample::FooTable *GetMutableSizePrefixedFooTable(void *buf) {
990 return ::flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf);
991 }
992
VerifyFooTableBuffer(::flatbuffers::Verifier & verifier)993 inline bool VerifyFooTableBuffer(
994 ::flatbuffers::Verifier &verifier) {
995 return verifier.VerifyBuffer<keyfield::sample::FooTable>(nullptr);
996 }
997
VerifySizePrefixedFooTableBuffer(::flatbuffers::Verifier & verifier)998 inline bool VerifySizePrefixedFooTableBuffer(
999 ::flatbuffers::Verifier &verifier) {
1000 return verifier.VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr);
1001 }
1002
FinishFooTableBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<keyfield::sample::FooTable> root)1003 inline void FinishFooTableBuffer(
1004 ::flatbuffers::FlatBufferBuilder &fbb,
1005 ::flatbuffers::Offset<keyfield::sample::FooTable> root) {
1006 fbb.Finish(root);
1007 }
1008
FinishSizePrefixedFooTableBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<keyfield::sample::FooTable> root)1009 inline void FinishSizePrefixedFooTableBuffer(
1010 ::flatbuffers::FlatBufferBuilder &fbb,
1011 ::flatbuffers::Offset<keyfield::sample::FooTable> root) {
1012 fbb.FinishSizePrefixed(root);
1013 }
1014
1015 inline std::unique_ptr<keyfield::sample::FooTableT> UnPackFooTable(
1016 const void *buf,
1017 const ::flatbuffers::resolver_function_t *res = nullptr) {
1018 return std::unique_ptr<keyfield::sample::FooTableT>(GetFooTable(buf)->UnPack(res));
1019 }
1020
1021 inline std::unique_ptr<keyfield::sample::FooTableT> UnPackSizePrefixedFooTable(
1022 const void *buf,
1023 const ::flatbuffers::resolver_function_t *res = nullptr) {
1024 return std::unique_ptr<keyfield::sample::FooTableT>(GetSizePrefixedFooTable(buf)->UnPack(res));
1025 }
1026
1027 } // namespace sample
1028 } // namespace keyfield
1029
1030 #endif // FLATBUFFERS_GENERATED_KEYFIELDSAMPLE_KEYFIELD_SAMPLE_H_
1031