command_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_COMMAND_TT_TARGET_METAL_H_
#define FLATBUFFERS_GENERATED_COMMAND_TT_TARGET_METAL_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 == 24 &&
              FLATBUFFERS_VERSION_MINOR == 3 &&
              FLATBUFFERS_VERSION_REVISION == 25,
             "Non-compatible flatbuffers version included");
 
#include "ttmlir/Target/TTMetal/program_generated.h"
#include "ttmlir/Target/TTMetal/types_generated.h"
 
namespace tt {
namespace target {
namespace metal {
 
struct HostAllocCommand;
struct HostAllocCommandBuilder;
 
struct ReturnCommand;
struct ReturnCommandBuilder;
 
struct EnqueueProgramCommand;
struct EnqueueProgramCommandBuilder;
 
struct EnqueueWriteBufferCommand;
struct EnqueueWriteBufferCommandBuilder;
 
struct EnqueueReadBufferCommand;
struct EnqueueReadBufferCommandBuilder;
 
struct CreateBufferCommand;
struct CreateBufferCommandBuilder;
 
struct DeallocateBufferCommand;
struct DeallocateBufferCommandBuilder;
 
struct CreateEventCommand;
struct CreateEventCommandBuilder;
 
struct EnqueueRecordEventCommand;
struct EnqueueRecordEventCommandBuilder;
 
struct EnqueueWaitForEventCommand;
struct EnqueueWaitForEventCommandBuilder;
 
struct EventSynchronizeCommand;
struct EventSynchronizeCommandBuilder;
 
struct EventQueryCommand;
struct EventQueryCommandBuilder;
 
struct MemrefCopyCommand;
struct MemrefCopyCommandBuilder;
 
struct CpuCommand;
struct CpuCommandBuilder;
 
struct FinishCommand;
struct FinishCommandBuilder;
 
struct Command;
struct CommandBuilder;
 
struct CommandQueue;
struct CommandQueueBuilder;
 
enum class CommandType : uint8_t {
  NONE = 0,
  HostAllocCommand = 1,
  ReturnCommand = 2,
  EnqueueProgramCommand = 3,
  EnqueueWriteBufferCommand = 4,
  EnqueueReadBufferCommand = 5,
  CreateBufferCommand = 6,
  DeallocateBufferCommand = 7,
  CreateEventCommand = 8,
  EnqueueRecordEventCommand = 9,
  EnqueueWaitForEventCommand = 10,
  EventSynchronizeCommand = 11,
  EventQueryCommand = 12,
  MemrefCopyCommand = 13,
  CpuCommand = 14,
  FinishCommand = 15,
  MIN = NONE,
  MAX = FinishCommand
};
 
inline const CommandType (&EnumValuesCommandType())[16] {
  static const CommandType values[] = {
    CommandType::NONE,
    CommandType::HostAllocCommand,
    CommandType::ReturnCommand,
    CommandType::EnqueueProgramCommand,
    CommandType::EnqueueWriteBufferCommand,
    CommandType::EnqueueReadBufferCommand,
    CommandType::CreateBufferCommand,
    CommandType::DeallocateBufferCommand,
    CommandType::CreateEventCommand,
    CommandType::EnqueueRecordEventCommand,
    CommandType::EnqueueWaitForEventCommand,
    CommandType::EventSynchronizeCommand,
    CommandType::EventQueryCommand,
    CommandType::MemrefCopyCommand,
    CommandType::CpuCommand,
    CommandType::FinishCommand
  };
  return values;
}
 
inline const char * const *EnumNamesCommandType() {
  static const char * const names[17] = {
    "NONE",
    "HostAllocCommand",
    "ReturnCommand",
    "EnqueueProgramCommand",
    "EnqueueWriteBufferCommand",
    "EnqueueReadBufferCommand",
    "CreateBufferCommand",
    "DeallocateBufferCommand",
    "CreateEventCommand",
    "EnqueueRecordEventCommand",
    "EnqueueWaitForEventCommand",
    "EventSynchronizeCommand",
    "EventQueryCommand",
    "MemrefCopyCommand",
    "CpuCommand",
    "FinishCommand",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameCommandType(CommandType e) {
  if (::flatbuffers::IsOutRange(e, CommandType::NONE, CommandType::FinishCommand)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesCommandType()[index];
}
 
template<typename T> struct CommandTypeTraits {
  static const CommandType enum_value = CommandType::NONE;
};
 
template<> struct CommandTypeTraits<tt::target::metal::HostAllocCommand> {
  static const CommandType enum_value = CommandType::HostAllocCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::ReturnCommand> {
  static const CommandType enum_value = CommandType::ReturnCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::EnqueueProgramCommand> {
  static const CommandType enum_value = CommandType::EnqueueProgramCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::EnqueueWriteBufferCommand> {
  static const CommandType enum_value = CommandType::EnqueueWriteBufferCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::EnqueueReadBufferCommand> {
  static const CommandType enum_value = CommandType::EnqueueReadBufferCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::CreateBufferCommand> {
  static const CommandType enum_value = CommandType::CreateBufferCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::DeallocateBufferCommand> {
  static const CommandType enum_value = CommandType::DeallocateBufferCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::CreateEventCommand> {
  static const CommandType enum_value = CommandType::CreateEventCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::EnqueueRecordEventCommand> {
  static const CommandType enum_value = CommandType::EnqueueRecordEventCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::EnqueueWaitForEventCommand> {
  static const CommandType enum_value = CommandType::EnqueueWaitForEventCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::EventSynchronizeCommand> {
  static const CommandType enum_value = CommandType::EventSynchronizeCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::EventQueryCommand> {
  static const CommandType enum_value = CommandType::EventQueryCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::MemrefCopyCommand> {
  static const CommandType enum_value = CommandType::MemrefCopyCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::CpuCommand> {
  static const CommandType enum_value = CommandType::CpuCommand;
};
 
template<> struct CommandTypeTraits<tt::target::metal::FinishCommand> {
  static const CommandType enum_value = CommandType::FinishCommand;
};
 
bool VerifyCommandType(::flatbuffers::Verifier &verifier, const void *obj, CommandType type);
bool VerifyCommandTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<CommandType> *types);
 
struct HostAllocCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HostAllocCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.HostAllocCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DST = 4,
    VT_DATA = 6
  };
  const tt::target::metal::BufferRef *dst() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_DST);
  }
  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_DST) &&
           verifier.VerifyTable(dst()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};
 
struct HostAllocCommandBuilder {
  typedef HostAllocCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_dst(::flatbuffers::Offset<tt::target::metal::BufferRef> dst) {
    fbb_.AddOffset(HostAllocCommand::VT_DST, dst);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(HostAllocCommand::VT_DATA, data);
  }
  explicit HostAllocCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HostAllocCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HostAllocCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<HostAllocCommand> CreateHostAllocCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> dst = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
  HostAllocCommandBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_dst(dst);
  return builder_.Finish();
}
 
struct HostAllocCommand::Traits {
  using type = HostAllocCommand;
  static auto constexpr Create = CreateHostAllocCommand;
};
 
inline ::flatbuffers::Offset<HostAllocCommand> CreateHostAllocCommandDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> dst = 0,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return tt::target::metal::CreateHostAllocCommand(
      _fbb,
      dst,
      data__);
}
 
struct ReturnCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReturnCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.ReturnCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RESULTS = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *results() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *>(VT_RESULTS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_RESULTS) &&
           verifier.VerifyVector(results()) &&
           verifier.VerifyVectorOfTables(results()) &&
           verifier.EndTable();
  }
};
 
struct ReturnCommandBuilder {
  typedef ReturnCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_results(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> results) {
    fbb_.AddOffset(ReturnCommand::VT_RESULTS, results);
  }
  explicit ReturnCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReturnCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReturnCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReturnCommand> CreateReturnCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> results = 0) {
  ReturnCommandBuilder builder_(_fbb);
  builder_.add_results(results);
  return builder_.Finish();
}
 
struct ReturnCommand::Traits {
  using type = ReturnCommand;
  static auto constexpr Create = CreateReturnCommand;
};
 
inline ::flatbuffers::Offset<ReturnCommand> CreateReturnCommandDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *results = nullptr) {
  auto results__ = results ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::BufferRef>>(*results) : 0;
  return tt::target::metal::CreateReturnCommand(
      _fbb,
      results__);
}
 
struct EnqueueProgramCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnqueueProgramCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.EnqueueProgramCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BUFFERS = 4,
    VT_CBS = 6,
    VT_PROGRAM = 8
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *buffers() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *>(VT_BUFFERS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CBRef>> *cbs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CBRef>> *>(VT_CBS);
  }
  const tt::target::metal::ProgramDesc *program() const {
    return GetPointer<const tt::target::metal::ProgramDesc *>(VT_PROGRAM);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_BUFFERS) &&
           verifier.VerifyVector(buffers()) &&
           verifier.VerifyVectorOfTables(buffers()) &&
           VerifyOffset(verifier, VT_CBS) &&
           verifier.VerifyVector(cbs()) &&
           verifier.VerifyVectorOfTables(cbs()) &&
           VerifyOffset(verifier, VT_PROGRAM) &&
           verifier.VerifyTable(program()) &&
           verifier.EndTable();
  }
};
 
struct EnqueueProgramCommandBuilder {
  typedef EnqueueProgramCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_buffers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> buffers) {
    fbb_.AddOffset(EnqueueProgramCommand::VT_BUFFERS, buffers);
  }
  void add_cbs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CBRef>>> cbs) {
    fbb_.AddOffset(EnqueueProgramCommand::VT_CBS, cbs);
  }
  void add_program(::flatbuffers::Offset<tt::target::metal::ProgramDesc> program) {
    fbb_.AddOffset(EnqueueProgramCommand::VT_PROGRAM, program);
  }
  explicit EnqueueProgramCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EnqueueProgramCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EnqueueProgramCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EnqueueProgramCommand> CreateEnqueueProgramCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> buffers = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CBRef>>> cbs = 0,
    ::flatbuffers::Offset<tt::target::metal::ProgramDesc> program = 0) {
  EnqueueProgramCommandBuilder builder_(_fbb);
  builder_.add_program(program);
  builder_.add_cbs(cbs);
  builder_.add_buffers(buffers);
  return builder_.Finish();
}
 
struct EnqueueProgramCommand::Traits {
  using type = EnqueueProgramCommand;
  static auto constexpr Create = CreateEnqueueProgramCommand;
};
 
inline ::flatbuffers::Offset<EnqueueProgramCommand> CreateEnqueueProgramCommandDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *buffers = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::metal::CBRef>> *cbs = nullptr,
    ::flatbuffers::Offset<tt::target::metal::ProgramDesc> program = 0) {
  auto buffers__ = buffers ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::BufferRef>>(*buffers) : 0;
  auto cbs__ = cbs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::CBRef>>(*cbs) : 0;
  return tt::target::metal::CreateEnqueueProgramCommand(
      _fbb,
      buffers__,
      cbs__,
      program);
}
 
struct EnqueueWriteBufferCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnqueueWriteBufferCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.EnqueueWriteBufferCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SRC = 4,
    VT_DST = 6
  };
  const tt::target::metal::BufferRef *src() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_SRC);
  }
  const tt::target::metal::BufferRef *dst() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_DST);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SRC) &&
           verifier.VerifyTable(src()) &&
           VerifyOffset(verifier, VT_DST) &&
           verifier.VerifyTable(dst()) &&
           verifier.EndTable();
  }
};
 
