1 // automatically generated by the FlatBuffers compiler, do not modify
2
3 #ifndef FLATBUFFERS_GENERATED_ARRAYSTEST_MYGAME_EXAMPLE_H_
4 #define FLATBUFFERS_GENERATED_ARRAYSTEST_MYGAME_EXAMPLE_H_
5
6 #include "flatbuffers/flatbuffers.h"
7
8 // Ensure the included flatbuffers.h is the same version as when this file was
9 // generated, otherwise it may not be compatible.
10 static_assert(FLATBUFFERS_VERSION_MAJOR == 24 && FLATBUFFERS_VERSION_MINOR == 3 &&
11 FLATBUFFERS_VERSION_REVISION == 25,
12 "Non-compatible flatbuffers version included");
13
14 namespace MyGame
15 {
16 namespace Example
17 {
18
19 struct NestedStruct;
20
21 struct ArrayStruct;
22
23 struct ArrayTable;
24 struct ArrayTableBuilder;
25 struct ArrayTableT;
26
27 bool operator==(const NestedStruct &lhs, const NestedStruct &rhs);
28 bool operator!=(const NestedStruct &lhs, const NestedStruct &rhs);
29 bool operator==(const ArrayStruct &lhs, const ArrayStruct &rhs);
30 bool operator!=(const ArrayStruct &lhs, const ArrayStruct &rhs);
31 bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs);
32 bool operator!=(const ArrayTableT &lhs, const ArrayTableT &rhs);
33
34 inline const ::flatbuffers::TypeTable *NestedStructTypeTable();
35
36 inline const ::flatbuffers::TypeTable *ArrayStructTypeTable();
37
38 inline const ::flatbuffers::TypeTable *ArrayTableTypeTable();
39
40 enum class TestEnum : int8_t
41 {
42 A = 0,
43 B = 1,
44 C = 2,
45 MIN = A,
46 MAX = C
47 };
48
EnumValuesTestEnum()49 inline const TestEnum (&EnumValuesTestEnum())[3]
50 {
51 static const TestEnum values[] = {TestEnum::A, TestEnum::B, TestEnum::C};
52 return values;
53 }
54
EnumNamesTestEnum()55 inline const char *const *EnumNamesTestEnum()
56 {
57 static const char *const names[4] = {"A", "B", "C", nullptr};
58 return names;
59 }
60
EnumNameTestEnum(TestEnum e)61 inline const char *EnumNameTestEnum(TestEnum e)
62 {
63 if (::flatbuffers::IsOutRange(e, TestEnum::A, TestEnum::C))
64 {
65 return "";
66 }
67 const size_t index = static_cast<size_t>(e);
68 return EnumNamesTestEnum()[index];
69 }
70
71 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS
72 {
73 private:
74 int32_t a_[2];
75 int8_t b_;
76 int8_t c_[2];
77 int8_t padding0__;
78 int32_t padding1__;
79 int64_t d_[2];
80
81 public:
82 struct Traits;
MiniReflectTypeTable()83 static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
84 {
85 return NestedStructTypeTable();
86 }
NestedStruct()87 NestedStruct() : a_(), b_(0), c_(), padding0__(0), padding1__(0), d_()
88 {
89 (void)padding0__;
90 (void)padding1__;
91 }
NestedStruct(MyGame::Example::TestEnum _b)92 NestedStruct(MyGame::Example::TestEnum _b)
93 : a_(),
94 b_(::flatbuffers::EndianScalar(static_cast<int8_t>(_b))),
95 c_(),
96 padding0__(0),
97 padding1__(0),
98 d_()
99 {
100 (void)padding0__;
101 (void)padding1__;
102 }
NestedStruct(::flatbuffers::span<const int32_t,2> _a,MyGame::Example::TestEnum _b,::flatbuffers::span<const MyGame::Example::TestEnum,2> _c,::flatbuffers::span<const int64_t,2> _d)103 NestedStruct(::flatbuffers::span<const int32_t, 2> _a, MyGame::Example::TestEnum _b,
104 ::flatbuffers::span<const MyGame::Example::TestEnum, 2> _c,
105 ::flatbuffers::span<const int64_t, 2> _d)
106 : b_(::flatbuffers::EndianScalar(static_cast<int8_t>(_b))), padding0__(0), padding1__(0)
107 {
108 ::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
109 ::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_).CopyFromSpan(_c);
110 (void)padding0__;
111 (void)padding1__;
112 ::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
113 }
a()114 const ::flatbuffers::Array<int32_t, 2> *a() const
115 {
116 return &::flatbuffers::CastToArray(a_);
117 }
mutable_a()118 ::flatbuffers::Array<int32_t, 2> *mutable_a()
119 {
120 return &::flatbuffers::CastToArray(a_);
121 }
b()122 MyGame::Example::TestEnum b() const
123 {
124 return static_cast<MyGame::Example::TestEnum>(::flatbuffers::EndianScalar(b_));
125 }
mutate_b(MyGame::Example::TestEnum _b)126 void mutate_b(MyGame::Example::TestEnum _b)
127 {
128 ::flatbuffers::WriteScalar(&b_, static_cast<int8_t>(_b));
129 }
c()130 const ::flatbuffers::Array<MyGame::Example::TestEnum, 2> *c() const
131 {
132 return &::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_);
133 }
mutable_c()134 ::flatbuffers::Array<MyGame::Example::TestEnum, 2> *mutable_c()
135 {
136 return &::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_);
137 }
d()138 const ::flatbuffers::Array<int64_t, 2> *d() const
139 {
140 return &::flatbuffers::CastToArray(d_);
141 }
mutable_d()142 ::flatbuffers::Array<int64_t, 2> *mutable_d()
143 {
144 return &::flatbuffers::CastToArray(d_);
145 }
146 };
147 FLATBUFFERS_STRUCT_END(NestedStruct, 32);
148
149 inline bool operator==(const NestedStruct &lhs, const NestedStruct &rhs)
150 {
151 return (*lhs.a() == *rhs.a()) && (lhs.b() == rhs.b()) && (*lhs.c() == *rhs.c()) &&
152 (*lhs.d() == *rhs.d());
153 }
154
155 inline bool operator!=(const NestedStruct &lhs, const NestedStruct &rhs)
156 {
157 return !(lhs == rhs);
158 }
159
160 struct NestedStruct::Traits
161 {
162 using type = NestedStruct;
163 };
164
165 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS
166 {
167 private:
168 float a_;
169 int32_t b_[15];
170 int8_t c_;
171 int8_t padding0__;
172 int16_t padding1__;
173 int32_t padding2__;
174 MyGame::Example::NestedStruct d_[2];
175 int32_t e_;
176 int32_t padding3__;
177 int64_t f_[2];
178
179 public:
180 struct Traits;
MiniReflectTypeTable()181 static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
182 {
183 return ArrayStructTypeTable();
184 }
ArrayStruct()185 ArrayStruct()
186 : a_(0),
187 b_(),
188 c_(0),
189 padding0__(0),
190 padding1__(0),
191 padding2__(0),
192 d_(),
193 e_(0),
194 padding3__(0),
195 f_()
196 {
197 (void)padding0__;
198 (void)padding1__;
199 (void)padding2__;
200 (void)padding3__;
201 }
ArrayStruct(float _a,int8_t _c,int32_t _e)202 ArrayStruct(float _a, int8_t _c, int32_t _e)
203 : a_(::flatbuffers::EndianScalar(_a)),
204 b_(),
205 c_(::flatbuffers::EndianScalar(_c)),
206 padding0__(0),
207 padding1__(0),
208 padding2__(0),
209 d_(),
210 e_(::flatbuffers::EndianScalar(_e)),
211 padding3__(0),
212 f_()
213 {
214 (void)padding0__;
215 (void)padding1__;
216 (void)padding2__;
217 (void)padding3__;
218 }
ArrayStruct(float _a,::flatbuffers::span<const int32_t,15> _b,int8_t _c,::flatbuffers::span<const MyGame::Example::NestedStruct,2> _d,int32_t _e,::flatbuffers::span<const int64_t,2> _f)219 ArrayStruct(float _a, ::flatbuffers::span<const int32_t, 15> _b, int8_t _c,
220 ::flatbuffers::span<const MyGame::Example::NestedStruct, 2> _d, int32_t _e,
221 ::flatbuffers::span<const int64_t, 2> _f)
222 : a_(::flatbuffers::EndianScalar(_a)),
223 c_(::flatbuffers::EndianScalar(_c)),
224 padding0__(0),
225 padding1__(0),
226 padding2__(0),
227 e_(::flatbuffers::EndianScalar(_e)),
228 padding3__(0)
229 {
230 ::flatbuffers::CastToArray(b_).CopyFromSpan(_b);
231 (void)padding0__;
232 (void)padding1__;
233 (void)padding2__;
234 ::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
235 (void)padding3__;
236 ::flatbuffers::CastToArray(f_).CopyFromSpan(_f);
237 }
a()238 float a() const
239 {
240 return ::flatbuffers::EndianScalar(a_);
241 }
mutate_a(float _a)242 void mutate_a(float _a)
243 {
244 ::flatbuffers::WriteScalar(&a_, _a);
245 }
b()246 const ::flatbuffers::Array<int32_t, 15> *b() const
247 {
248 return &::flatbuffers::CastToArray(b_);
249 }
mutable_b()250 ::flatbuffers::Array<int32_t, 15> *mutable_b()
251 {
252 return &::flatbuffers::CastToArray(b_);
253 }
c()254 int8_t c() const
255 {
256 return ::flatbuffers::EndianScalar(c_);
257 }
mutate_c(int8_t _c)258 void mutate_c(int8_t _c)
259 {
260 ::flatbuffers::WriteScalar(&c_, _c);
261 }
d()262 const ::flatbuffers::Array<MyGame::Example::NestedStruct, 2> *d() const
263 {
264 return &::flatbuffers::CastToArray(d_);
265 }
mutable_d()266 ::flatbuffers::Array<MyGame::Example::NestedStruct, 2> *mutable_d()
267 {
268 return &::flatbuffers::CastToArray(d_);
269 }
e()270 int32_t e() const
271 {
272 return ::flatbuffers::EndianScalar(e_);
273 }
mutate_e(int32_t _e)274 void mutate_e(int32_t _e)
275 {
276 ::flatbuffers::WriteScalar(&e_, _e);
277 }
f()278 const ::flatbuffers::Array<int64_t, 2> *f() const
279 {
280 return &::flatbuffers::CastToArray(f_);
281 }
mutable_f()282 ::flatbuffers::Array<int64_t, 2> *mutable_f()
283 {
284 return &::flatbuffers::CastToArray(f_);
285 }
286 };
287 FLATBUFFERS_STRUCT_END(ArrayStruct, 160);
288
289 inline bool operator==(const ArrayStruct &lhs, const ArrayStruct &rhs)
290 {
291 return (lhs.a() == rhs.a()) && (*lhs.b() == *rhs.b()) && (lhs.c() == rhs.c()) &&
292 (*lhs.d() == *rhs.d()) && (lhs.e() == rhs.e()) && (*lhs.f() == *rhs.f());
293 }
294
295 inline bool operator!=(const ArrayStruct &lhs, const ArrayStruct &rhs)
296 {
297 return !(lhs == rhs);
298 }
299
300 struct ArrayStruct::Traits
301 {
302 using type = ArrayStruct;
303 };
304
305 struct ArrayTableT : public ::flatbuffers::NativeTable
306 {
307 typedef ArrayTable TableType;
308 std::unique_ptr<MyGame::Example::ArrayStruct> a{};
309 ArrayTableT() = default;
310 ArrayTableT(const ArrayTableT &o);
311 ArrayTableT(ArrayTableT &&) FLATBUFFERS_NOEXCEPT = default;
312 ArrayTableT &operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT;
313 };
314
315 struct ArrayTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
316 {
317 typedef ArrayTableT NativeTableType;
318 typedef ArrayTableBuilder Builder;
319 struct Traits;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS320 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { return ArrayTableTypeTable(); }
321 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
322 {
323 VT_A = 4
324 };
aFLATBUFFERS_FINAL_CLASS325 const MyGame::Example::ArrayStruct *a() const
326 {
327 return GetStruct<const MyGame::Example::ArrayStruct *>(VT_A);
328 }
mutable_aFLATBUFFERS_FINAL_CLASS329 MyGame::Example::ArrayStruct *mutable_a()
330 {
331 return GetStruct<MyGame::Example::ArrayStruct *>(VT_A);
332 }
VerifyFLATBUFFERS_FINAL_CLASS333 bool Verify(::flatbuffers::Verifier &verifier) const
334 {
335 return VerifyTableStart(verifier) &&
336 VerifyField<MyGame::Example::ArrayStruct>(verifier, VT_A, 8) && verifier.EndTable();
337 }
338 ArrayTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
339 void UnPackTo(ArrayTableT *_o,
340 const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
341 static ::flatbuffers::Offset<ArrayTable> Pack(
342 ::flatbuffers::FlatBufferBuilder &_fbb,
343 const ArrayTableT *_o,
344 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
345 };
346
347 struct ArrayTableBuilder
348 {
349 typedef ArrayTable Table;
350 ::flatbuffers::FlatBufferBuilder &fbb_;
351 ::flatbuffers::uoffset_t start_;
add_aArrayTableBuilder352 void add_a(const MyGame::Example::ArrayStruct *a) { fbb_.AddStruct(ArrayTable::VT_A, a); }
ArrayTableBuilderArrayTableBuilder353 explicit ArrayTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
354 {
355 start_ = fbb_.StartTable();
356 }
FinishArrayTableBuilder357 ::flatbuffers::Offset<ArrayTable> Finish()
358 {
359 const auto end = fbb_.EndTable(start_);
360 auto o = ::flatbuffers::Offset<ArrayTable>(end);
361 return o;
362 }
363 };
364
365 inline ::flatbuffers::Offset<ArrayTable> CreateArrayTable(
366 ::flatbuffers::FlatBufferBuilder &_fbb,
367 const MyGame::Example::ArrayStruct *a = nullptr)
368 {
369 ArrayTableBuilder builder_(_fbb);
370 builder_.add_a(a);
371 return builder_.Finish();
372 }
373
374 struct ArrayTable::Traits
375 {
376 using type = ArrayTable;
377 static auto constexpr Create = CreateArrayTable;
378 };
379
380 ::flatbuffers::Offset<ArrayTable> CreateArrayTable(
381 ::flatbuffers::FlatBufferBuilder &_fbb,
382 const ArrayTableT *_o,
383 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
384
385 inline bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs)
386 {
387 return ((lhs.a == rhs.a) || (lhs.a && rhs.a && *lhs.a == *rhs.a));
388 }
389
390 inline bool operator!=(const ArrayTableT &lhs, const ArrayTableT &rhs)
391 {
392 return !(lhs == rhs);
393 }
394
ArrayTableT(const ArrayTableT & o)395 inline ArrayTableT::ArrayTableT(const ArrayTableT &o)
396 : a((o.a) ? new MyGame::Example::ArrayStruct(*o.a) : nullptr)
397 {}
398
399 inline ArrayTableT &ArrayTableT::operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT
400 {
401 std::swap(a, o.a);
402 return *this;
403 }
404
UnPack(const::flatbuffers::resolver_function_t * _resolver)405 inline ArrayTableT *ArrayTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const
406 {
407 auto _o = std::make_unique<ArrayTableT>();
408 UnPackTo(_o.get(), _resolver);
409 return _o.release();
410 }
411
UnPackTo(ArrayTableT * _o,const::flatbuffers::resolver_function_t * _resolver)412 inline void ArrayTable::UnPackTo(ArrayTableT *_o,
413 const ::flatbuffers::resolver_function_t *_resolver) const
414 {
415 (void)_o;
416 (void)_resolver;
417 {
418 auto _e = a();
419 if (_e)
420 {
421 _o->a = std::unique_ptr<MyGame::Example::ArrayStruct>(
422 new MyGame::Example::ArrayStruct(*_e));
423 }
424 }
425 }
426
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const ArrayTableT * _o,const::flatbuffers::rehasher_function_t * _rehasher)427 inline ::flatbuffers::Offset<ArrayTable> ArrayTable::Pack(
428 ::flatbuffers::FlatBufferBuilder &_fbb,
429 const ArrayTableT *_o,
430 const ::flatbuffers::rehasher_function_t *_rehasher)
431 {
432 return CreateArrayTable(_fbb, _o, _rehasher);
433 }
434
CreateArrayTable(::flatbuffers::FlatBufferBuilder & _fbb,const ArrayTableT * _o,const::flatbuffers::rehasher_function_t * _rehasher)435 inline ::flatbuffers::Offset<ArrayTable> CreateArrayTable(
436 ::flatbuffers::FlatBufferBuilder &_fbb,
437 const ArrayTableT *_o,
438 const ::flatbuffers::rehasher_function_t *_rehasher)
439 {
440 (void)_rehasher;
441 (void)_o;
442 struct _VectorArgs
443 {
444 ::flatbuffers::FlatBufferBuilder *__fbb;
445 const ArrayTableT *__o;
446 const ::flatbuffers::rehasher_function_t *__rehasher;
447 } _va = {&_fbb, _o, _rehasher};
448 (void)_va;
449 auto _a = _o->a ? _o->a.get() : nullptr;
450 return MyGame::Example::CreateArrayTable(_fbb, _a);
451 }
452
TestEnumTypeTable()453 inline const ::flatbuffers::TypeTable *TestEnumTypeTable()
454 {
455 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_CHAR, 0, 0},
456 {::flatbuffers::ET_CHAR, 0, 0},
457 {::flatbuffers::ET_CHAR, 0, 0}};
458 static const ::flatbuffers::TypeFunction type_refs[] = {MyGame::Example::TestEnumTypeTable};
459 static const char *const names[] = {"A", "B", "C"};
460 static const ::flatbuffers::TypeTable tt = {
461 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names};
462 return &tt;
463 }
464
NestedStructTypeTable()465 inline const ::flatbuffers::TypeTable *NestedStructTypeTable()
466 {
467 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_INT, 1, -1},
468 {::flatbuffers::ET_CHAR, 0, 0},
469 {::flatbuffers::ET_CHAR, 1, 0},
470 {::flatbuffers::ET_LONG, 1, -1}};
471 static const ::flatbuffers::TypeFunction type_refs[] = {MyGame::Example::TestEnumTypeTable};
472 static const int16_t array_sizes[] = {
473 2,
474 2,
475 2,
476 };
477 static const int64_t values[] = {0, 8, 9, 16, 32};
478 static const char *const names[] = {"a", "b", "c", "d"};
479 static const ::flatbuffers::TypeTable tt = {
480 ::flatbuffers::ST_STRUCT, 4, type_codes, type_refs, array_sizes, values, names};
481 return &tt;
482 }
483
ArrayStructTypeTable()484 inline const ::flatbuffers::TypeTable *ArrayStructTypeTable()
485 {
486 static const ::flatbuffers::TypeCode type_codes[] = {
487 {::flatbuffers::ET_FLOAT, 0, -1}, {::flatbuffers::ET_INT, 1, -1},
488 {::flatbuffers::ET_CHAR, 0, -1}, {::flatbuffers::ET_SEQUENCE, 1, 0},
489 {::flatbuffers::ET_INT, 0, -1}, {::flatbuffers::ET_LONG, 1, -1}};
490 static const ::flatbuffers::TypeFunction type_refs[] = {MyGame::Example::NestedStructTypeTable};
491 static const int16_t array_sizes[] = {
492 15,
493 2,
494 2,
495 };
496 static const int64_t values[] = {0, 4, 64, 72, 136, 144, 160};
497 static const char *const names[] = {"a", "b", "c", "d", "e", "f"};
498 static const ::flatbuffers::TypeTable tt = {
499 ::flatbuffers::ST_STRUCT, 6, type_codes, type_refs, array_sizes, values, names};
500 return &tt;
501 }
502
ArrayTableTypeTable()503 inline const ::flatbuffers::TypeTable *ArrayTableTypeTable()
504 {
505 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_SEQUENCE, 0, 0}};
506 static const ::flatbuffers::TypeFunction type_refs[] = {MyGame::Example::ArrayStructTypeTable};
507 static const char *const names[] = {"a"};
508 static const ::flatbuffers::TypeTable tt = {
509 ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names};
510 return &tt;
511 }
512
GetArrayTable(const void * buf)513 inline const MyGame::Example::ArrayTable *GetArrayTable(const void *buf)
514 {
515 return ::flatbuffers::GetRoot<MyGame::Example::ArrayTable>(buf);
516 }
517
GetSizePrefixedArrayTable(const void * buf)518 inline const MyGame::Example::ArrayTable *GetSizePrefixedArrayTable(const void *buf)
519 {
520 return ::flatbuffers::GetSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
521 }
522
GetMutableArrayTable(void * buf)523 inline ArrayTable *GetMutableArrayTable(void *buf)
524 {
525 return ::flatbuffers::GetMutableRoot<ArrayTable>(buf);
526 }
527
GetMutableSizePrefixedArrayTable(void * buf)528 inline MyGame::Example::ArrayTable *GetMutableSizePrefixedArrayTable(void *buf)
529 {
530 return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
531 }
532
ArrayTableIdentifier()533 inline const char *ArrayTableIdentifier()
534 {
535 return "ARRT";
536 }
537
ArrayTableBufferHasIdentifier(const void * buf)538 inline bool ArrayTableBufferHasIdentifier(const void *buf)
539 {
540 return ::flatbuffers::BufferHasIdentifier(buf, ArrayTableIdentifier());
541 }
542
SizePrefixedArrayTableBufferHasIdentifier(const void * buf)543 inline bool SizePrefixedArrayTableBufferHasIdentifier(const void *buf)
544 {
545 return ::flatbuffers::BufferHasIdentifier(buf, ArrayTableIdentifier(), true);
546 }
547
VerifyArrayTableBuffer(::flatbuffers::Verifier & verifier)548 inline bool VerifyArrayTableBuffer(::flatbuffers::Verifier &verifier)
549 {
550 return verifier.VerifyBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
551 }
552
VerifySizePrefixedArrayTableBuffer(::flatbuffers::Verifier & verifier)553 inline bool VerifySizePrefixedArrayTableBuffer(::flatbuffers::Verifier &verifier)
554 {
555 return verifier.VerifySizePrefixedBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
556 }
557
ArrayTableExtension()558 inline const char *ArrayTableExtension()
559 {
560 return "mon";
561 }
562
FinishArrayTableBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<MyGame::Example::ArrayTable> root)563 inline void FinishArrayTableBuffer(::flatbuffers::FlatBufferBuilder &fbb,
564 ::flatbuffers::Offset<MyGame::Example::ArrayTable> root)
565 {
566 fbb.Finish(root, ArrayTableIdentifier());
567 }
568
FinishSizePrefixedArrayTableBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<MyGame::Example::ArrayTable> root)569 inline void FinishSizePrefixedArrayTableBuffer(
570 ::flatbuffers::FlatBufferBuilder &fbb,
571 ::flatbuffers::Offset<MyGame::Example::ArrayTable> root)
572 {
573 fbb.FinishSizePrefixed(root, ArrayTableIdentifier());
574 }
575
576 inline std::unique_ptr<MyGame::Example::ArrayTableT> UnPackArrayTable(
577 const void *buf,
578 const ::flatbuffers::resolver_function_t *res = nullptr)
579 {
580 return std::unique_ptr<MyGame::Example::ArrayTableT>(GetArrayTable(buf)->UnPack(res));
581 }
582
583 inline std::unique_ptr<MyGame::Example::ArrayTableT> UnPackSizePrefixedArrayTable(
584 const void *buf,
585 const ::flatbuffers::resolver_function_t *res = nullptr)
586 {
587 return std::unique_ptr<MyGame::Example::ArrayTableT>(
588 GetSizePrefixedArrayTable(buf)->UnPack(res));
589 }
590
591 } // namespace Example
592 } // namespace MyGame
593
594 #endif // FLATBUFFERS_GENERATED_ARRAYSTEST_MYGAME_EXAMPLE_H_
595