kc3-lang/angle/third_party/flatbuffers/generated/tests/alignment_test_generated.h

• Show log

  Commit

• Hash : bcfc214f
  Author :
  Date : 2023-06-27T09:49:12
  

  Roll Chromium from 14fa1a826dad to 2e0371f07e01 (1224 revisions)
  
  Manually update third_party/flatbuffers
  
  https://chromium.googlesource.com/chromium/src.git/+log/14fa1a826dad..2e0371f07e01
  
  If this roll has caused a breakage, revert this CL and stop the roller
  using the controls here:
  https://autoroll.skia.org/r/chromium-angle-autoroll
  Please CC angle-team@google.com,solti@google.com on the revert to ensure
  that a human
  is aware of the problem.
  
  To file a bug in Chromium:
  https://bugs.chromium.org/p/chromium/issues/entry
  To file a bug in ANGLE:
  https://bugs.chromium.org/p/angleproject/issues/entry
  
  To report a problem with the AutoRoller itself, please file a bug:
  https://bugs.chromium.org/p/skia/issues/entry?template=Autoroller+Bug
  
  Documentation for the AutoRoller is here:
  https://skia.googlesource.com/buildbot/+doc/main/autoroll/README.md
  
  Changed dependencies
  * build: https://chromium.googlesource.com/chromium/src/build.git/+log/4438010153..e4262406c0
  * buildtools: https://chromium.googlesource.com/chromium/src/buildtools.git/+log/ad9b993f2f..f089c59d7c
  * buildtools/third_party/libc++/trunk: https://chromium.googlesource.com/external/github.com/llvm/llvm-project/libcxx.git/+log/745104ff4a..b272a1c128
  * testing: https://chromium.googlesource.com/chromium/src/testing/+log/75c78f8f64..46c0754180
  * third_party/abseil-cpp: https://chromium.googlesource.com/chromium/src/third_party/abseil-cpp/+log/8f8f07bdce..66a5ea107e
  * third_party/android_build_tools: https://chromium.googlesource.com/chromium/src/third_party/android_build_tools/+log/3b0115d9f8..4cb10f1315
  * third_party/catapult: https://chromium.googlesource.com/catapult.git/+log/{catapult_..1a0894f20f
  * third_party/depot_tools: https://chromium.googlesource.com/chromium/tools/depot_tools.git/+log/98d3bb27f0..f0fba1d307
  * third_party/flatbuffers/src: https://chromium.googlesource.com/external/github.com/google/flatbuffers.git/+log/13fc75cb6b..28861d1d7d
  * third_party/fuchsia-sdk/sdk: version:13.20230622.3.1..version:13.20230626.3.1
  * tools/android: https://chromium.googlesource.com/chromium/src/tools/android/+log/9b4ea9e0d4..5c2008090e
  * tools/clang: https://chromium.googlesource.com/chromium/src/tools/clang.git/+log/ff9b9e9ce2..053092c268
  * tools/perf: https://chromium.googlesource.com/chromium/src/tools/perf/+log/31a576a999..daed2f7981
  No update to Clang.
  
  Bug: None
  Tbr: solti@google.com
  Change-Id: I7bf9a5c427845ac28e9cc70051c9b07381313cc9
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4649047
  Reviewed-by: Solti Ho <solti@google.com>
  Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
  

Download

• third_party/flatbuffers/generated/tests/alignment_test_generated.h