struct EnqueueWriteBufferCommandBuilder {
  typedef EnqueueWriteBufferCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_src(::flatbuffers::Offset<tt::target::metal::BufferRef> src) {
    fbb_.AddOffset(EnqueueWriteBufferCommand::VT_SRC, src);
  }
  void add_dst(::flatbuffers::Offset<tt::target::metal::BufferRef> dst) {
    fbb_.AddOffset(EnqueueWriteBufferCommand::VT_DST, dst);
  }
  explicit EnqueueWriteBufferCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EnqueueWriteBufferCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EnqueueWriteBufferCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EnqueueWriteBufferCommand> CreateEnqueueWriteBufferCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> src = 0,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> dst = 0) {
  EnqueueWriteBufferCommandBuilder builder_(_fbb);
  builder_.add_dst(dst);
  builder_.add_src(src);
  return builder_.Finish();
}
 
struct EnqueueWriteBufferCommand::Traits {
  using type = EnqueueWriteBufferCommand;
  static auto constexpr Create = CreateEnqueueWriteBufferCommand;
};
 
struct EnqueueReadBufferCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnqueueReadBufferCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.EnqueueReadBufferCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SRC = 4,
    VT_DST = 6
  };
  const tt::target::metal::BufferRef *src() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_SRC);
  }
  const tt::target::metal::BufferRef *dst() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_DST);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SRC) &&
           verifier.VerifyTable(src()) &&
           VerifyOffset(verifier, VT_DST) &&
           verifier.VerifyTable(dst()) &&
           verifier.EndTable();
  }
};
 
