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


#ifndef FLATBUFFERS_GENERATED_GPUCACHE_MINDSPORE_SCHEMA_H_
#define FLATBUFFERS_GENERATED_GPUCACHE_MINDSPORE_SCHEMA_H_

#include "flatbuffers/flatbuffers.h"

namespace mindspore {
namespace schema {

struct TuneParam;
struct TuneParamBuilder;

struct ProgramBinary;
struct ProgramBinaryBuilder;

struct GpuCache;
struct GpuCacheBuilder;

struct TuneParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TuneParamBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LOCAL = 4,
    VT_BLOCK = 6,
    VT_SHAPE = 8,
    VT_OPPARA = 10
  };
  const flatbuffers::Vector<int32_t> *local() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_LOCAL);
  }
  const flatbuffers::Vector<int32_t> *block() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK);
  }
  const flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  const flatbuffers::Vector<int32_t> *opPara() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OPPARA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_LOCAL) &&
           verifier.VerifyVector(local()) &&
           VerifyOffset(verifier, VT_BLOCK) &&
           verifier.VerifyVector(block()) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyOffset(verifier, VT_OPPARA) &&
           verifier.VerifyVector(opPara()) &&
           verifier.EndTable();
  }
};

struct TuneParamBuilder {
  typedef TuneParam Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_local(flatbuffers::Offset<flatbuffers::Vector<int32_t>> local) {
    fbb_.AddOffset(TuneParam::VT_LOCAL, local);
  }
  void add_block(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block) {
    fbb_.AddOffset(TuneParam::VT_BLOCK, block);
  }
  void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(TuneParam::VT_SHAPE, shape);
  }
  void add_opPara(flatbuffers::Offset<flatbuffers::Vector<int32_t>> opPara) {
    fbb_.AddOffset(TuneParam::VT_OPPARA, opPara);
  }
  explicit TuneParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<TuneParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<TuneParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<TuneParam> CreateTuneParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> local = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> block = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> opPara = 0) {
  TuneParamBuilder builder_(_fbb);
  builder_.add_opPara(opPara);
  builder_.add_shape(shape);
  builder_.add_block(block);
  builder_.add_local(local);
  return builder_.Finish();
}

inline flatbuffers::Offset<TuneParam> CreateTuneParamDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *local = nullptr,
    const std::vector<int32_t> *block = nullptr,
    const std::vector<int32_t> *shape = nullptr,
    const std::vector<int32_t> *opPara = nullptr) {
  auto local__ = local ? _fbb.CreateVector<int32_t>(*local) : 0;
  auto block__ = block ? _fbb.CreateVector<int32_t>(*block) : 0;
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  auto opPara__ = opPara ? _fbb.CreateVector<int32_t>(*opPara) : 0;
  return mindspore::schema::CreateTuneParam(
      _fbb,
      local__,
      block__,
      shape__,
      opPara__);
}

struct ProgramBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ProgramBinaryBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PROGRAM_NAME = 4,
    VT_BUILD_OPTION = 6,
    VT_TUNE = 8,
    VT_DATA = 10
  };
  const flatbuffers::String *program_name() const {
    return GetPointer<const flatbuffers::String *>(VT_PROGRAM_NAME);
  }
  const flatbuffers::String *build_option() const {
    return GetPointer<const flatbuffers::String *>(VT_BUILD_OPTION);
  }
  const mindspore::schema::TuneParam *tune() const {
    return GetPointer<const mindspore::schema::TuneParam *>(VT_TUNE);
  }
  const flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_PROGRAM_NAME) &&
           verifier.VerifyString(program_name()) &&
           VerifyOffset(verifier, VT_BUILD_OPTION) &&
           verifier.VerifyString(build_option()) &&
           VerifyOffset(verifier, VT_TUNE) &&
           verifier.VerifyTable(tune()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct ProgramBinaryBuilder {
  typedef ProgramBinary Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_program_name(flatbuffers::Offset<flatbuffers::String> program_name) {
    fbb_.AddOffset(ProgramBinary::VT_PROGRAM_NAME, program_name);
  }
  void add_build_option(flatbuffers::Offset<flatbuffers::String> build_option) {
    fbb_.AddOffset(ProgramBinary::VT_BUILD_OPTION, build_option);
  }
  void add_tune(flatbuffers::Offset<mindspore::schema::TuneParam> tune) {
    fbb_.AddOffset(ProgramBinary::VT_TUNE, tune);
  }
  void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(ProgramBinary::VT_DATA, data);
  }
  explicit ProgramBinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ProgramBinary> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ProgramBinary>(end);
    return o;
  }
};

