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 "program_generated.h"
 
namespace tt {
namespace target {
namespace metal {
 
struct EnqueueProgramCommand;
struct EnqueueProgramCommandBuilder;
 
struct ConstantBuffer8;
struct ConstantBuffer8Builder;
 
struct ConstantBuffer16;
struct ConstantBuffer16Builder;
 
struct ConstantBuffer32;
struct ConstantBuffer32Builder;
 
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 FinishCommand;
struct FinishCommandBuilder;
 
struct Command;
struct CommandBuilder;
 
struct CommandQueue;
struct CommandQueueBuilder;
 
enum class HostBuffer : uint8_t {
  NONE = 0,
  TensorRef = 1,
  ConstantBuffer8 = 2,
  ConstantBuffer16 = 3,
  ConstantBuffer32 = 4,
  MIN = NONE,
  MAX = ConstantBuffer32
};
 
inline const HostBuffer (&EnumValuesHostBuffer())[5] {
  static const HostBuffer values[] = {
    HostBuffer::NONE,
    HostBuffer::TensorRef,
    HostBuffer::ConstantBuffer8,
    HostBuffer::ConstantBuffer16,
    HostBuffer::ConstantBuffer32
  };
  return values;
}
 
inline const char * const *EnumNamesHostBuffer() {
  static const char * const names[6] = {
    "NONE",
    "TensorRef",
    "ConstantBuffer8",
    "ConstantBuffer16",
    "ConstantBuffer32",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameHostBuffer(HostBuffer e) {
  if (::flatbuffers::IsOutRange(e, HostBuffer::NONE, HostBuffer::ConstantBuffer32)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesHostBuffer()[index];
}
 
template<typename T> struct HostBufferTraits {
  static const HostBuffer enum_value = HostBuffer::NONE;
};
 
template<> struct HostBufferTraits<tt::target::TensorRef> {
  static const HostBuffer enum_value = HostBuffer::TensorRef;
};
 
template<> struct HostBufferTraits<tt::target::metal::ConstantBuffer8> {
  static const HostBuffer enum_value = HostBuffer::ConstantBuffer8;
};
 
template<> struct HostBufferTraits<tt::target::metal::ConstantBuffer16> {
  static const HostBuffer enum_value = HostBuffer::ConstantBuffer16;
};
 
template<> struct HostBufferTraits<tt::target::metal::ConstantBuffer32> {
  static const HostBuffer enum_value = HostBuffer::ConstantBuffer32;
};
 
bool VerifyHostBuffer(::flatbuffers::Verifier &verifier, const void *obj, HostBuffer type);
bool VerifyHostBufferVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<HostBuffer> *types);
 
enum class CommandType : uint8_t {
  NONE = 0,
  EnqueueProgramCommand = 1,
  EnqueueWriteBufferCommand = 2,
  EnqueueReadBufferCommand = 3,
  CreateBufferCommand = 4,
  DeallocateBufferCommand = 5,
  CreateEventCommand = 6,
  EnqueueRecordEventCommand = 7,
  EnqueueWaitForEventCommand = 8,
  EventSynchronizeCommand = 9,
  EventQueryCommand = 10,
  FinishCommand = 11,
  MIN = NONE,
  MAX = FinishCommand
};
 
inline const CommandType (&EnumValuesCommandType())[12] {
  static const CommandType values[] = {
    CommandType::NONE,
    CommandType::EnqueueProgramCommand,
    CommandType::EnqueueWriteBufferCommand,
    CommandType::EnqueueReadBufferCommand,
    CommandType::CreateBufferCommand,
    CommandType::DeallocateBufferCommand,
    CommandType::CreateEventCommand,
    CommandType::EnqueueRecordEventCommand,
    CommandType::EnqueueWaitForEventCommand,
    CommandType::EventSynchronizeCommand,
    CommandType::EventQueryCommand,
    CommandType::FinishCommand
  };
  return values;
}
 
inline const char * const *EnumNamesCommandType() {
  static const char * const names[13] = {
    "NONE",
    "EnqueueProgramCommand",
    "EnqueueWriteBufferCommand",
    "EnqueueReadBufferCommand",
    "CreateBufferCommand",
    "DeallocateBufferCommand",
    "CreateEventCommand",
    "EnqueueRecordEventCommand",
    "EnqueueWaitForEventCommand",
    "EventSynchronizeCommand",
    "EventQueryCommand",
    "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::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::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 EnqueueProgramCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnqueueProgramCommandBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OPERANDS = 4,
    VT_PROGRAM = 6
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *operands() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *>(VT_OPERANDS);
  }
  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_OPERANDS) &&
           verifier.VerifyVector(operands()) &&
           verifier.VerifyVectorOfTables(operands()) &&
           VerifyOffset(verifier, VT_PROGRAM) &&
           verifier.VerifyTable(program()) &&
           verifier.EndTable();
  }
};
 
struct EnqueueProgramCommandBuilder {
  typedef EnqueueProgramCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_operands(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>>> operands) {
    fbb_.AddOffset(EnqueueProgramCommand::VT_OPERANDS, operands);
  }
  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::TensorRef>>> operands = 0,
    ::flatbuffers::Offset<tt::target::metal::ProgramDesc> program = 0) {
  EnqueueProgramCommandBuilder builder_(_fbb);
  builder_.add_program(program);
  builder_.add_operands(operands);
  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::TensorRef>> *operands = nullptr,
    ::flatbuffers::Offset<tt::target::metal::ProgramDesc> program = 0) {
  auto operands__ = operands ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::TensorRef>>(*operands) : 0;
  return tt::target::metal::CreateEnqueueProgramCommand(
      _fbb,
      operands__,
      program);
}
 
struct ConstantBuffer8 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConstantBuffer8Builder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  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_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};
 
struct ConstantBuffer8Builder {
  typedef ConstantBuffer8 Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(ConstantBuffer8::VT_DATA, data);
  }
  explicit ConstantBuffer8Builder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConstantBuffer8> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConstantBuffer8>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConstantBuffer8> CreateConstantBuffer8(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
  ConstantBuffer8Builder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}
 
struct ConstantBuffer8::Traits {
  using type = ConstantBuffer8;
  static auto constexpr Create = CreateConstantBuffer8;
};
 
inline ::flatbuffers::Offset<ConstantBuffer8> CreateConstantBuffer8Direct(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return tt::target::metal::CreateConstantBuffer8(
      _fbb,
      data__);
}
 
struct ConstantBuffer16 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConstantBuffer16Builder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  const ::flatbuffers::Vector<uint16_t> *data() const {
    return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};
 
struct ConstantBuffer16Builder {
  typedef ConstantBuffer16 Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> data) {
    fbb_.AddOffset(ConstantBuffer16::VT_DATA, data);
  }
  explicit ConstantBuffer16Builder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConstantBuffer16> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConstantBuffer16>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConstantBuffer16> CreateConstantBuffer16(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> data = 0) {
  ConstantBuffer16Builder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}
 
struct ConstantBuffer16::Traits {
  using type = ConstantBuffer16;
  static auto constexpr Create = CreateConstantBuffer16;
};
 
inline ::flatbuffers::Offset<ConstantBuffer16> CreateConstantBuffer16Direct(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint16_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint16_t>(*data) : 0;
  return tt::target::metal::CreateConstantBuffer16(
      _fbb,
      data__);
}
 
struct ConstantBuffer32 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConstantBuffer32Builder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  const ::flatbuffers::Vector<uint32_t> *data() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};
 
struct ConstantBuffer32Builder {
  typedef ConstantBuffer32 Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> data) {
    fbb_.AddOffset(ConstantBuffer32::VT_DATA, data);
  }
  explicit ConstantBuffer32Builder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConstantBuffer32> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConstantBuffer32>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConstantBuffer32> CreateConstantBuffer32(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> data = 0) {
  ConstantBuffer32Builder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}
 
struct ConstantBuffer32::Traits {
  using type = ConstantBuffer32;
  static auto constexpr Create = CreateConstantBuffer32;
};
 
inline ::flatbuffers::Offset<ConstantBuffer32> CreateConstantBuffer32Direct(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint32_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint32_t>(*data) : 0;
  return tt::target::metal::CreateConstantBuffer32(
      _fbb,
      data__);
}
 
struct EnqueueWriteBufferCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnqueueWriteBufferCommandBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SRC_TYPE = 4,
    VT_SRC = 6,
    VT_DST = 8
  };
  tt::target::metal::HostBuffer src_type() const {
    return static_cast<tt::target::metal::HostBuffer>(GetField<uint8_t>(VT_SRC_TYPE, 0));
  }
  const void *src() const {
    return GetPointer<const void *>(VT_SRC);
  }
  template<typename T> const T *src_as() const;
  const tt::target::TensorRef *src_as_TensorRef() const {
    return src_type() == tt::target::metal::HostBuffer::TensorRef ? static_cast<const tt::target::TensorRef *>(src()) : nullptr;
  }
  const tt::target::metal::ConstantBuffer8 *src_as_ConstantBuffer8() const {
    return src_type() == tt::target::metal::HostBuffer::ConstantBuffer8 ? static_cast<const tt::target::metal::ConstantBuffer8 *>(src()) : nullptr;
  }
  const tt::target::metal::ConstantBuffer16 *src_as_ConstantBuffer16() const {
    return src_type() == tt::target::metal::HostBuffer::ConstantBuffer16 ? static_cast<const tt::target::metal::ConstantBuffer16 *>(src()) : nullptr;
  }
  const tt::target::metal::ConstantBuffer32 *src_as_ConstantBuffer32() const {
    return src_type() == tt::target::metal::HostBuffer::ConstantBuffer32 ? static_cast<const tt::target::metal::ConstantBuffer32 *>(src()) : nullptr;
  }
  const tt::target::TensorRef *dst() const {
    return GetPointer<const tt::target::TensorRef *>(VT_DST);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SRC_TYPE, 1) &&
           VerifyOffset(verifier, VT_SRC) &&
           VerifyHostBuffer(verifier, src(), src_type()) &&
           VerifyOffset(verifier, VT_DST) &&
           verifier.VerifyTable(dst()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::TensorRef *EnqueueWriteBufferCommand::src_as<tt::target::TensorRef>() const {
  return src_as_TensorRef();
}
 
template<> inline const tt::target::metal::ConstantBuffer8 *EnqueueWriteBufferCommand::src_as<tt::target::metal::ConstantBuffer8>() const {
  return src_as_ConstantBuffer8();
}
 
template<> inline const tt::target::metal::ConstantBuffer16 *EnqueueWriteBufferCommand::src_as<tt::target::metal::ConstantBuffer16>() const {
  return src_as_ConstantBuffer16();
}
 
template<> inline const tt::target::metal::ConstantBuffer32 *EnqueueWriteBufferCommand::src_as<tt::target::metal::ConstantBuffer32>() const {
  return src_as_ConstantBuffer32();
}
 
struct EnqueueWriteBufferCommandBuilder {
  typedef EnqueueWriteBufferCommand Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_src_type(tt::target::metal::HostBuffer src_type) {
    fbb_.AddElement<uint8_t>(EnqueueWriteBufferCommand::VT_SRC_TYPE, static_cast<uint8_t>(src_type), 0);
  }
  void add_src(::flatbuffers::Offset<void> src) {
    fbb_.AddOffset(EnqueueWriteBufferCommand::VT_SRC, src);
  }
  void add_dst(::flatbuffers::Offset<tt::target::TensorRef> 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,
    tt::target::metal::HostBuffer src_type = tt::target::metal::HostBuffer::NONE,
    ::flatbuffers::Offset<void> src = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> dst = 0) {
  EnqueueWriteBufferCommandBuilder builder_(_fbb);
  builder_.add_dst(dst);
  builder_.add_src(src);
  builder_.add_src_type(src_type);
  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;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SRC = 4,
    VT_DST = 6
  };
  const tt::target::TensorRef *src() const {
    return GetPointer<const tt::target::TensorRef *>(VT_SRC);
  }
  const tt::target::TensorRef *dst() const {
    return GetPointer<const tt::target::TensorRef *>(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::TensorRef> src) {
    fbb_.AddOffset(EnqueueReadBufferCommand::VT_SRC, src);
  }
  void add_dst(::flatbuffers::Offset<tt::target::TensorRef> 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::TensorRef> src = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> 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;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::TensorRef *ref() const {
    return GetPointer<const tt::target::TensorRef *>(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::TensorRef> 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::TensorRef> 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;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REF = 4
  };
  const tt::target::TensorRef *ref() const {
    return GetPointer<const tt::target::TensorRef *>(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::TensorRef> 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::TensorRef> 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;
  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;
  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;
  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;
  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;
  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 FinishCommand FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FinishCommandBuilder Builder;
  struct Traits;
  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;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE_TYPE = 4,
    VT_TYPE = 6,
    VT_DEBUG_INFO = 8
  };
  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::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::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 *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_DEBUG_INFO) &&
           verifier.VerifyString(debug_info()) &&
           verifier.EndTable();
  }
};
 
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::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_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> debug_info = 0) {
  CommandBuilder builder_(_fbb);
  builder_.add_debug_info(debug_info);
  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 *debug_info = nullptr) {
  auto debug_info__ = debug_info ? _fbb.CreateString(debug_info) : 0;
  return tt::target::metal::CreateCommand(
      _fbb,
      type_type,
      type,
      debug_info__);
}
 
struct CommandQueue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CommandQueueBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_COMMANDS = 6
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  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()) &&
           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_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,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Command>>> commands = 0) {
  CommandQueueBuilder builder_(_fbb);
  builder_.add_commands(commands);
  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,
    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__,
      commands__);
}
 
inline bool VerifyHostBuffer(::flatbuffers::Verifier &verifier, const void *obj, HostBuffer type) {
  switch (type) {
    case HostBuffer::NONE: {
      return true;
    }
    case HostBuffer::TensorRef: {
      auto ptr = reinterpret_cast<const tt::target::TensorRef *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case HostBuffer::ConstantBuffer8: {
      auto ptr = reinterpret_cast<const tt::target::metal::ConstantBuffer8 *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case HostBuffer::ConstantBuffer16: {
      auto ptr = reinterpret_cast<const tt::target::metal::ConstantBuffer16 *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case HostBuffer::ConstantBuffer32: {
      auto ptr = reinterpret_cast<const tt::target::metal::ConstantBuffer32 *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyHostBufferVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<HostBuffer> *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 (!VerifyHostBuffer(
        verifier,  values->Get(i), types->GetEnum<HostBuffer>(i))) {
      return false;
    }
  }
  return true;
}
 
inline bool VerifyCommandType(::flatbuffers::Verifier &verifier, const void *obj, CommandType type) {
  switch (type) {
    case CommandType::NONE: {
      return true;
    }
    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::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_