struct EnqueueReadBufferCommandBuilder {
  typedef EnqueueReadBufferCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_src(::flatbuffers::Offset<tt::target::metal::BufferRef> src) {
    fbb_.AddOffset(EnqueueReadBufferCommand::VT_SRC, src);
  }
  void add_dst(::flatbuffers::Offset<tt::target::metal::BufferRef> dst) {
    fbb_.AddOffset(EnqueueReadBufferCommand::VT_DST, dst);
  }
  explicit EnqueueReadBufferCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EnqueueReadBufferCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EnqueueReadBufferCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EnqueueReadBufferCommand> CreateEnqueueReadBufferCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> src = 0,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> dst = 0) {
  EnqueueReadBufferCommandBuilder builder_(_fbb);
  builder_.add_dst(dst);
  builder_.add_src(src);
  return builder_.Finish();
}
 
struct EnqueueReadBufferCommand::Traits {
  using type = EnqueueReadBufferCommand;
  static auto constexpr Create = CreateEnqueueReadBufferCommand;
};
 
struct CreateBufferCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CreateBufferCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.CreateBufferCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::metal::BufferRef *ref() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_REF) &&
           verifier.VerifyTable(ref()) &&
           verifier.EndTable();
  }
};
 
struct CreateBufferCommandBuilder {
  typedef CreateBufferCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ref(::flatbuffers::Offset<tt::target::metal::BufferRef> ref) {
    fbb_.AddOffset(CreateBufferCommand::VT_REF, ref);
  }
  explicit CreateBufferCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CreateBufferCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CreateBufferCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CreateBufferCommand> CreateCreateBufferCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> ref = 0) {
  CreateBufferCommandBuilder builder_(_fbb);
  builder_.add_ref(ref);
  return builder_.Finish();
}
 
