1 // automatically generated by the FlatBuffers compiler, do not modify
2
3 #ifndef FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
4 #define FLATBUFFERS_GENERATED_ALIGNMENTTEST_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 struct BadAlignmentSmall;
15
16 struct BadAlignmentLarge;
17
18 struct OuterLarge;
19 struct OuterLargeBuilder;
20 struct OuterLargeT;
21
22 struct BadAlignmentRoot;
23 struct BadAlignmentRootBuilder;
24 struct BadAlignmentRootT;
25
26 struct JustSmallStruct;
27
28 struct SmallStructs;
29 struct SmallStructsBuilder;
30 struct SmallStructsT;
31
32 bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs);
33 bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs);
34 bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs);
35 bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs);
36 bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs);
37 bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs);
38 bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
39 bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
40 bool operator==(const JustSmallStruct &lhs, const JustSmallStruct &rhs);
41 bool operator!=(const JustSmallStruct &lhs, const JustSmallStruct &rhs);
42 bool operator==(const SmallStructsT &lhs, const SmallStructsT &rhs);
43 bool operator!=(const SmallStructsT &lhs, const SmallStructsT &rhs);
44
45 inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable();
46
47 inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable();
48
49 inline const ::flatbuffers::TypeTable *OuterLargeTypeTable();
50
51 inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable();
52
53 inline const ::flatbuffers::TypeTable *JustSmallStructTypeTable();
54
55 inline const ::flatbuffers::TypeTable *SmallStructsTypeTable();
56
57 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4)
58 BadAlignmentSmall FLATBUFFERS_FINAL_CLASS
59 {
60 private:
61 uint32_t var_0_;
62 uint32_t var_1_;
63 uint32_t var_2_;
64
65 public:
66 struct Traits;
MiniReflectTypeTable()67 static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
68 {
69 return BadAlignmentSmallTypeTable();
70 }
BadAlignmentSmall()71 BadAlignmentSmall() : var_0_(0), var_1_(0), var_2_(0) {}
BadAlignmentSmall(uint32_t _var_0,uint32_t _var_1,uint32_t _var_2)72 BadAlignmentSmall(uint32_t _var_0, uint32_t _var_1, uint32_t _var_2)
73 : var_0_(::flatbuffers::EndianScalar(_var_0)),
74 var_1_(::flatbuffers::EndianScalar(_var_1)),
75 var_2_(::flatbuffers::EndianScalar(_var_2))
76 {}
var_0()77 uint32_t var_0() const
78 {
79 return ::flatbuffers::EndianScalar(var_0_);
80 }
mutate_var_0(uint32_t _var_0)81 void mutate_var_0(uint32_t _var_0)
82 {
83 ::flatbuffers::WriteScalar(&var_0_, _var_0);
84 }
var_1()85 uint32_t var_1() const
86 {
87 return ::flatbuffers::EndianScalar(var_1_);
88 }
mutate_var_1(uint32_t _var_1)89 void mutate_var_1(uint32_t _var_1)
90 {
91 ::flatbuffers::WriteScalar(&var_1_, _var_1);
92 }
var_2()93 uint32_t var_2() const
94 {
95 return ::flatbuffers::EndianScalar(var_2_);
96 }
mutate_var_2(uint32_t _var_2)97 void mutate_var_2(uint32_t _var_2)
98 {
99 ::flatbuffers::WriteScalar(&var_2_, _var_2);
100 }
101 };
102 FLATBUFFERS_STRUCT_END(BadAlignmentSmall, 12);
103
104 inline bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs)
105 {
106 return (lhs.var_0() == rhs.var_0()) && (lhs.var_1() == rhs.var_1()) &&
107 (lhs.var_2() == rhs.var_2());
108 }
109
110 inline bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs)
111 {
112 return !(lhs == rhs);
113 }
114
115 struct BadAlignmentSmall::Traits
116 {
117 using type = BadAlignmentSmall;
118 };
119
120 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8)
121 BadAlignmentLarge FLATBUFFERS_FINAL_CLASS
122 {
123 private:
124 uint64_t var_0_;
125
126 public:
127 struct Traits;
MiniReflectTypeTable()128 static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
129 {
130 return BadAlignmentLargeTypeTable();
131 }
BadAlignmentLarge()132 BadAlignmentLarge() : var_0_(0) {}
BadAlignmentLarge(uint64_t _var_0)133 BadAlignmentLarge(uint64_t _var_0) : var_0_(::flatbuffers::EndianScalar(_var_0)) {}
var_0()134 uint64_t var_0() const
135 {
136 return ::flatbuffers::EndianScalar(var_0_);
137 }
mutate_var_0(uint64_t _var_0)138 void mutate_var_0(uint64_t _var_0)
139 {
140 ::flatbuffers::WriteScalar(&var_0_, _var_0);
141 }
142 };
143 FLATBUFFERS_STRUCT_END(BadAlignmentLarge, 8);
144
145 inline bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs)
146 {
147 return (lhs.var_0() == rhs.var_0());
148 }
149
150 inline bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs)
151 {
152 return !(lhs == rhs);
153 }
154
155 struct BadAlignmentLarge::Traits
156 {
157 using type = BadAlignmentLarge;
158 };
159
160 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) JustSmallStruct FLATBUFFERS_FINAL_CLASS
161 {
162 private:
163 uint8_t var_0_;
164 uint8_t var_1_;
165
166 public:
167 struct Traits;
MiniReflectTypeTable()168 static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
169 {
170 return JustSmallStructTypeTable();
171 }
JustSmallStruct()172 JustSmallStruct() : var_0_(0), var_1_(0) {}
JustSmallStruct(uint8_t _var_0,uint8_t _var_1)173 JustSmallStruct(uint8_t _var_0, uint8_t _var_1)
174 : var_0_(::flatbuffers::EndianScalar(_var_0)), var_1_(::flatbuffers::EndianScalar(_var_1))
175 {}
var_0()176 uint8_t var_0() const
177 {
178 return ::flatbuffers::EndianScalar(var_0_);
179 }
mutate_var_0(uint8_t _var_0)180 void mutate_var_0(uint8_t _var_0)
181 {
182 ::flatbuffers::WriteScalar(&var_0_, _var_0);
183 }
var_1()184 uint8_t var_1() const
185 {
186 return ::flatbuffers::EndianScalar(var_1_);
187 }
mutate_var_1(uint8_t _var_1)188 void mutate_var_1(uint8_t _var_1)
189 {
190 ::flatbuffers::WriteScalar(&var_1_, _var_1);
191 }
192 };
193 FLATBUFFERS_STRUCT_END(JustSmallStruct, 2);
194
195 inline bool operator==(const JustSmallStruct &lhs, const JustSmallStruct &rhs)
196 {
197 return (lhs.var_0() == rhs.var_0()) && (lhs.var_1() == rhs.var_1());
198 }
199
200 inline bool operator!=(const JustSmallStruct &lhs, const JustSmallStruct &rhs)
201 {
202 return !(lhs == rhs);
203 }
204
205 struct JustSmallStruct::Traits
206 {
207 using type = JustSmallStruct;
208 };
209
210 struct OuterLargeT : public ::flatbuffers::NativeTable
211 {
212 typedef OuterLarge TableType;
213 std::unique_ptr<BadAlignmentLarge> large{};
214 OuterLargeT() = default;
215 OuterLargeT(const OuterLargeT &o);
216 OuterLargeT(OuterLargeT &&) FLATBUFFERS_NOEXCEPT = default;
217 OuterLargeT &operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT;
218 };
219
220 struct OuterLarge FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
221 {
222 typedef OuterLargeT NativeTableType;
223 typedef OuterLargeBuilder Builder;
224 struct Traits;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS225 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { return OuterLargeTypeTable(); }
226 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
227 {
228 VT_LARGE = 4
229 };
largeFLATBUFFERS_FINAL_CLASS230 const BadAlignmentLarge *large() const
231 {
232 return GetStruct<const BadAlignmentLarge *>(VT_LARGE);
233 }
mutable_largeFLATBUFFERS_FINAL_CLASS234 BadAlignmentLarge *mutable_large() { return GetStruct<BadAlignmentLarge *>(VT_LARGE); }
VerifyFLATBUFFERS_FINAL_CLASS235 bool Verify(::flatbuffers::Verifier &verifier) const
236 {
237 return VerifyTableStart(verifier) &&
238 VerifyField<BadAlignmentLarge>(verifier, VT_LARGE, 8) && verifier.EndTable();
239 }
240 OuterLargeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
241 void UnPackTo(OuterLargeT *_o,
242 const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
243 static ::flatbuffers::Offset<OuterLarge> Pack(
244 ::flatbuffers::FlatBufferBuilder &_fbb,
245 const OuterLargeT *_o,
246 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
247 };
248
249 struct OuterLargeBuilder
250 {
251 typedef OuterLarge Table;
252 ::flatbuffers::FlatBufferBuilder &fbb_;
253 ::flatbuffers::uoffset_t start_;
add_largeOuterLargeBuilder254 void add_large(const BadAlignmentLarge *large) { fbb_.AddStruct(OuterLarge::VT_LARGE, large); }
OuterLargeBuilderOuterLargeBuilder255 explicit OuterLargeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
256 {
257 start_ = fbb_.StartTable();
258 }
FinishOuterLargeBuilder259 ::flatbuffers::Offset<OuterLarge> Finish()
260 {
261 const auto end = fbb_.EndTable(start_);
262 auto o = ::flatbuffers::Offset<OuterLarge>(end);
263 return o;
264 }
265 };
266
267 inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb,
268 const BadAlignmentLarge *large = nullptr)
269 {
270 OuterLargeBuilder builder_(_fbb);
271 builder_.add_large(large);
272 return builder_.Finish();
273 }
274
275 struct OuterLarge::Traits
276 {
277 using type = OuterLarge;
278 static auto constexpr Create = CreateOuterLarge;
279 };
280
281 ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
282 ::flatbuffers::FlatBufferBuilder &_fbb,
283 const OuterLargeT *_o,
284 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
285
286 struct BadAlignmentRootT : public ::flatbuffers::NativeTable
287 {
288 typedef BadAlignmentRoot TableType;
289 std::unique_ptr<OuterLargeT> large{};
290 std::vector<BadAlignmentSmall> small{};
291 BadAlignmentRootT() = default;
292 BadAlignmentRootT(const BadAlignmentRootT &o);
293 BadAlignmentRootT(BadAlignmentRootT &&) FLATBUFFERS_NOEXCEPT = default;
294 BadAlignmentRootT &operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT;
295 };
296
297 struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
298 {
299 typedef BadAlignmentRootT NativeTableType;
300 typedef BadAlignmentRootBuilder Builder;
301 struct Traits;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS302 static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
303 {
304 return BadAlignmentRootTypeTable();
305 }
306 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
307 {
308 VT_LARGE = 4,
309 VT_SMALL = 6
310 };
largeFLATBUFFERS_FINAL_CLASS311 const OuterLarge *large() const { return GetPointer<const OuterLarge *>(VT_LARGE); }
mutable_largeFLATBUFFERS_FINAL_CLASS312 OuterLarge *mutable_large() { return GetPointer<OuterLarge *>(VT_LARGE); }
smallFLATBUFFERS_FINAL_CLASS313 const ::flatbuffers::Vector<const BadAlignmentSmall *> *small() const
314 {
315 return GetPointer<const ::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
316 }
mutable_smallFLATBUFFERS_FINAL_CLASS317 ::flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small()
318 {
319 return GetPointer<::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
320 }
VerifyFLATBUFFERS_FINAL_CLASS321 bool Verify(::flatbuffers::Verifier &verifier) const
322 {
323 return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_LARGE) &&
324 verifier.VerifyTable(large()) && VerifyOffset(verifier, VT_SMALL) &&
325 verifier.VerifyVector(small()) && verifier.EndTable();
326 }
327 BadAlignmentRootT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
328 void UnPackTo(BadAlignmentRootT *_o,
329 const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
330 static ::flatbuffers::Offset<BadAlignmentRoot> Pack(
331 ::flatbuffers::FlatBufferBuilder &_fbb,
332 const BadAlignmentRootT *_o,
333 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
334 };
335
336 struct BadAlignmentRootBuilder
337 {
338 typedef BadAlignmentRoot Table;
339 ::flatbuffers::FlatBufferBuilder &fbb_;
340 ::flatbuffers::uoffset_t start_;
add_largeBadAlignmentRootBuilder341 void add_large(::flatbuffers::Offset<OuterLarge> large)
342 {
343 fbb_.AddOffset(BadAlignmentRoot::VT_LARGE, large);
344 }
add_smallBadAlignmentRootBuilder345 void add_small(::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small)
346 {
347 fbb_.AddOffset(BadAlignmentRoot::VT_SMALL, small);
348 }
BadAlignmentRootBuilderBadAlignmentRootBuilder349 explicit BadAlignmentRootBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
350 {
351 start_ = fbb_.StartTable();
352 }
FinishBadAlignmentRootBuilder353 ::flatbuffers::Offset<BadAlignmentRoot> Finish()
354 {
355 const auto end = fbb_.EndTable(start_);
356 auto o = ::flatbuffers::Offset<BadAlignmentRoot>(end);
357 return o;
358 }
359 };
360
361 inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
362 ::flatbuffers::FlatBufferBuilder &_fbb,
363 ::flatbuffers::Offset<OuterLarge> large = 0,
364 ::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small = 0)
365 {
366 BadAlignmentRootBuilder builder_(_fbb);
367 builder_.add_small(small);
368 builder_.add_large(large);
369 return builder_.Finish();
370 }
371
372 struct BadAlignmentRoot::Traits
373 {
374 using type = BadAlignmentRoot;
375 static auto constexpr Create = CreateBadAlignmentRoot;
376 };
377
378 inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
379 ::flatbuffers::FlatBufferBuilder &_fbb,
380 ::flatbuffers::Offset<OuterLarge> large = 0,
381 const std::vector<BadAlignmentSmall> *small = nullptr)
382 {
383 auto small__ = small ? _fbb.CreateVectorOfStructs<BadAlignmentSmall>(*small) : 0;
384 return CreateBadAlignmentRoot(_fbb, large, small__);
385 }
386
387 ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
388 ::flatbuffers::FlatBufferBuilder &_fbb,
389 const BadAlignmentRootT *_o,
390 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
391
392 struct SmallStructsT : public ::flatbuffers::NativeTable
393 {
394 typedef SmallStructs TableType;
395 std::vector<JustSmallStruct> small_structs{};
396 };
397
398 struct SmallStructs FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
399 {
400 typedef SmallStructsT NativeTableType;
401 typedef SmallStructsBuilder Builder;
402 struct Traits;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS403 static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
404 {
405 return SmallStructsTypeTable();
406 }
407 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
408 {
409 VT_SMALL_STRUCTS = 4
410 };
small_structsFLATBUFFERS_FINAL_CLASS411 const ::flatbuffers::Vector<const JustSmallStruct *> *small_structs() const
412 {
413 return GetPointer<const ::flatbuffers::Vector<const JustSmallStruct *> *>(VT_SMALL_STRUCTS);
414 }
mutable_small_structsFLATBUFFERS_FINAL_CLASS415 ::flatbuffers::Vector<const JustSmallStruct *> *mutable_small_structs()
416 {
417 return GetPointer<::flatbuffers::Vector<const JustSmallStruct *> *>(VT_SMALL_STRUCTS);
418 }
VerifyFLATBUFFERS_FINAL_CLASS419 bool Verify(::flatbuffers::Verifier &verifier) const
420 {
421 return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SMALL_STRUCTS) &&
422 verifier.VerifyVector(small_structs()) && verifier.EndTable();
423 }
424 SmallStructsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
425 void UnPackTo(SmallStructsT *_o,
426 const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
427 static ::flatbuffers::Offset<SmallStructs> Pack(
428 ::flatbuffers::FlatBufferBuilder &_fbb,
429 const SmallStructsT *_o,
430 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
431 };
432
433 struct SmallStructsBuilder
434 {
435 typedef SmallStructs Table;
436 ::flatbuffers::FlatBufferBuilder &fbb_;
437 ::flatbuffers::uoffset_t start_;
add_small_structsSmallStructsBuilder438 void add_small_structs(
439 ::flatbuffers::Offset<::flatbuffers::Vector<const JustSmallStruct *>> small_structs)
440 {
441 fbb_.AddOffset(SmallStructs::VT_SMALL_STRUCTS, small_structs);
442 }
SmallStructsBuilderSmallStructsBuilder443 explicit SmallStructsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
444 {
445 start_ = fbb_.StartTable();
446 }
FinishSmallStructsBuilder447 ::flatbuffers::Offset<SmallStructs> Finish()
448 {
449 const auto end = fbb_.EndTable(start_);
450 auto o = ::flatbuffers::Offset<SmallStructs>(end);
451 return o;
452 }
453 };
454
455 inline ::flatbuffers::Offset<SmallStructs> CreateSmallStructs(
456 ::flatbuffers::FlatBufferBuilder &_fbb,
457 ::flatbuffers::Offset<::flatbuffers::Vector<const JustSmallStruct *>> small_structs = 0)
458 {
459 SmallStructsBuilder builder_(_fbb);
460 builder_.add_small_structs(small_structs);
461 return builder_.Finish();
462 }
463
464 struct SmallStructs::Traits
465 {
466 using type = SmallStructs;
467 static auto constexpr Create = CreateSmallStructs;
468 };
469
470 inline ::flatbuffers::Offset<SmallStructs> CreateSmallStructsDirect(
471 ::flatbuffers::FlatBufferBuilder &_fbb,
472 const std::vector<JustSmallStruct> *small_structs = nullptr)
473 {
474 auto small_structs__ =
475 small_structs ? _fbb.CreateVectorOfStructs<JustSmallStruct>(*small_structs) : 0;
476 return CreateSmallStructs(_fbb, small_structs__);
477 }
478
479 ::flatbuffers::Offset<SmallStructs> CreateSmallStructs(
480 ::flatbuffers::FlatBufferBuilder &_fbb,
481 const SmallStructsT *_o,
482 const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
483
484 inline bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs)
485 {
486 return ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large));
487 }
488
489 inline bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs)
490 {
491 return !(lhs == rhs);
492 }
493
OuterLargeT(const OuterLargeT & o)494 inline OuterLargeT::OuterLargeT(const OuterLargeT &o)
495 : large((o.large) ? new BadAlignmentLarge(*o.large) : nullptr)
496 {}
497
498 inline OuterLargeT &OuterLargeT::operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT
499 {
500 std::swap(large, o.large);
501 return *this;
502 }
503
UnPack(const::flatbuffers::resolver_function_t * _resolver)504 inline OuterLargeT *OuterLarge::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const
505 {
506 auto _o = std::make_unique<OuterLargeT>();
507 UnPackTo(_o.get(), _resolver);
508 return _o.release();
509 }
510
UnPackTo(OuterLargeT * _o,const::flatbuffers::resolver_function_t * _resolver)511 inline void OuterLarge::UnPackTo(OuterLargeT *_o,
512 const ::flatbuffers::resolver_function_t *_resolver) const
513 {
514 (void)_o;
515 (void)_resolver;
516 {
517 auto _e = large();
518 if (_e)
519 {
520 _o->large = std::unique_ptr<BadAlignmentLarge>(new BadAlignmentLarge(*_e));
521 }
522 }
523 }
524
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const OuterLargeT * _o,const::flatbuffers::rehasher_function_t * _rehasher)525 inline ::flatbuffers::Offset<OuterLarge> OuterLarge::Pack(
526 ::flatbuffers::FlatBufferBuilder &_fbb,
527 const OuterLargeT *_o,
528 const ::flatbuffers::rehasher_function_t *_rehasher)
529 {
530 return CreateOuterLarge(_fbb, _o, _rehasher);
531 }
532
CreateOuterLarge(::flatbuffers::FlatBufferBuilder & _fbb,const OuterLargeT * _o,const::flatbuffers::rehasher_function_t * _rehasher)533 inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
534 ::flatbuffers::FlatBufferBuilder &_fbb,
535 const OuterLargeT *_o,
536 const ::flatbuffers::rehasher_function_t *_rehasher)
537 {
538 (void)_rehasher;
539 (void)_o;
540 struct _VectorArgs
541 {
542 ::flatbuffers::FlatBufferBuilder *__fbb;
543 const OuterLargeT *__o;
544 const ::flatbuffers::rehasher_function_t *__rehasher;
545 } _va = {&_fbb, _o, _rehasher};
546 (void)_va;
547 auto _large = _o->large ? _o->large.get() : nullptr;
548 return CreateOuterLarge(_fbb, _large);
549 }
550
551 inline bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs)
552 {
553 return ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large)) &&
554 (lhs.small == rhs.small);
555 }
556
557 inline bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs)
558 {
559 return !(lhs == rhs);
560 }
561
BadAlignmentRootT(const BadAlignmentRootT & o)562 inline BadAlignmentRootT::BadAlignmentRootT(const BadAlignmentRootT &o)
563 : large((o.large) ? new OuterLargeT(*o.large) : nullptr), small(o.small)
564 {}
565
566 inline BadAlignmentRootT &BadAlignmentRootT::operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT
567 {
568 std::swap(large, o.large);
569 std::swap(small, o.small);
570 return *this;
571 }
572
UnPack(const::flatbuffers::resolver_function_t * _resolver)573 inline BadAlignmentRootT *BadAlignmentRoot::UnPack(
574 const ::flatbuffers::resolver_function_t *_resolver) const
575 {
576 auto _o = std::make_unique<BadAlignmentRootT>();
577 UnPackTo(_o.get(), _resolver);
578 return _o.release();
579 }
580
UnPackTo(BadAlignmentRootT * _o,const::flatbuffers::resolver_function_t * _resolver)581 inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o,
582 const ::flatbuffers::resolver_function_t *_resolver) const
583 {
584 (void)_o;
585 (void)_resolver;
586 {
587 auto _e = large();
588 if (_e)
589 {
590 if (_o->large)
591 {
592 _e->UnPackTo(_o->large.get(), _resolver);
593 }
594 else
595 {
596 _o->large = std::unique_ptr<OuterLargeT>(_e->UnPack(_resolver));
597 }
598 }
599 else if (_o->large)
600 {
601 _o->large.reset();
602 }
603 }
604 {
605 auto _e = small();
606 if (_e)
607 {
608 _o->small.resize(_e->size());
609 for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
610 {
611 _o->small[_i] = *_e->Get(_i);
612 }
613 }
614 else
615 {
616 _o->small.resize(0);
617 }
618 }
619 }
620
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const BadAlignmentRootT * _o,const::flatbuffers::rehasher_function_t * _rehasher)621 inline ::flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(
622 ::flatbuffers::FlatBufferBuilder &_fbb,
623 const BadAlignmentRootT *_o,
624 const ::flatbuffers::rehasher_function_t *_rehasher)
625 {
626 return CreateBadAlignmentRoot(_fbb, _o, _rehasher);
627 }
628
CreateBadAlignmentRoot(::flatbuffers::FlatBufferBuilder & _fbb,const BadAlignmentRootT * _o,const::flatbuffers::rehasher_function_t * _rehasher)629 inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
630 ::flatbuffers::FlatBufferBuilder &_fbb,
631 const BadAlignmentRootT *_o,
632 const ::flatbuffers::rehasher_function_t *_rehasher)
633 {
634 (void)_rehasher;
635 (void)_o;
636 struct _VectorArgs
637 {
638 ::flatbuffers::FlatBufferBuilder *__fbb;
639 const BadAlignmentRootT *__o;
640 const ::flatbuffers::rehasher_function_t *__rehasher;
641 } _va = {&_fbb, _o, _rehasher};
642 (void)_va;
643 auto _large = _o->large ? CreateOuterLarge(_fbb, _o->large.get(), _rehasher) : 0;
644 auto _small = _o->small.size() ? _fbb.CreateVectorOfStructs(_o->small) : 0;
645 return CreateBadAlignmentRoot(_fbb, _large, _small);
646 }
647
648 inline bool operator==(const SmallStructsT &lhs, const SmallStructsT &rhs)
649 {
650 return (lhs.small_structs == rhs.small_structs);
651 }
652
653 inline bool operator!=(const SmallStructsT &lhs, const SmallStructsT &rhs)
654 {
655 return !(lhs == rhs);
656 }
657
UnPack(const::flatbuffers::resolver_function_t * _resolver)658 inline SmallStructsT *SmallStructs::UnPack(
659 const ::flatbuffers::resolver_function_t *_resolver) const
660 {
661 auto _o = std::make_unique<SmallStructsT>();
662 UnPackTo(_o.get(), _resolver);
663 return _o.release();
664 }
665
UnPackTo(SmallStructsT * _o,const::flatbuffers::resolver_function_t * _resolver)666 inline void SmallStructs::UnPackTo(SmallStructsT *_o,
667 const ::flatbuffers::resolver_function_t *_resolver) const
668 {
669 (void)_o;
670 (void)_resolver;
671 {
672 auto _e = small_structs();
673 if (_e)
674 {
675 _o->small_structs.resize(_e->size());
676 for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
677 {
678 _o->small_structs[_i] = *_e->Get(_i);
679 }
680 }
681 else
682 {
683 _o->small_structs.resize(0);
684 }
685 }
686 }
687
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const SmallStructsT * _o,const::flatbuffers::rehasher_function_t * _rehasher)688 inline ::flatbuffers::Offset<SmallStructs> SmallStructs::Pack(
689 ::flatbuffers::FlatBufferBuilder &_fbb,
690 const SmallStructsT *_o,
691 const ::flatbuffers::rehasher_function_t *_rehasher)
692 {
693 return CreateSmallStructs(_fbb, _o, _rehasher);
694 }
695
CreateSmallStructs(::flatbuffers::FlatBufferBuilder & _fbb,const SmallStructsT * _o,const::flatbuffers::rehasher_function_t * _rehasher)696 inline ::flatbuffers::Offset<SmallStructs> CreateSmallStructs(
697 ::flatbuffers::FlatBufferBuilder &_fbb,
698 const SmallStructsT *_o,
699 const ::flatbuffers::rehasher_function_t *_rehasher)
700 {
701 (void)_rehasher;
702 (void)_o;
703 struct _VectorArgs
704 {
705 ::flatbuffers::FlatBufferBuilder *__fbb;
706 const SmallStructsT *__o;
707 const ::flatbuffers::rehasher_function_t *__rehasher;
708 } _va = {&_fbb, _o, _rehasher};
709 (void)_va;
710 auto _small_structs =
711 _o->small_structs.size() ? _fbb.CreateVectorOfStructs(_o->small_structs) : 0;
712 return CreateSmallStructs(_fbb, _small_structs);
713 }
714
BadAlignmentSmallTypeTable()715 inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable()
716 {
717 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_UINT, 0, -1},
718 {::flatbuffers::ET_UINT, 0, -1},
719 {::flatbuffers::ET_UINT, 0, -1}};
720 static const int64_t values[] = {0, 4, 8, 12};
721 static const char *const names[] = {"var_0", "var_1", "var_2"};
722 static const ::flatbuffers::TypeTable tt = {
723 ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names};
724 return &tt;
725 }
726
BadAlignmentLargeTypeTable()727 inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable()
728 {
729 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_ULONG, 0, -1}};
730 static const int64_t values[] = {0, 8};
731 static const char *const names[] = {"var_0"};
732 static const ::flatbuffers::TypeTable tt = {
733 ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names};
734 return &tt;
735 }
736
OuterLargeTypeTable()737 inline const ::flatbuffers::TypeTable *OuterLargeTypeTable()
738 {
739 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_SEQUENCE, 0, 0}};
740 static const ::flatbuffers::TypeFunction type_refs[] = {BadAlignmentLargeTypeTable};
741 static const char *const names[] = {"large"};
742 static const ::flatbuffers::TypeTable tt = {
743 ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names};
744 return &tt;
745 }
746
BadAlignmentRootTypeTable()747 inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable()
748 {
749 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_SEQUENCE, 0, 0},
750 {::flatbuffers::ET_SEQUENCE, 1, 1}};
751 static const ::flatbuffers::TypeFunction type_refs[] = {OuterLargeTypeTable,
752 BadAlignmentSmallTypeTable};
753 static const char *const names[] = {"large", "small"};
754 static const ::flatbuffers::TypeTable tt = {
755 ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names};
756 return &tt;
757 }
758
JustSmallStructTypeTable()759 inline const ::flatbuffers::TypeTable *JustSmallStructTypeTable()
760 {
761 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_UCHAR, 0, -1},
762 {::flatbuffers::ET_UCHAR, 0, -1}};
763 static const int64_t values[] = {0, 1, 2};
764 static const char *const names[] = {"var_0", "var_1"};
765 static const ::flatbuffers::TypeTable tt = {
766 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names};
767 return &tt;
768 }
769
SmallStructsTypeTable()770 inline const ::flatbuffers::TypeTable *SmallStructsTypeTable()
771 {
772 static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_SEQUENCE, 1, 0}};
773 static const ::flatbuffers::TypeFunction type_refs[] = {JustSmallStructTypeTable};
774 static const char *const names[] = {"small_structs"};
775 static const ::flatbuffers::TypeTable tt = {
776 ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names};
777 return &tt;
778 }
779
GetSmallStructs(const void * buf)780 inline const SmallStructs *GetSmallStructs(const void *buf)
781 {
782 return ::flatbuffers::GetRoot<SmallStructs>(buf);
783 }
784
GetSizePrefixedSmallStructs(const void * buf)785 inline const SmallStructs *GetSizePrefixedSmallStructs(const void *buf)
786 {
787 return ::flatbuffers::GetSizePrefixedRoot<SmallStructs>(buf);
788 }
789
GetMutableSmallStructs(void * buf)790 inline SmallStructs *GetMutableSmallStructs(void *buf)
791 {
792 return ::flatbuffers::GetMutableRoot<SmallStructs>(buf);
793 }
794
GetMutableSizePrefixedSmallStructs(void * buf)795 inline SmallStructs *GetMutableSizePrefixedSmallStructs(void *buf)
796 {
797 return ::flatbuffers::GetMutableSizePrefixedRoot<SmallStructs>(buf);
798 }
799
VerifySmallStructsBuffer(::flatbuffers::Verifier & verifier)800 inline bool VerifySmallStructsBuffer(::flatbuffers::Verifier &verifier)
801 {
802 return verifier.VerifyBuffer<SmallStructs>(nullptr);
803 }
804
VerifySizePrefixedSmallStructsBuffer(::flatbuffers::Verifier & verifier)805 inline bool VerifySizePrefixedSmallStructsBuffer(::flatbuffers::Verifier &verifier)
806 {
807 return verifier.VerifySizePrefixedBuffer<SmallStructs>(nullptr);
808 }
809
FinishSmallStructsBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<SmallStructs> root)810 inline void FinishSmallStructsBuffer(::flatbuffers::FlatBufferBuilder &fbb,
811 ::flatbuffers::Offset<SmallStructs> root)
812 {
813 fbb.Finish(root);
814 }
815
FinishSizePrefixedSmallStructsBuffer(::flatbuffers::FlatBufferBuilder & fbb,::flatbuffers::Offset<SmallStructs> root)816 inline void FinishSizePrefixedSmallStructsBuffer(::flatbuffers::FlatBufferBuilder &fbb,
817 ::flatbuffers::Offset<SmallStructs> root)
818 {
819 fbb.FinishSizePrefixed(root);
820 }
821
822 inline std::unique_ptr<SmallStructsT> UnPackSmallStructs(
823 const void *buf,
824 const ::flatbuffers::resolver_function_t *res = nullptr)
825 {
826 return std::unique_ptr<SmallStructsT>(GetSmallStructs(buf)->UnPack(res));
827 }
828
829 inline std::unique_ptr<SmallStructsT> UnPackSizePrefixedSmallStructs(
830 const void *buf,
831 const ::flatbuffers::resolver_function_t *res = nullptr)
832 {
833 return std::unique_ptr<SmallStructsT>(GetSizePrefixedSmallStructs(buf)->UnPack(res));
834 }
835
836 #endif // FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
837