1// automatically generated by the FlatBuffers compiler, do not modify
2
3
4#ifndef FLATBUFFERS_GENERATED_TEST64BIT_H_
5#define FLATBUFFERS_GENERATED_TEST64BIT_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
16// For access to the binary schema that produced this file.
17#include "test_64bit_bfbs_generated.h"
18
19struct LeafStruct;
20
21struct WrapperTable;
22struct WrapperTableBuilder;
23struct WrapperTableT;
24
25struct RootTable;
26struct RootTableBuilder;
27struct RootTableT;
28
29bool operator==(const LeafStruct &lhs, const LeafStruct &rhs);
30bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs);
31bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs);
32bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs);
33bool operator==(const RootTableT &lhs, const RootTableT &rhs);
34bool operator!=(const RootTableT &lhs, const RootTableT &rhs);
35
36inline const ::flatbuffers::TypeTable *LeafStructTypeTable();
37
38inline const ::flatbuffers::TypeTable *WrapperTableTypeTable();
39
40inline const ::flatbuffers::TypeTable *RootTableTypeTable();
41
42FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) LeafStruct FLATBUFFERS_FINAL_CLASS {
43 private:
44 int32_t a_;
45 int32_t padding0__;
46 double b_;
47
48 public:
49 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
50 return LeafStructTypeTable();
51 }
52 LeafStruct()
53 : a_(0),
54 padding0__(0),
55 b_(0) {
56 (void)padding0__;
57 }
58 LeafStruct(int32_t _a, double _b)
59 : a_(::flatbuffers::EndianScalar(_a)),
60 padding0__(0),
61 b_(::flatbuffers::EndianScalar(_b)) {
62 (void)padding0__;
63 }
64 int32_t a() const {
65 return ::flatbuffers::EndianScalar(a_);
66 }
67 void mutate_a(int32_t _a) {
68 ::flatbuffers::WriteScalar(&a_, _a);
69 }
70 double b() const {
71 return ::flatbuffers::EndianScalar(b_);
72 }
73 void mutate_b(double _b) {
74 ::flatbuffers::WriteScalar(&b_, _b);
75 }
76};
77FLATBUFFERS_STRUCT_END(LeafStruct, 16);
78
79inline bool operator==(const LeafStruct &lhs, const LeafStruct &rhs) {
80 return
81 (lhs.a() == rhs.a()) &&
82 (lhs.b() == rhs.b());
83}
84
85inline bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs) {
86 return !(lhs == rhs);
87}
88
89
90struct WrapperTableT : public ::flatbuffers::NativeTable {
91 typedef WrapperTable TableType;
92 std::vector<int8_t> vector{};
93};
94
95struct WrapperTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
96 typedef WrapperTableT NativeTableType;
97 typedef WrapperTableBuilder Builder;
98 typedef RootTableBinarySchema BinarySchema;
99 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
100 return WrapperTableTypeTable();
101 }
102 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
103 VT_VECTOR = 4
104 };
105 const ::flatbuffers::Vector<int8_t> *vector() const {
106 return GetPointer64<const ::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
107 }
108 ::flatbuffers::Vector<int8_t> *mutable_vector() {
109 return GetPointer64<::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
110 }
111 bool Verify(::flatbuffers::Verifier &verifier) const {
112 return VerifyTableStart(verifier) &&
113 VerifyOffset64(verifier, VT_VECTOR) &&
114 verifier.VerifyVector(vector()) &&
115 verifier.EndTable();
116 }
117 WrapperTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
118 void UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
119 static ::flatbuffers::Offset<WrapperTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
120};
121
122struct WrapperTableBuilder {
123 typedef WrapperTable Table;
124 ::flatbuffers::FlatBufferBuilder64 &fbb_;
125 ::flatbuffers::uoffset_t start_;
126 void add_vector(::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector) {
127 fbb_.AddOffset(WrapperTable::VT_VECTOR, vector);
128 }
129 explicit WrapperTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
130 : fbb_(_fbb) {
131 start_ = fbb_.StartTable();
132 }
133 ::flatbuffers::Offset<WrapperTable> Finish() {
134 const auto end = fbb_.EndTable(start_);
135 auto o = ::flatbuffers::Offset<WrapperTable>(end);
136 return o;
137 }
138};
139
140inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable(
141 ::flatbuffers::FlatBufferBuilder64 &_fbb,
142 ::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector = 0) {
143 WrapperTableBuilder builder_(_fbb);
144 builder_.add_vector(vector);
145 return builder_.Finish();
146}
147
148inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTableDirect(
149 ::flatbuffers::FlatBufferBuilder64 &_fbb,
150 const std::vector<int8_t> *vector = nullptr) {
151 auto vector__ = vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*vector) : 0;
152 return CreateWrapperTable(
153 _fbb,
154 vector__);
155}
156
157::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
158
159struct RootTableT : public ::flatbuffers::NativeTable {
160 typedef RootTable TableType;
161 std::vector<uint8_t> far_vector{};
162 int32_t a = 0;
163 std::string far_string{};
164 std::vector<uint8_t> big_vector{};
165 std::string near_string{};
166 std::vector<uint8_t> nested_root{};
167 std::vector<LeafStruct> far_struct_vector{};
168 std::vector<LeafStruct> big_struct_vector{};
169 std::vector<std::unique_ptr<WrapperTableT>> many_vectors{};
170 RootTableT() = default;
171 RootTableT(const RootTableT &o);
172 RootTableT(RootTableT&&) FLATBUFFERS_NOEXCEPT = default;
173 RootTableT &operator=(RootTableT o) FLATBUFFERS_NOEXCEPT;
174};
175
176struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
177 typedef RootTableT NativeTableType;
178 typedef RootTableBuilder Builder;
179 typedef RootTableBinarySchema BinarySchema;
180 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
181 return RootTableTypeTable();
182 }
183 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
184 VT_FAR_VECTOR = 4,
185 VT_A = 6,
186 VT_FAR_STRING = 8,
187 VT_BIG_VECTOR = 10,
188 VT_NEAR_STRING = 12,
189 VT_NESTED_ROOT = 14,
190 VT_FAR_STRUCT_VECTOR = 16,
191 VT_BIG_STRUCT_VECTOR = 18,
192 VT_MANY_VECTORS = 20
193 };
194 const ::flatbuffers::Vector<uint8_t> *far_vector() const {
195 return GetPointer64<const ::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR);
196 }
197 ::flatbuffers::Vector<uint8_t> *mutable_far_vector() {
198 return GetPointer64<::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR);
199 }
200 int32_t a() const {
201 return GetField<int32_t>(VT_A, 0);
202 }
203 bool mutate_a(int32_t _a = 0) {
204 return SetField<int32_t>(VT_A, _a, 0);
205 }
206 const ::flatbuffers::String *far_string() const {
207 return GetPointer64<const ::flatbuffers::String *>(VT_FAR_STRING);
208 }
209 ::flatbuffers::String *mutable_far_string() {
210 return GetPointer64<::flatbuffers::String *>(VT_FAR_STRING);
211 }
212 const ::flatbuffers::Vector64<uint8_t> *big_vector() const {
213 return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
214 }
215 ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() {
216 return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
217 }
218 const ::flatbuffers::String *near_string() const {
219 return GetPointer<const ::flatbuffers::String *>(VT_NEAR_STRING);
220 }
221 ::flatbuffers::String *mutable_near_string() {
222 return GetPointer<::flatbuffers::String *>(VT_NEAR_STRING);
223 }
224 const ::flatbuffers::Vector64<uint8_t> *nested_root() const {
225 return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT);
226 }
227 ::flatbuffers::Vector64<uint8_t> *mutable_nested_root() {
228 return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT);
229 }
230 const RootTable *nested_root_nested_root() const {
231 const auto _f = nested_root();
232 return _f ? ::flatbuffers::GetRoot<RootTable>(_f->Data())
233 : nullptr;
234 }
235 const ::flatbuffers::Vector<const LeafStruct *> *far_struct_vector() const {
236 return GetPointer64<const ::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR);
237 }
238 ::flatbuffers::Vector<const LeafStruct *> *mutable_far_struct_vector() {
239 return GetPointer64<::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR);
240 }
241 const ::flatbuffers::Vector64<const LeafStruct *> *big_struct_vector() const {
242 return GetPointer64<const ::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR);
243 }
244 ::flatbuffers::Vector64<const LeafStruct *> *mutable_big_struct_vector() {
245 return GetPointer64<::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR);
246 }
247 const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *many_vectors() const {
248 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS);
249 }
250 ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *mutable_many_vectors() {
251 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS);
252 }
253 bool Verify(::flatbuffers::Verifier &verifier) const {
254 return VerifyTableStart(verifier) &&
255 VerifyOffset64(verifier, VT_FAR_VECTOR) &&
256 verifier.VerifyVector(far_vector()) &&
257 VerifyField<int32_t>(verifier, VT_A, 4) &&
258 VerifyOffset64(verifier, VT_FAR_STRING) &&
259 verifier.VerifyString(far_string()) &&
260 VerifyOffset64(verifier, VT_BIG_VECTOR) &&
261 verifier.VerifyVector(big_vector()) &&
262 VerifyOffset(verifier, VT_NEAR_STRING) &&
263 verifier.VerifyString(near_string()) &&
264 VerifyOffset64(verifier, VT_NESTED_ROOT) &&
265 verifier.VerifyVector(nested_root()) &&
266 verifier.VerifyNestedFlatBuffer<RootTable>(nested_root(), nullptr) &&
267 VerifyOffset64(verifier, VT_FAR_STRUCT_VECTOR) &&
268 verifier.VerifyVector(far_struct_vector()) &&
269 VerifyOffset64(verifier, VT_BIG_STRUCT_VECTOR) &&
270 verifier.VerifyVector(big_struct_vector()) &&
271 VerifyOffset(verifier, VT_MANY_VECTORS) &&
272 verifier.VerifyVector(many_vectors()) &&
273 verifier.VerifyVectorOfTables(many_vectors()) &&
274 verifier.EndTable();
275 }
276 RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
277 void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
278 static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
279};
280
281struct RootTableBuilder {
282 typedef RootTable Table;
283 ::flatbuffers::FlatBufferBuilder64 &fbb_;
284 ::flatbuffers::uoffset_t start_;
285 void add_far_vector(::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector) {
286 fbb_.AddOffset(RootTable::VT_FAR_VECTOR, far_vector);
287 }
288 void add_a(int32_t a) {
289 fbb_.AddElement<int32_t>(RootTable::VT_A, a, 0);
290 }
291 void add_far_string(::flatbuffers::Offset64<::flatbuffers::String> far_string) {
292 fbb_.AddOffset(RootTable::VT_FAR_STRING, far_string);
293 }
294 void add_big_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector) {
295 fbb_.AddOffset(RootTable::VT_BIG_VECTOR, big_vector);
296 }
297 void add_near_string(::flatbuffers::Offset<::flatbuffers::String> near_string) {
298 fbb_.AddOffset(RootTable::VT_NEAR_STRING, near_string);
299 }
300 void add_nested_root(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root) {
301 fbb_.AddOffset(RootTable::VT_NESTED_ROOT, nested_root);
302 }
303 void add_far_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector) {
304 fbb_.AddOffset(RootTable::VT_FAR_STRUCT_VECTOR, far_struct_vector);
305 }
306 void add_big_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector) {
307 fbb_.AddOffset(RootTable::VT_BIG_STRUCT_VECTOR, big_struct_vector);
308 }
309 void add_many_vectors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors) {
310 fbb_.AddOffset(RootTable::VT_MANY_VECTORS, many_vectors);
311 }
312 explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
313 : fbb_(_fbb) {
314 start_ = fbb_.StartTable();
315 }
316 ::flatbuffers::Offset<RootTable> Finish() {
317 const auto end = fbb_.EndTable(start_);
318 auto o = ::flatbuffers::Offset<RootTable>(end);
319 return o;
320 }
321};
322
323inline ::flatbuffers::Offset<RootTable> CreateRootTable(
324 ::flatbuffers::FlatBufferBuilder64 &_fbb,
325 ::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector = 0,
326 int32_t a = 0,
327 ::flatbuffers::Offset64<::flatbuffers::String> far_string = 0,
328 ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector = 0,
329 ::flatbuffers::Offset<::flatbuffers::String> near_string = 0,
330 ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root = 0,
331 ::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector = 0,
332 ::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector = 0,
333 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors = 0) {
334 RootTableBuilder builder_(_fbb);
335 builder_.add_big_struct_vector(big_struct_vector);
336 builder_.add_nested_root(nested_root);
337 builder_.add_big_vector(big_vector);
338 builder_.add_many_vectors(many_vectors);
339 builder_.add_far_struct_vector(far_struct_vector);
340 builder_.add_near_string(near_string);
341 builder_.add_far_string(far_string);
342 builder_.add_a(a);
343 builder_.add_far_vector(far_vector);
344 return builder_.Finish();
345}
346
347inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect(
348 ::flatbuffers::FlatBufferBuilder64 &_fbb,
349 const std::vector<uint8_t> *far_vector = nullptr,
350 int32_t a = 0,
351 const char *far_string = nullptr,
352 const std::vector<uint8_t> *big_vector = nullptr,
353 const char *near_string = nullptr,
354 const std::vector<uint8_t> *nested_root = nullptr,
355 const std::vector<LeafStruct> *far_struct_vector = nullptr,
356 const std::vector<LeafStruct> *big_struct_vector = nullptr,
357 const std::vector<::flatbuffers::Offset<WrapperTable>> *many_vectors = nullptr) {
358 auto far_vector__ = far_vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*far_vector) : 0;
359 auto far_string__ = far_string ? _fbb.CreateString<::flatbuffers::Offset64>(far_string) : 0;
360 auto big_vector__ = big_vector ? _fbb.CreateVector64(*big_vector) : 0;
361 auto nested_root__ = nested_root ? _fbb.CreateVector64(*nested_root) : 0;
362 auto far_struct_vector__ = far_struct_vector ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(*far_struct_vector) : 0;
363 auto big_struct_vector__ = big_struct_vector ? _fbb.CreateVectorOfStructs64(*big_struct_vector) : 0;
364 auto near_string__ = near_string ? _fbb.CreateString(near_string) : 0;
365 auto many_vectors__ = many_vectors ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>>(*many_vectors) : 0;
366 return CreateRootTable(
367 _fbb,
368 far_vector__,
369 a,
370 far_string__,
371 big_vector__,
372 near_string__,
373 nested_root__,
374 far_struct_vector__,
375 big_struct_vector__,
376 many_vectors__);
377}
378
379::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
380
381
382inline bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs) {
383 return
384 (lhs.vector == rhs.vector);
385}
386
387inline bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs) {
388 return !(lhs == rhs);
389}
390
391
392inline WrapperTableT *WrapperTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
393 auto _o = std::unique_ptr<WrapperTableT>(new WrapperTableT());
394 UnPackTo(_o.get(), _resolver);
395 return _o.release();
396}
397
398inline void WrapperTable::UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
399 (void)_o;
400 (void)_resolver;
401 { auto _e = vector(); if (_e) { _o->vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->vector.begin()); } }
402}
403
404inline ::flatbuffers::Offset<WrapperTable> WrapperTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
405 return CreateWrapperTable(_fbb, _o, _rehasher);
406}
407
408inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
409 (void)_rehasher;
410 (void)_o;
411 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const WrapperTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
412 auto _vector = _o->vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->vector) : 0;
413 return CreateWrapperTable(
414 _fbb,
415 _vector);
416}
417
418
419inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) {
420 return
421 (lhs.far_vector == rhs.far_vector) &&
422 (lhs.a == rhs.a) &&
423 (lhs.far_string == rhs.far_string) &&
424 (lhs.big_vector == rhs.big_vector) &&
425 (lhs.near_string == rhs.near_string) &&
426 (lhs.nested_root == rhs.nested_root) &&
427 (lhs.far_struct_vector == rhs.far_struct_vector) &&
428 (lhs.big_struct_vector == rhs.big_struct_vector) &&
429 (lhs.many_vectors.size() == rhs.many_vectors.size() && std::equal(lhs.many_vectors.cbegin(), lhs.many_vectors.cend(), rhs.many_vectors.cbegin(), [](std::unique_ptr<WrapperTableT> const &a, std::unique_ptr<WrapperTableT> const &b) { return (a == b) || (a && b && *a == *b); }));
430}
431
432inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) {
433 return !(lhs == rhs);
434}
435
436
437inline RootTableT::RootTableT(const RootTableT &o)
438 : far_vector(o.far_vector),
439 a(o.a),
440 far_string(o.far_string),
441 big_vector(o.big_vector),
442 near_string(o.near_string),
443 nested_root(o.nested_root),
444 far_struct_vector(o.far_struct_vector),
445 big_struct_vector(o.big_struct_vector) {
446 many_vectors.reserve(o.many_vectors.size());
447 for (const auto &many_vectors_ : o.many_vectors) { many_vectors.emplace_back((many_vectors_) ? new WrapperTableT(*many_vectors_) : nullptr); }
448}
449
450inline RootTableT &RootTableT::operator=(RootTableT o) FLATBUFFERS_NOEXCEPT {
451 std::swap(far_vector, o.far_vector);
452 std::swap(a, o.a);
453 std::swap(far_string, o.far_string);
454 std::swap(big_vector, o.big_vector);
455 std::swap(near_string, o.near_string);
456 std::swap(nested_root, o.nested_root);
457 std::swap(far_struct_vector, o.far_struct_vector);
458 std::swap(big_struct_vector, o.big_struct_vector);
459 std::swap(many_vectors, o.many_vectors);
460 return *this;
461}
462
463inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
464 auto _o = std::unique_ptr<RootTableT>(new RootTableT());
465 UnPackTo(_o.get(), _resolver);
466 return _o.release();
467}
468
469inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
470 (void)_o;
471 (void)_resolver;
472 { auto _e = far_vector(); if (_e) { _o->far_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->far_vector.begin()); } }
473 { auto _e = a(); _o->a = _e; }
474 { auto _e = far_string(); if (_e) _o->far_string = _e->str(); }
475 { auto _e = big_vector(); if (_e) { _o->big_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_vector.begin()); } }
476 { auto _e = near_string(); if (_e) _o->near_string = _e->str(); }
477 { auto _e = nested_root(); if (_e) { _o->nested_root.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->nested_root.begin()); } }
478 { auto _e = far_struct_vector(); if (_e) { _o->far_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->far_struct_vector[_i] = *_e->Get(_i); } } else { _o->far_struct_vector.resize(0); } }
479 { auto _e = big_struct_vector(); if (_e) { _o->big_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset64_t _i = 0; _i < _e->size(); _i++) { _o->big_struct_vector[_i] = *_e->Get(_i); } } else { _o->big_struct_vector.resize(0); } }
480 { auto _e = many_vectors(); if (_e) { _o->many_vectors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->many_vectors[_i]) { _e->Get(_i)->UnPackTo(_o->many_vectors[_i].get(), _resolver); } else { _o->many_vectors[_i] = std::unique_ptr<WrapperTableT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->many_vectors.resize(0); } }
481}
482
483inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
484 return CreateRootTable(_fbb, _o, _rehasher);
485}
486
487inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
488 (void)_rehasher;
489 (void)_o;
490 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
491 auto _far_vector = _o->far_vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->far_vector) : 0;
492 auto _a = _o->a;
493 auto _far_string = _o->far_string.empty() ? 0 : _fbb.CreateString<::flatbuffers::Offset64>(_o->far_string);
494 auto _big_vector = _o->big_vector.size() ? _fbb.CreateVector64(_o->big_vector) : 0;
495 auto _near_string = _o->near_string.empty() ? 0 : _fbb.CreateString(_o->near_string);
496 auto _nested_root = _o->nested_root.size() ? _fbb.CreateVector64(_o->nested_root) : 0;
497 auto _far_struct_vector = _o->far_struct_vector.size() ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(_o->far_struct_vector) : 0;
498 auto _big_struct_vector = _o->big_struct_vector.size() ? _fbb.CreateVectorOfStructs64(_o->big_struct_vector) : 0;
499 auto _many_vectors = _o->many_vectors.size() ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>> (_o->many_vectors.size(), [](size_t i, _VectorArgs *__va) { return CreateWrapperTable(*__va->__fbb, __va->__o->many_vectors[i].get(), __va->__rehasher); }, &_va ) : 0;
500 return CreateRootTable(
501 _fbb,
502 _far_vector,
503 _a,
504 _far_string,
505 _big_vector,
506 _near_string,
507 _nested_root,
508 _far_struct_vector,
509 _big_struct_vector,
510 _many_vectors);
511}
512
513inline const ::flatbuffers::TypeTable *LeafStructTypeTable() {
514 static const ::flatbuffers::TypeCode type_codes[] = {
515 { ::flatbuffers::ET_INT, 0, -1 },
516 { ::flatbuffers::ET_DOUBLE, 0, -1 }
517 };
518 static const int64_t values[] = { 0, 8, 16 };
519 static const char * const names[] = {
520 "a",
521 "b"
522 };
523 static const ::flatbuffers::TypeTable tt = {
524 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
525 };
526 return &tt;
527}
528
529inline const ::flatbuffers::TypeTable *WrapperTableTypeTable() {
530 static const ::flatbuffers::TypeCode type_codes[] = {
531 { ::flatbuffers::ET_CHAR, 1, -1 }
532 };
533 static const char * const names[] = {
534 "vector"
535 };
536 static const ::flatbuffers::TypeTable tt = {
537 ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
538 };
539 return &tt;
540}
541
542inline const ::flatbuffers::TypeTable *RootTableTypeTable() {
543 static const ::flatbuffers::TypeCode type_codes[] = {
544 { ::flatbuffers::ET_UCHAR, 1, -1 },
545 { ::flatbuffers::ET_INT, 0, -1 },
546 { ::flatbuffers::ET_STRING, 0, -1 },
547 { ::flatbuffers::ET_UCHAR, 1, -1 },
548 { ::flatbuffers::ET_STRING, 0, -1 },
549 { ::flatbuffers::ET_UCHAR, 1, -1 },
550 { ::flatbuffers::ET_SEQUENCE, 1, 0 },
551 { ::flatbuffers::ET_SEQUENCE, 1, 0 },
552 { ::flatbuffers::ET_SEQUENCE, 1, 1 }
553 };
554 static const ::flatbuffers::TypeFunction type_refs[] = {
555 LeafStructTypeTable,
556 WrapperTableTypeTable
557 };
558 static const char * const names[] = {
559 "far_vector",
560 "a",
561 "far_string",
562 "big_vector",
563 "near_string",
564 "nested_root",
565 "far_struct_vector",
566 "big_struct_vector",
567 "many_vectors"
568 };
569 static const ::flatbuffers::TypeTable tt = {
570 ::flatbuffers::ST_TABLE, 9, type_codes, type_refs, nullptr, nullptr, names
571 };
572 return &tt;
573}
574
575inline const RootTable *GetRootTable(const void *buf) {
576 return ::flatbuffers::GetRoot<RootTable>(buf);
577}
578
579inline const RootTable *GetSizePrefixedRootTable(const void *buf) {
580 return ::flatbuffers::GetSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
581}
582
583inline RootTable *GetMutableRootTable(void *buf) {
584 return ::flatbuffers::GetMutableRoot<RootTable>(buf);
585}
586
587inline RootTable *GetMutableSizePrefixedRootTable(void *buf) {
588 return ::flatbuffers::GetMutableSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
589}
590
591inline bool VerifyRootTableBuffer(
592 ::flatbuffers::Verifier &verifier) {
593 return verifier.VerifyBuffer<RootTable>(nullptr);
594}
595
596inline bool VerifySizePrefixedRootTableBuffer(
597 ::flatbuffers::Verifier &verifier) {
598 return verifier.VerifySizePrefixedBuffer<RootTable,::flatbuffers::uoffset64_t>(nullptr);
599}
600
601inline void FinishRootTableBuffer(
602 ::flatbuffers::FlatBufferBuilder64 &fbb,
603 ::flatbuffers::Offset<RootTable> root) {
604 fbb.Finish(root);
605}
606
607inline void FinishSizePrefixedRootTableBuffer(
608 ::flatbuffers::FlatBufferBuilder64 &fbb,
609 ::flatbuffers::Offset<RootTable> root) {
610 fbb.FinishSizePrefixed(root);
611}
612
613inline std::unique_ptr<RootTableT> UnPackRootTable(
614 const void *buf,
615 const ::flatbuffers::resolver_function_t *res = nullptr) {
616 return std::unique_ptr<RootTableT>(GetRootTable(buf)->UnPack(res));
617}
618
619inline std::unique_ptr<RootTableT> UnPackSizePrefixedRootTable(
620 const void *buf,
621 const ::flatbuffers::resolver_function_t *res = nullptr) {
622 return std::unique_ptr<RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res));
623}
624
625#endif // FLATBUFFERS_GENERATED_TEST64BIT_H_
View as plain text