struct CreateBufferCommand::Traits {
  using type = CreateBufferCommand;
  static auto constexpr Create = CreateCreateBufferCommand;
};
 
struct DeallocateBufferCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DeallocateBufferCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.DeallocateBufferCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::metal::BufferRef *ref() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_REF) &&
           verifier.VerifyTable(ref()) &&
           verifier.EndTable();
  }
};
 
struct DeallocateBufferCommandBuilder {
  typedef DeallocateBufferCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ref(::flatbuffers::Offset<tt::target::metal::BufferRef> ref) {
    fbb_.AddOffset(DeallocateBufferCommand::VT_REF, ref);
  }
  explicit DeallocateBufferCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DeallocateBufferCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DeallocateBufferCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<DeallocateBufferCommand> CreateDeallocateBufferCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> ref = 0) {
  DeallocateBufferCommandBuilder builder_(_fbb);
  builder_.add_ref(ref);
  return builder_.Finish();
}
 
struct DeallocateBufferCommand::Traits {
  using type = DeallocateBufferCommand;
  static auto constexpr Create = CreateDeallocateBufferCommand;
};
 
struct CreateEventCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CreateEventCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.CreateEventCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::EventRef *ref() const {
    return GetPointer<const tt::target::EventRef *>(VT_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_REF) &&
           verifier.VerifyTable(ref()) &&
           verifier.EndTable();
  }
};
 
struct CreateEventCommandBuilder {
  typedef CreateEventCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ref(::flatbuffers::Offset<tt::target::EventRef> ref) {
    fbb_.AddOffset(CreateEventCommand::VT_REF, ref);
  }
  explicit CreateEventCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CreateEventCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CreateEventCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CreateEventCommand> CreateCreateEventCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::EventRef> ref = 0) {
  CreateEventCommandBuilder builder_(_fbb);
  builder_.add_ref(ref);
  return builder_.Finish();
}
 
struct CreateEventCommand::Traits {
  using type = CreateEventCommand;
  static auto constexpr Create = CreateCreateEventCommand;
};
 
struct EnqueueRecordEventCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnqueueRecordEventCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.EnqueueRecordEventCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::EventRef *ref() const {
    return GetPointer<const tt::target::EventRef *>(VT_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_REF) &&
           verifier.VerifyTable(ref()) &&
           verifier.EndTable();
  }
};
 
struct EnqueueRecordEventCommandBuilder {
  typedef EnqueueRecordEventCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ref(::flatbuffers::Offset<tt::target::EventRef> ref) {
    fbb_.AddOffset(EnqueueRecordEventCommand::VT_REF, ref);
  }
  explicit EnqueueRecordEventCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EnqueueRecordEventCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EnqueueRecordEventCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EnqueueRecordEventCommand> CreateEnqueueRecordEventCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::EventRef> ref = 0) {
  EnqueueRecordEventCommandBuilder builder_(_fbb);
  builder_.add_ref(ref);
  return builder_.Finish();
}
 
struct EnqueueRecordEventCommand::Traits {
  using type = EnqueueRecordEventCommand;
  static auto constexpr Create = CreateEnqueueRecordEventCommand;
};
 
struct EnqueueWaitForEventCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnqueueWaitForEventCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.EnqueueWaitForEventCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::EventRef *ref() const {
    return GetPointer<const tt::target::EventRef *>(VT_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_REF) &&
           verifier.VerifyTable(ref()) &&
           verifier.EndTable();
  }
};
 
struct EnqueueWaitForEventCommandBuilder {
  typedef EnqueueWaitForEventCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ref(::flatbuffers::Offset<tt::target::EventRef> ref) {
    fbb_.AddOffset(EnqueueWaitForEventCommand::VT_REF, ref);
  }
  explicit EnqueueWaitForEventCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EnqueueWaitForEventCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EnqueueWaitForEventCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EnqueueWaitForEventCommand> CreateEnqueueWaitForEventCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::EventRef> ref = 0) {
  EnqueueWaitForEventCommandBuilder builder_(_fbb);
  builder_.add_ref(ref);
  return builder_.Finish();
}
 
struct EnqueueWaitForEventCommand::Traits {
  using type = EnqueueWaitForEventCommand;
  static auto constexpr Create = CreateEnqueueWaitForEventCommand;
};
 
