"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_