// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_ASSETHEADER_BIGFOOT_FLAT_H_
#define FLATBUFFERS_GENERATED_ASSETHEADER_BIGFOOT_FLAT_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 == 25 &&
              FLATBUFFERS_VERSION_MINOR == 12 &&
              FLATBUFFERS_VERSION_REVISION == 19,
             "Non-compatible flatbuffers version included");

#include "Engine/BigFile/Asset/AssetTypeID.hpp"
#include "Engine/BigFile/Asset/AssetTypeID.hpp"
#include "System/UUID/UUID.hpp"
#include "Engine/BigFile/Asset/AssetTypeID_generated.hpp"
#include "System/UUID/UUID_generated.hpp"

#include "EASTL/unique_ptr.h"
#include "EASTL/string.h"

namespace Bigfoot {
namespace Flat {

struct AssetHeader;
struct AssetHeaderBuilder;
struct AssetHeaderT;

inline const ::flatbuffers::TypeTable *AssetHeaderTypeTable();

struct AssetHeaderT : public ::flatbuffers::NativeTable {
  typedef AssetHeader TableType;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "Bigfoot.Flat.AssetHeaderT";
  }
  ::Bigfoot::UUID uuid{};
  eastl::string name{};
  ::Bigfoot::AssetTypeID type_id{};
  eastl::string type_name{};
  uint32_t version = 0;
};

struct AssetHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AssetHeaderT NativeTableType;
  typedef AssetHeaderBuilder Builder;
  struct Traits;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return AssetHeaderTypeTable();
  }
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "Bigfoot.Flat.AssetHeader";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_UUID = 4,
    VT_NAME = 6,
    VT_TYPE_ID = 8,
    VT_TYPE_NAME = 10,
    VT_VERSION = 12
  };
  const Bigfoot::Flat::UUID *uuid() const {
    return GetStruct<const Bigfoot::Flat::UUID *>(VT_UUID);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const Bigfoot::Flat::AssetTypeID *type_id() const {
    return GetStruct<const Bigfoot::Flat::AssetTypeID *>(VT_TYPE_ID);
  }
  const ::flatbuffers::String *type_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TYPE_NAME);
  }
  uint32_t version() const {
    return GetField<uint32_t>(VT_VERSION, 0);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyFieldRequired<Bigfoot::Flat::UUID>(verifier, VT_UUID, 1) &&
           VerifyOffsetRequired(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyFieldRequired<Bigfoot::Flat::AssetTypeID>(verifier, VT_TYPE_ID, 8) &&
           VerifyOffsetRequired(verifier, VT_TYPE_NAME) &&
           verifier.VerifyString(type_name()) &&
           VerifyField<uint32_t>(verifier, VT_VERSION, 4) &&
           verifier.EndTable();
  }
  AssetHeaderT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(AssetHeaderT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<AssetHeader> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct AssetHeaderBuilder {
  typedef AssetHeader Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_uuid(const Bigfoot::Flat::UUID *uuid) {
    fbb_.AddStruct(AssetHeader::VT_UUID, uuid);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(AssetHeader::VT_NAME, name);
  }
  void add_type_id(const Bigfoot::Flat::AssetTypeID *type_id) {
    fbb_.AddStruct(AssetHeader::VT_TYPE_ID, type_id);
  }
  void add_type_name(::flatbuffers::Offset<::flatbuffers::String> type_name) {
    fbb_.AddOffset(AssetHeader::VT_TYPE_NAME, type_name);
  }
  void add_version(uint32_t version) {
    fbb_.AddElement<uint32_t>(AssetHeader::VT_VERSION, version, 0);
  }
  explicit AssetHeaderBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AssetHeader> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AssetHeader>(end);
    fbb_.Required(o, AssetHeader::VT_UUID);
    fbb_.Required(o, AssetHeader::VT_NAME);
    fbb_.Required(o, AssetHeader::VT_TYPE_ID);
    fbb_.Required(o, AssetHeader::VT_TYPE_NAME);
    return o;
  }
};

inline ::flatbuffers::Offset<AssetHeader> CreateAssetHeader(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const Bigfoot::Flat::UUID *uuid = nullptr,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    const Bigfoot::Flat::AssetTypeID *type_id = nullptr,
    ::flatbuffers::Offset<::flatbuffers::String> type_name = 0,
    uint32_t version = 0) {
  AssetHeaderBuilder builder_(_fbb);
  builder_.add_version(version);
  builder_.add_type_name(type_name);
  builder_.add_type_id(type_id);
  builder_.add_name(name);
  builder_.add_uuid(uuid);
  return builder_.Finish();
}

struct AssetHeader::Traits {
  using type = AssetHeader;
  static auto constexpr Create = CreateAssetHeader;
};

::flatbuffers::Offset<AssetHeader> CreateAssetHeader(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

inline AssetHeaderT *AssetHeader::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::make_unique<AssetHeaderT>();
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void AssetHeader::UnPackTo(AssetHeaderT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = uuid(); if (_e) _o->uuid = ::flatbuffers::UnPack(*_e); }
  { auto _e = name(); if (_e) _o->name = eastl::string(_e->c_str(), _e->size()); }
  { auto _e = type_id(); if (_e) _o->type_id = ::flatbuffers::UnPack(*_e); }
  { auto _e = type_name(); if (_e) _o->type_name = eastl::string(_e->c_str(), _e->size()); }
  { auto _e = version(); _o->version = _e; }
}

inline ::flatbuffers::Offset<AssetHeader> CreateAssetHeader(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return AssetHeader::Pack(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<AssetHeader> AssetHeader::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetHeaderT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _uuid = ::flatbuffers::Pack(_o->uuid);
  auto _name = _fbb.CreateString(_o->name);
  auto _type_id = ::flatbuffers::Pack(_o->type_id);
  auto _type_name = _fbb.CreateString(_o->type_name);
  auto _version = _o->version;
  return Bigfoot::Flat::CreateAssetHeader(
      _fbb,
      &_uuid,
      _name,
      &_type_id,
      _type_name,
      _version);
}

inline const ::flatbuffers::TypeTable *AssetHeaderTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_UINT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    Bigfoot::Flat::UUIDTypeTable,
    Bigfoot::Flat::AssetTypeIDTypeTable
  };
  static const char * const names[] = {
    "uuid",
    "name",
    "type_id",
    "type_name",
    "version"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const Bigfoot::Flat::AssetHeader *GetAssetHeader(const void *buf) {
  return ::flatbuffers::GetRoot<Bigfoot::Flat::AssetHeader>(buf);
}

inline const Bigfoot::Flat::AssetHeader *GetSizePrefixedAssetHeader(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<Bigfoot::Flat::AssetHeader>(buf);
}

template <bool B = false>
inline bool VerifyAssetHeaderBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifyBuffer<Bigfoot::Flat::AssetHeader>(nullptr);
}

template <bool B = false>
inline bool VerifySizePrefixedAssetHeaderBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifySizePrefixedBuffer<Bigfoot::Flat::AssetHeader>(nullptr);
}

inline const char *AssetHeaderExtension() {
  return "bfbs";
}

inline void FinishAssetHeaderBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Bigfoot::Flat::AssetHeader> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedAssetHeaderBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Bigfoot::Flat::AssetHeader> root) {
  fbb.FinishSizePrefixed(root);
}

inline eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT> UnPackAssetHeader(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) {
  return eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT>(GetAssetHeader(buf)->UnPack(res));
}

inline eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT> UnPackSizePrefixedAssetHeader(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) {
  return eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT>(GetSizePrefixedAssetHeader(buf)->UnPack(res));
}

}  // namespace Flat
}  // namespace Bigfoot

#endif  // FLATBUFFERS_GENERATED_ASSETHEADER_BIGFOOT_FLAT_H_