struct EventSynchronizeCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EventSynchronizeCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.EventSynchronizeCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::EventRef *ref() const {
    return GetPointer<const tt::target::EventRef *>(VT_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_REF) &&
           verifier.VerifyTable(ref()) &&
           verifier.EndTable();
  }
};
 
struct EventSynchronizeCommandBuilder {
  typedef EventSynchronizeCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ref(::flatbuffers::Offset<tt::target::EventRef> ref) {
    fbb_.AddOffset(EventSynchronizeCommand::VT_REF, ref);
  }
  explicit EventSynchronizeCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EventSynchronizeCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EventSynchronizeCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EventSynchronizeCommand> CreateEventSynchronizeCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::EventRef> ref = 0) {
  EventSynchronizeCommandBuilder builder_(_fbb);
  builder_.add_ref(ref);
  return builder_.Finish();
}
 
struct EventSynchronizeCommand::Traits {
  using type = EventSynchronizeCommand;
  static auto constexpr Create = CreateEventSynchronizeCommand;
};
 
struct EventQueryCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EventQueryCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.EventQueryCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::EventRef *ref() const {
    return GetPointer<const tt::target::EventRef *>(VT_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_REF) &&
           verifier.VerifyTable(ref()) &&
           verifier.EndTable();
  }
};
 
struct EventQueryCommandBuilder {
  typedef EventQueryCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ref(::flatbuffers::Offset<tt::target::EventRef> ref) {
    fbb_.AddOffset(EventQueryCommand::VT_REF, ref);
  }
  explicit EventQueryCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EventQueryCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EventQueryCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EventQueryCommand> CreateEventQueryCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::EventRef> ref = 0) {
  EventQueryCommandBuilder builder_(_fbb);
  builder_.add_ref(ref);
  return builder_.Finish();
}
 
struct EventQueryCommand::Traits {
  using type = EventQueryCommand;
  static auto constexpr Create = CreateEventQueryCommand;
};
 
struct MemrefCopyCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MemrefCopyCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.MemrefCopyCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SRC = 4,
    VT_DST = 6
  };
  const tt::target::metal::BufferRef *src() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_SRC);
  }
  const tt::target::metal::BufferRef *dst() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_DST);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SRC) &&
           verifier.VerifyTable(src()) &&
           VerifyOffset(verifier, VT_DST) &&
           verifier.VerifyTable(dst()) &&
           verifier.EndTable();
  }
};
 
struct MemrefCopyCommandBuilder {
  typedef MemrefCopyCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_src(::flatbuffers::Offset<tt::target::metal::BufferRef> src) {
    fbb_.AddOffset(MemrefCopyCommand::VT_SRC, src);
  }
  void add_dst(::flatbuffers::Offset<tt::target::metal::BufferRef> dst) {
    fbb_.AddOffset(MemrefCopyCommand::VT_DST, dst);
  }
  explicit MemrefCopyCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MemrefCopyCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MemrefCopyCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MemrefCopyCommand> CreateMemrefCopyCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> src = 0,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> dst = 0) {
  MemrefCopyCommandBuilder builder_(_fbb);
  builder_.add_dst(dst);
  builder_.add_src(src);
  return builder_.Finish();
}
 
struct MemrefCopyCommand::Traits {
  using type = MemrefCopyCommand;
  static auto constexpr Create = CreateMemrefCopyCommand;
};
 
struct CpuCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CpuCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.CpuCommand";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INS = 4,
    VT_OUT = 6,
    VT_FUNC_NAME = 8,
    VT_DYLIB_ID = 10
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *ins() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *>(VT_INS);
  }
  const tt::target::metal::BufferRef *out() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_OUT);
  }
  const ::flatbuffers::String *func_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_FUNC_NAME);
  }
  uint32_t dylib_id() const {
    return GetField<uint32_t>(VT_DYLIB_ID, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INS) &&
           verifier.VerifyVector(ins()) &&
           verifier.VerifyVectorOfTables(ins()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_FUNC_NAME) &&
           verifier.VerifyString(func_name()) &&
           VerifyField<uint32_t>(verifier, VT_DYLIB_ID, 4) &&
           verifier.EndTable();
  }
};
 
struct CpuCommandBuilder {
  typedef CpuCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ins(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> ins) {
    fbb_.AddOffset(CpuCommand::VT_INS, ins);
  }
  void add_out(::flatbuffers::Offset<tt::target::metal::BufferRef> out) {
    fbb_.AddOffset(CpuCommand::VT_OUT, out);
  }
  void add_func_name(::flatbuffers::Offset<::flatbuffers::String> func_name) {
    fbb_.AddOffset(CpuCommand::VT_FUNC_NAME, func_name);
  }
  void add_dylib_id(uint32_t dylib_id) {
    fbb_.AddElement<uint32_t>(CpuCommand::VT_DYLIB_ID, dylib_id, 0);
  }
  explicit CpuCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CpuCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CpuCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CpuCommand> CreateCpuCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> ins = 0,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::String> func_name = 0,
    uint32_t dylib_id = 0) {
  CpuCommandBuilder builder_(_fbb);
  builder_.add_dylib_id(dylib_id);
  builder_.add_func_name(func_name);
  builder_.add_out(out);
  builder_.add_ins(ins);
  return builder_.Finish();
}
 