inline flatbuffers::Offset<ProgramBinary> CreateProgramBinary(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> program_name = 0,
    flatbuffers::Offset<flatbuffers::String> build_option = 0,
    flatbuffers::Offset<mindspore::schema::TuneParam> tune = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
  ProgramBinaryBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_tune(tune);
  builder_.add_build_option(build_option);
  builder_.add_program_name(program_name);
  return builder_.Finish();
}

inline flatbuffers::Offset<ProgramBinary> CreateProgramBinaryDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *program_name = nullptr,
    const char *build_option = nullptr,
    flatbuffers::Offset<mindspore::schema::TuneParam> tune = 0,
    const std::vector<uint8_t> *data = nullptr) {
  auto program_name__ = program_name ? _fbb.CreateString(program_name) : 0;
  auto build_option__ = build_option ? _fbb.CreateString(build_option) : 0;
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return mindspore::schema::CreateProgramBinary(
      _fbb,
      program_name__,
      build_option__,
      tune,
      data__);
}

struct GpuCache FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GpuCacheBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_VERSION = 6,
    VT_ALLBINS = 8
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  const flatbuffers::String *version() const {
    return GetPointer<const flatbuffers::String *>(VT_VERSION);
  }
  const flatbuffers::Vector<flatbuffers::Offset<mindspore::schema::ProgramBinary>> *allBins() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<mindspore::schema::ProgramBinary>> *>(VT_ALLBINS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_VERSION) &&
           verifier.VerifyString(version()) &&
           VerifyOffset(verifier, VT_ALLBINS) &&
           verifier.VerifyVector(allBins()) &&
           verifier.VerifyVectorOfTables(allBins()) &&
           verifier.EndTable();
  }
};

struct GpuCacheBuilder {
  typedef GpuCache Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(GpuCache::VT_NAME, name);
  }
  void add_version(flatbuffers::Offset<flatbuffers::String> version) {
    fbb_.AddOffset(GpuCache::VT_VERSION, version);
  }
  void add_allBins(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<mindspore::schema::ProgramBinary>>> allBins) {
    fbb_.AddOffset(GpuCache::VT_ALLBINS, allBins);
  }
  explicit GpuCacheBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GpuCache> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GpuCache>(end);
    return o;
  }
};

inline flatbuffers::Offset<GpuCache> CreateGpuCache(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    flatbuffers::Offset<flatbuffers::String> version = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<mindspore::schema::ProgramBinary>>> allBins = 0) {
  GpuCacheBuilder builder_(_fbb);
  builder_.add_allBins(allBins);
  builder_.add_version(version);
  builder_.add_name(name);
  return builder_.Finish();
}

inline flatbuffers::Offset<GpuCache> CreateGpuCacheDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const char *version = nullptr,
    const std::vector<flatbuffers::Offset<mindspore::schema::ProgramBinary>> *allBins = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto version__ = version ? _fbb.CreateString(version) : 0;
  auto allBins__ = allBins ? _fbb.CreateVector<flatbuffers::Offset<mindspore::schema::ProgramBinary>>(*allBins) : 0;
  return mindspore::schema::CreateGpuCache(
      _fbb,
      name__,
      version__,
      allBins__);
}

inline const mindspore::schema::GpuCache *GetGpuCache(const void *buf) {
  return flatbuffers::GetRoot<mindspore::schema::GpuCache>(buf);
}

inline const mindspore::schema::GpuCache *GetSizePrefixedGpuCache(const void *buf) {
  return flatbuffers::GetSizePrefixedRoot<mindspore::schema::GpuCache>(buf);
}

inline bool VerifyGpuCacheBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<mindspore::schema::GpuCache>(nullptr);
}

inline bool VerifySizePrefixedGpuCacheBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<mindspore::schema::GpuCache>(nullptr);
}

inline void FinishGpuCacheBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<mindspore::schema::GpuCache> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedGpuCacheBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<mindspore::schema::GpuCache> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace schema
}  // namespace mindspore

#endif  // FLATBUFFERS_GENERATED_GPUCACHE_MINDSPORE_SCHEMA_H_