• // automatically generated by the FlatBuffers compiler, do not modify
  
  #ifndef FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
  #define FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
  
  #include "flatbuffers/flatbuffers.h"
  
  // Ensure the included flatbuffers.h is the same version as when this file was
  // generated, otherwise it may not be compatible.
  static_assert(FLATBUFFERS_VERSION_MAJOR == 23 && FLATBUFFERS_VERSION_MINOR == 5 &&
                    FLATBUFFERS_VERSION_REVISION == 26,
                "Non-compatible flatbuffers version included");
  
  struct BadAlignmentSmall;
  
  struct BadAlignmentLarge;
  
  struct OuterLarge;
  struct OuterLargeBuilder;
  struct OuterLargeT;
  
  struct BadAlignmentRoot;
  struct BadAlignmentRootBuilder;
  struct BadAlignmentRootT;
  
  bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs);
  bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs);
  bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs);
  bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs);
  bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs);
  bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs);
  bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
  bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
  
  inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable();
  
  inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable();
  
  inline const ::flatbuffers::TypeTable *OuterLargeTypeTable();
  
  inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable();
  
  FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1)
  BadAlignmentSmall FLATBUFFERS_FINAL_CLASS
  {
    private:
      uint8_t var_0_;
      uint8_t var_1_;
  
    public:
      struct Traits;
      static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
      {
          return BadAlignmentSmallTypeTable();
      }
      BadAlignmentSmall() : var_0_(0), var_1_(0) {}
      BadAlignmentSmall(uint8_t _var_0, uint8_t _var_1)
          : var_0_(::flatbuffers::EndianScalar(_var_0)), var_1_(::flatbuffers::EndianScalar(_var_1))
      {}
      uint8_t var_0() const
      {
          return ::flatbuffers::EndianScalar(var_0_);
      }
      void mutate_var_0(uint8_t _var_0)
      {
          ::flatbuffers::WriteScalar(&var_0_, _var_0);
      }
      uint8_t var_1() const
      {
          return ::flatbuffers::EndianScalar(var_1_);
      }
      void mutate_var_1(uint8_t _var_1)
      {
          ::flatbuffers::WriteScalar(&var_1_, _var_1);
      }
  };
  FLATBUFFERS_STRUCT_END(BadAlignmentSmall, 2);
  
  inline bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs)
  {
      return (lhs.var_0() == rhs.var_0()) && (lhs.var_1() == rhs.var_1());
  }
  
  inline bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs)
  {
      return !(lhs == rhs);
  }
  
  struct BadAlignmentSmall::Traits
  {
      using type = BadAlignmentSmall;
  };
  
  FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8)
  BadAlignmentLarge FLATBUFFERS_FINAL_CLASS
  {
    private:
      uint64_t var_0_;
  
    public:
      struct Traits;
      static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
      {
          return BadAlignmentLargeTypeTable();
      }
      BadAlignmentLarge() : var_0_(0) {}
      BadAlignmentLarge(uint64_t _var_0) : var_0_(::flatbuffers::EndianScalar(_var_0)) {}
      uint64_t var_0() const
      {
          return ::flatbuffers::EndianScalar(var_0_);
      }
      void mutate_var_0(uint64_t _var_0)
      {
          ::flatbuffers::WriteScalar(&var_0_, _var_0);
      }
  };
  FLATBUFFERS_STRUCT_END(BadAlignmentLarge, 8);
  
  inline bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs)
  {
      return (lhs.var_0() == rhs.var_0());
  }
  
  inline bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs)
  {
      return !(lhs == rhs);
  }
  
  struct BadAlignmentLarge::Traits
  {
      using type = BadAlignmentLarge;
  };
  
  struct OuterLargeT : public ::flatbuffers::NativeTable
  {
      typedef OuterLarge TableType;
      std::unique_ptr<BadAlignmentLarge> large{};
      OuterLargeT() = default;
      OuterLargeT(const OuterLargeT &o);
      OuterLargeT(OuterLargeT &&) FLATBUFFERS_NOEXCEPT = default;
      OuterLargeT &operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT;
  };
  
  struct OuterLarge FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
  {
      typedef OuterLargeT NativeTableType;
      typedef OuterLargeBuilder Builder;
      struct Traits;
      static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { return OuterLargeTypeTable(); }
      enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
      {
          VT_LARGE = 4
      };
      const BadAlignmentLarge *large() const
      {
          return GetStruct<const BadAlignmentLarge *>(VT_LARGE);
      }
      BadAlignmentLarge *mutable_large() { return GetStruct<BadAlignmentLarge *>(VT_LARGE); }
      bool Verify(::flatbuffers::Verifier &verifier) const
      {
          return VerifyTableStart(verifier) &&
                 VerifyField<BadAlignmentLarge>(verifier, VT_LARGE, 8) && verifier.EndTable();
      }
      OuterLargeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
      void UnPackTo(OuterLargeT *_o,
                    const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
      static ::flatbuffers::Offset<OuterLarge> Pack(
          ::flatbuffers::FlatBufferBuilder &_fbb,
          const OuterLargeT *_o,
          const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
  };
  
  struct OuterLargeBuilder
  {
      typedef OuterLarge Table;
      ::flatbuffers::FlatBufferBuilder &fbb_;
      ::flatbuffers::uoffset_t start_;
      void add_large(const BadAlignmentLarge *large) { fbb_.AddStruct(OuterLarge::VT_LARGE, large); }
      explicit OuterLargeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
      {
          start_ = fbb_.StartTable();
      }
      ::flatbuffers::Offset<OuterLarge> Finish()
      {
          const auto end = fbb_.EndTable(start_);
          auto o         = ::flatbuffers::Offset<OuterLarge>(end);
          return o;
      }
  };
  
  inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb,
                                                            const BadAlignmentLarge *large = nullptr)
  {
      OuterLargeBuilder builder_(_fbb);
      builder_.add_large(large);
      return builder_.Finish();
  }
  
  struct OuterLarge::Traits
  {
      using type                   = OuterLarge;
      static auto constexpr Create = CreateOuterLarge;
  };
  
  ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      const OuterLargeT *_o,
      const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
  
  struct BadAlignmentRootT : public ::flatbuffers::NativeTable
  {
      typedef BadAlignmentRoot TableType;
      std::unique_ptr<OuterLargeT> large{};
      std::vector<BadAlignmentSmall> small{};
      BadAlignmentRootT() = default;
      BadAlignmentRootT(const BadAlignmentRootT &o);
      BadAlignmentRootT(BadAlignmentRootT &&) FLATBUFFERS_NOEXCEPT = default;
      BadAlignmentRootT &operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT;
  };
  
  struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
  {
      typedef BadAlignmentRootT NativeTableType;
      typedef BadAlignmentRootBuilder Builder;
      struct Traits;
      static const ::flatbuffers::TypeTable *MiniReflectTypeTable()
      {
          return BadAlignmentRootTypeTable();
      }
      enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
      {
          VT_LARGE = 4,
          VT_SMALL = 6
      };
      const OuterLarge *large() const { return GetPointer<const OuterLarge *>(VT_LARGE); }
      OuterLarge *mutable_large() { return GetPointer<OuterLarge *>(VT_LARGE); }
      const ::flatbuffers::Vector<const BadAlignmentSmall *> *small() const
      {
          return GetPointer<const ::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
      }
      ::flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small()
      {
          return GetPointer<::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
      }
      bool Verify(::flatbuffers::Verifier &verifier) const
      {
          return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_LARGE) &&
                 verifier.VerifyTable(large()) && VerifyOffset(verifier, VT_SMALL) &&
                 verifier.VerifyVector(small()) && verifier.EndTable();
      }
      BadAlignmentRootT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
      void UnPackTo(BadAlignmentRootT *_o,
                    const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
      static ::flatbuffers::Offset<BadAlignmentRoot> Pack(
          ::flatbuffers::FlatBufferBuilder &_fbb,
          const BadAlignmentRootT *_o,
          const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
  };
  
  struct BadAlignmentRootBuilder
  {
      typedef BadAlignmentRoot Table;
      ::flatbuffers::FlatBufferBuilder &fbb_;
      ::flatbuffers::uoffset_t start_;
      void add_large(::flatbuffers::Offset<OuterLarge> large)
      {
          fbb_.AddOffset(BadAlignmentRoot::VT_LARGE, large);
      }
      void add_small(::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small)
      {
          fbb_.AddOffset(BadAlignmentRoot::VT_SMALL, small);
      }
      explicit BadAlignmentRootBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
      {
          start_ = fbb_.StartTable();
      }
      ::flatbuffers::Offset<BadAlignmentRoot> Finish()
      {
          const auto end = fbb_.EndTable(start_);
          auto o         = ::flatbuffers::Offset<BadAlignmentRoot>(end);
          return o;
      }
  };
  
  inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      ::flatbuffers::Offset<OuterLarge> large                                       = 0,
      ::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small = 0)
  {
      BadAlignmentRootBuilder builder_(_fbb);
      builder_.add_small(small);
      builder_.add_large(large);
      return builder_.Finish();
  }
  
  struct BadAlignmentRoot::Traits
  {
      using type                   = BadAlignmentRoot;
      static auto constexpr Create = CreateBadAlignmentRoot;
  };
  
  inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      ::flatbuffers::Offset<OuterLarge> large     = 0,
      const std::vector<BadAlignmentSmall> *small = nullptr)
  {
      auto small__ = small ? _fbb.CreateVectorOfStructs<BadAlignmentSmall>(*small) : 0;
      return CreateBadAlignmentRoot(_fbb, large, small__);
  }
  
  ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      const BadAlignmentRootT *_o,
      const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
  
  inline bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs)
  {
      return ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large));
  }
  
  inline bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs)
  {
      return !(lhs == rhs);
  }
  
  inline OuterLargeT::OuterLargeT(const OuterLargeT &o)
      : large((o.large) ? new BadAlignmentLarge(*o.large) : nullptr)
  {}
  
  inline OuterLargeT &OuterLargeT::operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT
  {
      std::swap(large, o.large);
      return *this;
  }
  
  inline OuterLargeT *OuterLarge::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const
  {
      auto _o = std::make_unique<OuterLargeT>();
      UnPackTo(_o.get(), _resolver);
      return _o.release();
  }
  
  inline void OuterLarge::UnPackTo(OuterLargeT *_o,
                                   const ::flatbuffers::resolver_function_t *_resolver) const
  {
      (void)_o;
      (void)_resolver;
      {
          auto _e = large();
          if (_e)
          {
              _o->large = std::unique_ptr<BadAlignmentLarge>(new BadAlignmentLarge(*_e));
          }
      }
  }
  
  inline ::flatbuffers::Offset<OuterLarge> OuterLarge::Pack(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      const OuterLargeT *_o,
      const ::flatbuffers::rehasher_function_t *_rehasher)
  {
      return CreateOuterLarge(_fbb, _o, _rehasher);
  }
  
  inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      const OuterLargeT *_o,
      const ::flatbuffers::rehasher_function_t *_rehasher)
  {
      (void)_rehasher;
      (void)_o;
      struct _VectorArgs
      {
          ::flatbuffers::FlatBufferBuilder *__fbb;
          const OuterLargeT *__o;
          const ::flatbuffers::rehasher_function_t *__rehasher;
      } _va = {&_fbb, _o, _rehasher};
      (void)_va;
      auto _large = _o->large ? _o->large.get() : nullptr;
      return CreateOuterLarge(_fbb, _large);
  }
  
  inline bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs)
  {
      return ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large)) &&
             (lhs.small == rhs.small);
  }
  
  inline bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs)
  {
      return !(lhs == rhs);
  }
  
  inline BadAlignmentRootT::BadAlignmentRootT(const BadAlignmentRootT &o)
      : large((o.large) ? new OuterLargeT(*o.large) : nullptr), small(o.small)
  {}
  
  inline BadAlignmentRootT &BadAlignmentRootT::operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT
  {
      std::swap(large, o.large);
      std::swap(small, o.small);
      return *this;
  }
  
  inline BadAlignmentRootT *BadAlignmentRoot::UnPack(
      const ::flatbuffers::resolver_function_t *_resolver) const
  {
      auto _o = std::make_unique<BadAlignmentRootT>();
      UnPackTo(_o.get(), _resolver);
      return _o.release();
  }
  
  inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o,
                                         const ::flatbuffers::resolver_function_t *_resolver) const
  {
      (void)_o;
      (void)_resolver;
      {
          auto _e = large();
          if (_e)
          {
              if (_o->large)
              {
                  _e->UnPackTo(_o->large.get(), _resolver);
              }
              else
              {
                  _o->large = std::unique_ptr<OuterLargeT>(_e->UnPack(_resolver));
              }
          }
          else if (_o->large)
          {
              _o->large.reset();
          }
      }
      {
          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);
          }
      }
  }
  
  inline ::flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      const BadAlignmentRootT *_o,
      const ::flatbuffers::rehasher_function_t *_rehasher)
  {
      return CreateBadAlignmentRoot(_fbb, _o, _rehasher);
  }
  
  inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
      ::flatbuffers::FlatBufferBuilder &_fbb,
      const BadAlignmentRootT *_o,
      const ::flatbuffers::rehasher_function_t *_rehasher)
  {
      (void)_rehasher;
      (void)_o;
      struct _VectorArgs
      {
          ::flatbuffers::FlatBufferBuilder *__fbb;
          const BadAlignmentRootT *__o;
          const ::flatbuffers::rehasher_function_t *__rehasher;
      } _va = {&_fbb, _o, _rehasher};
      (void)_va;
      auto _large = _o->large ? CreateOuterLarge(_fbb, _o->large.get(), _rehasher) : 0;
      auto _small = _o->small.size() ? _fbb.CreateVectorOfStructs(_o->small) : 0;
      return CreateBadAlignmentRoot(_fbb, _large, _small);
  }
  
  inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable()
  {
      static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_UCHAR, 0, -1},
                                                           {::flatbuffers::ET_UCHAR, 0, -1}};
      static const int64_t values[]                     = {0, 1, 2};
      static const char *const names[]                  = {"var_0", "var_1"};
      static const ::flatbuffers::TypeTable tt          = {
          ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names};
      return &tt;
  }
  
  inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable()
  {
      static const ::flatbuffers::TypeCode type_codes[] = {{::flatbuffers::ET_ULONG, 0, -1}};
      static const int64_t values[]                     = {0, 8};
      static const char *const names[]                  = {"var_0"};
      static const ::flatbuffers::TypeTable tt          = {
          ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names};
      return &tt;
  }
  
  inline const ::flatbuffers::TypeTable *OuterLargeTypeTable()
  {
      static const ::flatbuffers::TypeCode type_codes[]    = {{::flatbuffers::ET_SEQUENCE, 0, 0}};
      static const ::flatbuffers::TypeFunction type_refs[] = {BadAlignmentLargeTypeTable};
      static const char *const names[]                     = {"large"};
      static const ::flatbuffers::TypeTable tt             = {
          ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names};
      return &tt;
  }
  
  inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable()
  {
      static const ::flatbuffers::TypeCode type_codes[]    = {{::flatbuffers::ET_SEQUENCE, 0, 0},
                                                              {::flatbuffers::ET_SEQUENCE, 1, 1}};
      static const ::flatbuffers::TypeFunction type_refs[] = {OuterLargeTypeTable,
                                                              BadAlignmentSmallTypeTable};
      static const char *const names[]                     = {"large", "small"};
      static const ::flatbuffers::TypeTable tt             = {
          ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names};
      return &tt;
  }
  
  inline const BadAlignmentRoot *GetBadAlignmentRoot(const void *buf)
  {
      return ::flatbuffers::GetRoot<BadAlignmentRoot>(buf);
  }
  
  inline const BadAlignmentRoot *GetSizePrefixedBadAlignmentRoot(const void *buf)
  {
      return ::flatbuffers::GetSizePrefixedRoot<BadAlignmentRoot>(buf);
  }
  
  inline BadAlignmentRoot *GetMutableBadAlignmentRoot(void *buf)
  {
      return ::flatbuffers::GetMutableRoot<BadAlignmentRoot>(buf);
  }
  
  inline BadAlignmentRoot *GetMutableSizePrefixedBadAlignmentRoot(void *buf)
  {
      return ::flatbuffers::GetMutableSizePrefixedRoot<BadAlignmentRoot>(buf);
  }
  
  inline bool VerifyBadAlignmentRootBuffer(::flatbuffers::Verifier &verifier)
  {
      return verifier.VerifyBuffer<BadAlignmentRoot>(nullptr);
  }
  
  inline bool VerifySizePrefixedBadAlignmentRootBuffer(::flatbuffers::Verifier &verifier)
  {
      return verifier.VerifySizePrefixedBuffer<BadAlignmentRoot>(nullptr);
  }
  
  inline void FinishBadAlignmentRootBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                           ::flatbuffers::Offset<BadAlignmentRoot> root)
  {
      fbb.Finish(root);
  }
  
  inline void FinishSizePrefixedBadAlignmentRootBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                                       ::flatbuffers::Offset<BadAlignmentRoot> root)
  {
      fbb.FinishSizePrefixed(root);
  }
  
  inline std::unique_ptr<BadAlignmentRootT> UnPackBadAlignmentRoot(
      const void *buf,
      const ::flatbuffers::resolver_function_t *res = nullptr)
  {
      return std::unique_ptr<BadAlignmentRootT>(GetBadAlignmentRoot(buf)->UnPack(res));
  }
  
  inline std::unique_ptr<BadAlignmentRootT> UnPackSizePrefixedBadAlignmentRoot(
      const void *buf,
      const ::flatbuffers::resolver_function_t *res = nullptr)
  {
      return std::unique_ptr<BadAlignmentRootT>(GetSizePrefixedBadAlignmentRoot(buf)->UnPack(res));
  }
  
  #endif  // FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
  

Download