"Fossies" - the Fresh Open Source Software Archive 
Member "flatbuffers-23.1.21/tests/alignment_test_generated.h" (21 Jan 2023, 17996 Bytes) of package /linux/misc/flatbuffers-23.1.21.tar.gz:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
See also the latest
Fossies "Diffs" side-by-side code changes report for "alignment_test_generated.h":
23.1.20_vs_23.1.21.
1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
5 #define FLATBUFFERS_GENERATED_ALIGNMENTTEST_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 == 23 &&
12 FLATBUFFERS_VERSION_MINOR == 1 &&
13 FLATBUFFERS_VERSION_REVISION == 21,
14 "Non-compatible flatbuffers version included");
15
16 struct BadAlignmentSmall;
17
18 struct BadAlignmentLarge;
19
20 struct OuterLarge;
21 struct OuterLargeBuilder;
22 struct OuterLargeT;
23
24 struct BadAlignmentRoot;
25 struct BadAlignmentRootBuilder;
26 struct BadAlignmentRootT;
27
28 bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs);
29 bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs);
30 bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs);
31 bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs);
32 bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs);
33 bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs);
34 bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
35 bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
36
37 inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable();
38
39 inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable();
40
41 inline const ::flatbuffers::TypeTable *OuterLargeTypeTable();
42
43 inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable();
44
45 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS {
46 private:
47 uint32_t var_0_;
48 uint32_t var_1_;
49 uint32_t var_2_;
50
51 public:
52 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
53 return BadAlignmentSmallTypeTable();
54 }
55 BadAlignmentSmall()
56 : var_0_(0),
57 var_1_(0),
58 var_2_(0) {
59 }
60 BadAlignmentSmall(uint32_t _var_0, uint32_t _var_1, uint32_t _var_2)
61 : var_0_(::flatbuffers::EndianScalar(_var_0)),
62 var_1_(::flatbuffers::EndianScalar(_var_1)),
63 var_2_(::flatbuffers::EndianScalar(_var_2)) {
64 }
65 uint32_t var_0() const {
66 return ::flatbuffers::EndianScalar(var_0_);
67 }
68 void mutate_var_0(uint32_t _var_0) {
69 ::flatbuffers::WriteScalar(&var_0_, _var_0);
70 }
71 uint32_t var_1() const {
72 return ::flatbuffers::EndianScalar(var_1_);
73 }
74 void mutate_var_1(uint32_t _var_1) {
75 ::flatbuffers::WriteScalar(&var_1_, _var_1);
76 }
77 uint32_t var_2() const {
78 return ::flatbuffers::EndianScalar(var_2_);
79 }
80 void mutate_var_2(uint32_t _var_2) {
81 ::flatbuffers::WriteScalar(&var_2_, _var_2);
82 }
83 };
84 FLATBUFFERS_STRUCT_END(BadAlignmentSmall, 12);
85
86 inline bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs) {
87 return
88 (lhs.var_0() == rhs.var_0()) &&
89 (lhs.var_1() == rhs.var_1()) &&
90 (lhs.var_2() == rhs.var_2());
91 }
92
93 inline bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs) {
94 return !(lhs == rhs);
95 }
96
97
98 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) BadAlignmentLarge FLATBUFFERS_FINAL_CLASS {
99 private:
100 uint64_t var_0_;
101
102 public:
103 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
104 return BadAlignmentLargeTypeTable();
105 }
106 BadAlignmentLarge()
107 : var_0_(0) {
108 }
109 BadAlignmentLarge(uint64_t _var_0)
110 : var_0_(::flatbuffers::EndianScalar(_var_0)) {
111 }
112 uint64_t var_0() const {
113 return ::flatbuffers::EndianScalar(var_0_);
114 }
115 void mutate_var_0(uint64_t _var_0) {
116 ::flatbuffers::WriteScalar(&var_0_, _var_0);
117 }
118 };
119 FLATBUFFERS_STRUCT_END(BadAlignmentLarge, 8);
120
121 inline bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs) {
122 return
123 (lhs.var_0() == rhs.var_0());
124 }
125
126 inline bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs) {
127 return !(lhs == rhs);
128 }
129
130
131 struct OuterLargeT : public ::flatbuffers::NativeTable {
132 typedef OuterLarge TableType;
133 flatbuffers::unique_ptr<BadAlignmentLarge> large{};
134 OuterLargeT() = default;
135 OuterLargeT(const OuterLargeT &o);
136 OuterLargeT(OuterLargeT&&) FLATBUFFERS_NOEXCEPT = default;
137 OuterLargeT &operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT;
138 };
139
140 struct OuterLarge FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
141 typedef OuterLargeT NativeTableType;
142 typedef OuterLargeBuilder Builder;
143 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
144 return OuterLargeTypeTable();
145 }
146 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
147 VT_LARGE = 4
148 };
149 const BadAlignmentLarge *large() const {
150 return GetStruct<const BadAlignmentLarge *>(VT_LARGE);
151 }
152 BadAlignmentLarge *mutable_large() {
153 return GetStruct<BadAlignmentLarge *>(VT_LARGE);
154 }
155 bool Verify(::flatbuffers::Verifier &verifier) const {
156 return VerifyTableStart(verifier) &&
157 VerifyField<BadAlignmentLarge>(verifier, VT_LARGE, 8) &&
158 verifier.EndTable();
159 }
160 OuterLargeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
161 void UnPackTo(OuterLargeT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
162 static ::flatbuffers::Offset<OuterLarge> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
163 };
164
165 struct OuterLargeBuilder {
166 typedef OuterLarge Table;
167 ::flatbuffers::FlatBufferBuilder &fbb_;
168 ::flatbuffers::uoffset_t start_;
169 void add_large(const BadAlignmentLarge *large) {
170 fbb_.AddStruct(OuterLarge::VT_LARGE, large);
171 }
172 explicit OuterLargeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
173 : fbb_(_fbb) {
174 start_ = fbb_.StartTable();
175 }
176 ::flatbuffers::Offset<OuterLarge> Finish() {
177 const auto end = fbb_.EndTable(start_);
178 auto o = ::flatbuffers::Offset<OuterLarge>(end);
179 return o;
180 }
181 };
182
183 inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
184 ::flatbuffers::FlatBufferBuilder &_fbb,
185 const BadAlignmentLarge *large = nullptr) {
186 OuterLargeBuilder builder_(_fbb);
187 builder_.add_large(large);
188 return builder_.Finish();
189 }
190
191 ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
192
193 struct BadAlignmentRootT : public ::flatbuffers::NativeTable {
194 typedef BadAlignmentRoot TableType;
195 flatbuffers::unique_ptr<OuterLargeT> large{};
196 std::vector<BadAlignmentSmall> small{};
197 BadAlignmentRootT() = default;
198 BadAlignmentRootT(const BadAlignmentRootT &o);
199 BadAlignmentRootT(BadAlignmentRootT&&) FLATBUFFERS_NOEXCEPT = default;
200 BadAlignmentRootT &operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT;
201 };
202
203 struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
204 typedef BadAlignmentRootT NativeTableType;
205 typedef BadAlignmentRootBuilder Builder;
206 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
207 return BadAlignmentRootTypeTable();
208 }
209 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
210 VT_LARGE = 4,
211 VT_SMALL = 6
212 };
213 const OuterLarge *large() const {
214 return GetPointer<const OuterLarge *>(VT_LARGE);
215 }
216 OuterLarge *mutable_large() {
217 return GetPointer<OuterLarge *>(VT_LARGE);
218 }
219 const ::flatbuffers::Vector<const BadAlignmentSmall *> *small() const {
220 return GetPointer<const ::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
221 }
222 ::flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small() {
223 return GetPointer<::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
224 }
225 bool Verify(::flatbuffers::Verifier &verifier) const {
226 return VerifyTableStart(verifier) &&
227 VerifyOffset(verifier, VT_LARGE) &&
228 verifier.VerifyTable(large()) &&
229 VerifyOffset(verifier, VT_SMALL) &&
230 verifier.VerifyVector(small()) &&
231 verifier.EndTable();
232 }
233 BadAlignmentRootT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
234 void UnPackTo(BadAlignmentRootT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
235 static ::flatbuffers::Offset<BadAlignmentRoot> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
236 };
237
238 struct BadAlignmentRootBuilder {
239 typedef BadAlignmentRoot Table;
240 ::flatbuffers::FlatBufferBuilder &fbb_;
241 ::flatbuffers::uoffset_t start_;
242 void add_large(::flatbuffers::Offset<OuterLarge> large) {
243 fbb_.AddOffset(BadAlignmentRoot::VT_LARGE, large);
244 }
245 void add_small(::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small) {
246 fbb_.AddOffset(BadAlignmentRoot::VT_SMALL, small);
247 }
248 explicit BadAlignmentRootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
249 : fbb_(_fbb) {
250 start_ = fbb_.StartTable();
251 }
252 ::flatbuffers::Offset<BadAlignmentRoot> Finish() {
253 const auto end = fbb_.EndTable(start_);
254 auto o = ::flatbuffers::Offset<BadAlignmentRoot>(end);
255 return o;
256 }
257 };
258
259 inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
260 ::flatbuffers::FlatBufferBuilder &_fbb,
261 ::flatbuffers::Offset<OuterLarge> large = 0,
262 ::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small = 0) {
263 BadAlignmentRootBuilder builder_(_fbb);
264 builder_.add_small(small);
265 builder_.add_large(large);
266 return builder_.Finish();
267 }
268
269 inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
270 ::flatbuffers::FlatBufferBuilder &_fbb,
271 ::flatbuffers::Offset<OuterLarge> large = 0,
272 const std::vector<BadAlignmentSmall> *small = nullptr) {
273 auto small__ = small ? _fbb.CreateVectorOfStructs<BadAlignmentSmall>(*small) : 0;
274 return CreateBadAlignmentRoot(
275 _fbb,
276 large,
277 small__);
278 }
279
280 ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
281
282
283 inline bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs) {
284 return
285 ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large));
286 }
287
288 inline bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs) {
289 return !(lhs == rhs);
290 }
291
292
293 inline OuterLargeT::OuterLargeT(const OuterLargeT &o)
294 : large((o.large) ? new BadAlignmentLarge(*o.large) : nullptr) {
295 }
296
297 inline OuterLargeT &OuterLargeT::operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT {
298 std::swap(large, o.large);
299 return *this;
300 }
301
302 inline OuterLargeT *OuterLarge::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
303 auto _o = std::unique_ptr<OuterLargeT>(new OuterLargeT());
304 UnPackTo(_o.get(), _resolver);
305 return _o.release();
306 }
307
308 inline void OuterLarge::UnPackTo(OuterLargeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
309 (void)_o;
310 (void)_resolver;
311 { auto _e = large(); if (_e) _o->large = flatbuffers::unique_ptr<BadAlignmentLarge>(new BadAlignmentLarge(*_e)); }
312 }
313
314 inline ::flatbuffers::Offset<OuterLarge> OuterLarge::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
315 return CreateOuterLarge(_fbb, _o, _rehasher);
316 }
317
318 inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
319 (void)_rehasher;
320 (void)_o;
321 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const OuterLargeT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
322 auto _large = _o->large ? _o->large.get() : nullptr;
323 return CreateOuterLarge(
324 _fbb,
325 _large);
326 }
327
328
329 inline bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs) {
330 return
331 ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large)) &&
332 (lhs.small == rhs.small);
333 }
334
335 inline bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs) {
336 return !(lhs == rhs);
337 }
338
339
340 inline BadAlignmentRootT::BadAlignmentRootT(const BadAlignmentRootT &o)
341 : large((o.large) ? new OuterLargeT(*o.large) : nullptr),
342 small(o.small) {
343 }
344
345 inline BadAlignmentRootT &BadAlignmentRootT::operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT {
346 std::swap(large, o.large);
347 std::swap(small, o.small);
348 return *this;
349 }
350
351 inline BadAlignmentRootT *BadAlignmentRoot::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
352 auto _o = std::unique_ptr<BadAlignmentRootT>(new BadAlignmentRootT());
353 UnPackTo(_o.get(), _resolver);
354 return _o.release();
355 }
356
357 inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
358 (void)_o;
359 (void)_resolver;
360 { auto _e = large(); if (_e) { if(_o->large) { _e->UnPackTo(_o->large.get(), _resolver); } else { _o->large = flatbuffers::unique_ptr<OuterLargeT>(_e->UnPack(_resolver)); } } else if (_o->large) { _o->large.reset(); } }
361 { auto _e = small(); if (_e) { _o->small.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->small[_i] = *_e->Get(_i); } } else { _o->small.resize(0); } }
362 }
363
364 inline ::flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
365 return CreateBadAlignmentRoot(_fbb, _o, _rehasher);
366 }
367
368 inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
369 (void)_rehasher;
370 (void)_o;
371 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BadAlignmentRootT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
372 auto _large = _o->large ? CreateOuterLarge(_fbb, _o->large.get(), _rehasher) : 0;
373 auto _small = _o->small.size() ? _fbb.CreateVectorOfStructs(_o->small) : 0;
374 return CreateBadAlignmentRoot(
375 _fbb,
376 _large,
377 _small);
378 }
379
380 inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable() {
381 static const ::flatbuffers::TypeCode type_codes[] = {
382 { ::flatbuffers::ET_UINT, 0, -1 },
383 { ::flatbuffers::ET_UINT, 0, -1 },
384 { ::flatbuffers::ET_UINT, 0, -1 }
385 };
386 static const int64_t values[] = { 0, 4, 8, 12 };
387 static const char * const names[] = {
388 "var_0",
389 "var_1",
390 "var_2"
391 };
392 static const ::flatbuffers::TypeTable tt = {
393 ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
394 };
395 return &tt;
396 }
397
398 inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable() {
399 static const ::flatbuffers::TypeCode type_codes[] = {
400 { ::flatbuffers::ET_ULONG, 0, -1 }
401 };
402 static const int64_t values[] = { 0, 8 };
403 static const char * const names[] = {
404 "var_0"
405 };
406 static const ::flatbuffers::TypeTable tt = {
407 ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
408 };
409 return &tt;
410 }
411
412 inline const ::flatbuffers::TypeTable *OuterLargeTypeTable() {
413 static const ::flatbuffers::TypeCode type_codes[] = {
414 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
415 };
416 static const ::flatbuffers::TypeFunction type_refs[] = {
417 BadAlignmentLargeTypeTable
418 };
419 static const char * const names[] = {
420 "large"
421 };
422 static const ::flatbuffers::TypeTable tt = {
423 ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
424 };
425 return &tt;
426 }
427
428 inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable() {
429 static const ::flatbuffers::TypeCode type_codes[] = {
430 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
431 { ::flatbuffers::ET_SEQUENCE, 1, 1 }
432 };
433 static const ::flatbuffers::TypeFunction type_refs[] = {
434 OuterLargeTypeTable,
435 BadAlignmentSmallTypeTable
436 };
437 static const char * const names[] = {
438 "large",
439 "small"
440 };
441 static const ::flatbuffers::TypeTable tt = {
442 ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
443 };
444 return &tt;
445 }
446
447 inline const BadAlignmentRoot *GetBadAlignmentRoot(const void *buf) {
448 return ::flatbuffers::GetRoot<BadAlignmentRoot>(buf);
449 }
450
451 inline const BadAlignmentRoot *GetSizePrefixedBadAlignmentRoot(const void *buf) {
452 return ::flatbuffers::GetSizePrefixedRoot<BadAlignmentRoot>(buf);
453 }
454
455 inline BadAlignmentRoot *GetMutableBadAlignmentRoot(void *buf) {
456 return ::flatbuffers::GetMutableRoot<BadAlignmentRoot>(buf);
457 }
458
459 inline BadAlignmentRoot *GetMutableSizePrefixedBadAlignmentRoot(void *buf) {
460 return ::flatbuffers::GetMutableSizePrefixedRoot<BadAlignmentRoot>(buf);
461 }
462
463 inline bool VerifyBadAlignmentRootBuffer(
464 ::flatbuffers::Verifier &verifier) {
465 return verifier.VerifyBuffer<BadAlignmentRoot>(nullptr);
466 }
467
468 inline bool VerifySizePrefixedBadAlignmentRootBuffer(
469 ::flatbuffers::Verifier &verifier) {
470 return verifier.VerifySizePrefixedBuffer<BadAlignmentRoot>(nullptr);
471 }
472
473 inline void FinishBadAlignmentRootBuffer(
474 ::flatbuffers::FlatBufferBuilder &fbb,
475 ::flatbuffers::Offset<BadAlignmentRoot> root) {
476 fbb.Finish(root);
477 }
478
479 inline void FinishSizePrefixedBadAlignmentRootBuffer(
480 ::flatbuffers::FlatBufferBuilder &fbb,
481 ::flatbuffers::Offset<BadAlignmentRoot> root) {
482 fbb.FinishSizePrefixed(root);
483 }
484
485 inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackBadAlignmentRoot(
486 const void *buf,
487 const ::flatbuffers::resolver_function_t *res = nullptr) {
488 return flatbuffers::unique_ptr<BadAlignmentRootT>(GetBadAlignmentRoot(buf)->UnPack(res));
489 }
490
491 inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackSizePrefixedBadAlignmentRoot(
492 const void *buf,
493 const ::flatbuffers::resolver_function_t *res = nullptr) {
494 return flatbuffers::unique_ptr<BadAlignmentRootT>(GetSizePrefixedBadAlignmentRoot(buf)->UnPack(res));
495 }
496
497 #endif // FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_