struct CpuCommand::Traits {
  using type = CpuCommand;
  static auto constexpr Create = CreateCpuCommand;
};
 
inline ::flatbuffers::Offset<CpuCommand> CreateCpuCommandDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *ins = nullptr,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> out = 0,
    const char *func_name = nullptr,
    uint32_t dylib_id = 0) {
  auto ins__ = ins ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::BufferRef>>(*ins) : 0;
  auto func_name__ = func_name ? _fbb.CreateString(func_name) : 0;
  return tt::target::metal::CreateCpuCommand(
      _fbb,
      ins__,
      out,
      func_name__,
      dylib_id);
}
 
struct FinishCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FinishCommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.FinishCommand";
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};
 
struct FinishCommandBuilder {
  typedef FinishCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit FinishCommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FinishCommand> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FinishCommand>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FinishCommand> CreateFinishCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  FinishCommandBuilder builder_(_fbb);
  return builder_.Finish();
}
 
struct FinishCommand::Traits {
  using type = FinishCommand;
  static auto constexpr Create = CreateFinishCommand;
};
 
struct Command FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CommandBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.Command";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE_TYPE = 4,
    VT_TYPE = 6,
    VT_LOC = 8,
    VT_DEBUG_INFO = 10
  };
  tt::target::metal::CommandType type_type() const {
    return static_cast<tt::target::metal::CommandType>(GetField<uint8_t>(VT_TYPE_TYPE, 0));
  }
  const void *type() const {
    return GetPointer<const void *>(VT_TYPE);
  }
  template<typename T> const T *type_as() const;
  const tt::target::metal::HostAllocCommand *type_as_HostAllocCommand() const {
    return type_type() == tt::target::metal::CommandType::HostAllocCommand ? static_cast<const tt::target::metal::HostAllocCommand *>(type()) : nullptr;
  }
  const tt::target::metal::ReturnCommand *type_as_ReturnCommand() const {
    return type_type() == tt::target::metal::CommandType::ReturnCommand ? static_cast<const tt::target::metal::ReturnCommand *>(type()) : nullptr;
  }
  const tt::target::metal::EnqueueProgramCommand *type_as_EnqueueProgramCommand() const {
    return type_type() == tt::target::metal::CommandType::EnqueueProgramCommand ? static_cast<const tt::target::metal::EnqueueProgramCommand *>(type()) : nullptr;
  }
  const tt::target::metal::EnqueueWriteBufferCommand *type_as_EnqueueWriteBufferCommand() const {
    return type_type() == tt::target::metal::CommandType::EnqueueWriteBufferCommand ? static_cast<const tt::target::metal::EnqueueWriteBufferCommand *>(type()) : nullptr;
  }
  const tt::target::metal::EnqueueReadBufferCommand *type_as_EnqueueReadBufferCommand() const {
    return type_type() == tt::target::metal::CommandType::EnqueueReadBufferCommand ? static_cast<const tt::target::metal::EnqueueReadBufferCommand *>(type()) : nullptr;
  }
  const tt::target::metal::CreateBufferCommand *type_as_CreateBufferCommand() const {
    return type_type() == tt::target::metal::CommandType::CreateBufferCommand ? static_cast<const tt::target::metal::CreateBufferCommand *>(type()) : nullptr;
  }
  const tt::target::metal::DeallocateBufferCommand *type_as_DeallocateBufferCommand() const {
    return type_type() == tt::target::metal::CommandType::DeallocateBufferCommand ? static_cast<const tt::target::metal::DeallocateBufferCommand *>(type()) : nullptr;
  }
  const tt::target::metal::CreateEventCommand *type_as_CreateEventCommand() const {
    return type_type() == tt::target::metal::CommandType::CreateEventCommand ? static_cast<const tt::target::metal::CreateEventCommand *>(type()) : nullptr;
  }
  const tt::target::metal::EnqueueRecordEventCommand *type_as_EnqueueRecordEventCommand() const {
    return type_type() == tt::target::metal::CommandType::EnqueueRecordEventCommand ? static_cast<const tt::target::metal::EnqueueRecordEventCommand *>(type()) : nullptr;
  }
  const tt::target::metal::EnqueueWaitForEventCommand *type_as_EnqueueWaitForEventCommand() const {
    return type_type() == tt::target::metal::CommandType::EnqueueWaitForEventCommand ? static_cast<const tt::target::metal::EnqueueWaitForEventCommand *>(type()) : nullptr;
  }
  const tt::target::metal::EventSynchronizeCommand *type_as_EventSynchronizeCommand() const {
    return type_type() == tt::target::metal::CommandType::EventSynchronizeCommand ? static_cast<const tt::target::metal::EventSynchronizeCommand *>(type()) : nullptr;
  }
  const tt::target::metal::EventQueryCommand *type_as_EventQueryCommand() const {
    return type_type() == tt::target::metal::CommandType::EventQueryCommand ? static_cast<const tt::target::metal::EventQueryCommand *>(type()) : nullptr;
  }
  const tt::target::metal::MemrefCopyCommand *type_as_MemrefCopyCommand() const {
    return type_type() == tt::target::metal::CommandType::MemrefCopyCommand ? static_cast<const tt::target::metal::MemrefCopyCommand *>(type()) : nullptr;
  }
  const tt::target::metal::CpuCommand *type_as_CpuCommand() const {
    return type_type() == tt::target::metal::CommandType::CpuCommand ? static_cast<const tt::target::metal::CpuCommand *>(type()) : nullptr;
  }
  const tt::target::metal::FinishCommand *type_as_FinishCommand() const {
    return type_type() == tt::target::metal::CommandType::FinishCommand ? static_cast<const tt::target::metal::FinishCommand *>(type()) : nullptr;
  }
  const ::flatbuffers::String *loc() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LOC);
  }
  const ::flatbuffers::String *debug_info() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DEBUG_INFO);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE, 1) &&
           VerifyOffset(verifier, VT_TYPE) &&
           VerifyCommandType(verifier, type(), type_type()) &&
           VerifyOffset(verifier, VT_LOC) &&
           verifier.VerifyString(loc()) &&
           VerifyOffset(verifier, VT_DEBUG_INFO) &&
           verifier.VerifyString(debug_info()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::metal::HostAllocCommand *Command::type_as<tt::target::metal::HostAllocCommand>() const {
  return type_as_HostAllocCommand();
}
 
template<> inline const tt::target::metal::ReturnCommand *Command::type_as<tt::target::metal::ReturnCommand>() const {
  return type_as_ReturnCommand();
}
 
template<> inline const tt::target::metal::EnqueueProgramCommand *Command::type_as<tt::target::metal::EnqueueProgramCommand>() const {
  return type_as_EnqueueProgramCommand();
}
 
template<> inline const tt::target::metal::EnqueueWriteBufferCommand *Command::type_as<tt::target::metal::EnqueueWriteBufferCommand>() const {
  return type_as_EnqueueWriteBufferCommand();
}
 
template<> inline const tt::target::metal::EnqueueReadBufferCommand *Command::type_as<tt::target::metal::EnqueueReadBufferCommand>() const {
  return type_as_EnqueueReadBufferCommand();
}
 
template<> inline const tt::target::metal::CreateBufferCommand *Command::type_as<tt::target::metal::CreateBufferCommand>() const {
  return type_as_CreateBufferCommand();
}
 
template<> inline const tt::target::metal::DeallocateBufferCommand *Command::type_as<tt::target::metal::DeallocateBufferCommand>() const {
  return type_as_DeallocateBufferCommand();
}
 
template<> inline const tt::target::metal::CreateEventCommand *Command::type_as<tt::target::metal::CreateEventCommand>() const {
  return type_as_CreateEventCommand();
}
 
template<> inline const tt::target::metal::EnqueueRecordEventCommand *Command::type_as<tt::target::metal::EnqueueRecordEventCommand>() const {
  return type_as_EnqueueRecordEventCommand();
}
 
template<> inline const tt::target::metal::EnqueueWaitForEventCommand *Command::type_as<tt::target::metal::EnqueueWaitForEventCommand>() const {
  return type_as_EnqueueWaitForEventCommand();
}
 
template<> inline const tt::target::metal::EventSynchronizeCommand *Command::type_as<tt::target::metal::EventSynchronizeCommand>() const {
  return type_as_EventSynchronizeCommand();
}
 
template<> inline const tt::target::metal::EventQueryCommand *Command::type_as<tt::target::metal::EventQueryCommand>() const {
  return type_as_EventQueryCommand();
}
 
template<> inline const tt::target::metal::MemrefCopyCommand *Command::type_as<tt::target::metal::MemrefCopyCommand>() const {
  return type_as_MemrefCopyCommand();
}
 
template<> inline const tt::target::metal::CpuCommand *Command::type_as<tt::target::metal::CpuCommand>() const {
  return type_as_CpuCommand();
}
 
template<> inline const tt::target::metal::FinishCommand *Command::type_as<tt::target::metal::FinishCommand>() const {
  return type_as_FinishCommand();
}
 
struct CommandBuilder {
  typedef Command Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type_type(tt::target::metal::CommandType type_type) {
    fbb_.AddElement<uint8_t>(Command::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
  }
  void add_type(::flatbuffers::Offset<void> type) {
    fbb_.AddOffset(Command::VT_TYPE, type);
  }
  void add_loc(::flatbuffers::Offset<::flatbuffers::String> loc) {
    fbb_.AddOffset(Command::VT_LOC, loc);
  }
  void add_debug_info(::flatbuffers::Offset<::flatbuffers::String> debug_info) {
    fbb_.AddOffset(Command::VT_DEBUG_INFO, debug_info);
  }
  explicit CommandBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Command> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Command>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Command> CreateCommand(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::metal::CommandType type_type = tt::target::metal::CommandType::NONE,
    ::flatbuffers::Offset<void> type = 0,
    ::flatbuffers::Offset<::flatbuffers::String> loc = 0,
    ::flatbuffers::Offset<::flatbuffers::String> debug_info = 0) {
  CommandBuilder builder_(_fbb);
  builder_.add_debug_info(debug_info);
  builder_.add_loc(loc);
  builder_.add_type(type);
  builder_.add_type_type(type_type);
  return builder_.Finish();
}
 
struct Command::Traits {
  using type = Command;
  static auto constexpr Create = CreateCommand;
};
 
inline ::flatbuffers::Offset<Command> CreateCommandDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::metal::CommandType type_type = tt::target::metal::CommandType::NONE,
    ::flatbuffers::Offset<void> type = 0,
    const char *loc = nullptr,
    const char *debug_info = nullptr) {
  auto loc__ = loc ? _fbb.CreateString(loc) : 0;
  auto debug_info__ = debug_info ? _fbb.CreateString(debug_info) : 0;
  return tt::target::metal::CreateCommand(
      _fbb,
      type_type,
      type,
      loc__,
      debug_info__);
}
 
struct CommandQueue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CommandQueueBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.CommandQueue";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_QUEUE_ID = 6,
    VT_COMMANDS = 8
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  uint32_t queue_id() const {
    return GetField<uint32_t>(VT_QUEUE_ID, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Command>> *commands() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Command>> *>(VT_COMMANDS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint32_t>(verifier, VT_QUEUE_ID, 4) &&
           VerifyOffset(verifier, VT_COMMANDS) &&
           verifier.VerifyVector(commands()) &&
           verifier.VerifyVectorOfTables(commands()) &&
           verifier.EndTable();
  }
};
 
struct CommandQueueBuilder {
  typedef CommandQueue Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(CommandQueue::VT_NAME, name);
  }
  void add_queue_id(uint32_t queue_id) {
    fbb_.AddElement<uint32_t>(CommandQueue::VT_QUEUE_ID, queue_id, 0);
  }
  void add_commands(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Command>>> commands) {
    fbb_.AddOffset(CommandQueue::VT_COMMANDS, commands);
  }
  explicit CommandQueueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CommandQueue> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CommandQueue>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CommandQueue> CreateCommandQueue(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    uint32_t queue_id = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Command>>> commands = 0) {
  CommandQueueBuilder builder_(_fbb);
  builder_.add_commands(commands);
  builder_.add_queue_id(queue_id);
  builder_.add_name(name);
  return builder_.Finish();
}
 
struct CommandQueue::Traits {
  using type = CommandQueue;
  static auto constexpr Create = CreateCommandQueue;
};
 
inline ::flatbuffers::Offset<CommandQueue> CreateCommandQueueDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    uint32_t queue_id = 0,
    const std::vector<::flatbuffers::Offset<tt::target::metal::Command>> *commands = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto commands__ = commands ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::Command>>(*commands) : 0;
  return tt::target::metal::CreateCommandQueue(
      _fbb,
      name__,
      queue_id,
      commands__);
}
 
inline bool VerifyCommandType(::flatbuffers::Verifier &verifier, const void *obj, CommandType type) {
  switch (type) {
    case CommandType::NONE: {
      return true;
    }
    case CommandType::HostAllocCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::HostAllocCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::ReturnCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::ReturnCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::EnqueueProgramCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::EnqueueProgramCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::EnqueueWriteBufferCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::EnqueueWriteBufferCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::EnqueueReadBufferCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::EnqueueReadBufferCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::CreateBufferCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::CreateBufferCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::DeallocateBufferCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::DeallocateBufferCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::CreateEventCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::CreateEventCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::EnqueueRecordEventCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::EnqueueRecordEventCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::EnqueueWaitForEventCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::EnqueueWaitForEventCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::EventSynchronizeCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::EventSynchronizeCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::EventQueryCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::EventQueryCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::MemrefCopyCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::MemrefCopyCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::CpuCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::CpuCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CommandType::FinishCommand: {
      auto ptr = reinterpret_cast<const tt::target::metal::FinishCommand *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyCommandTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<CommandType> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyCommandType(
        verifier,  values->Get(i), types->GetEnum<CommandType>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace metal
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_COMMAND_TT_TARGET_METAL_H_