creation_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_CREATION_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_CREATION_TT_TARGET_TTNN_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/Common/types_generated.h"
#include "ttmlir/Target/TTNN/types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct ArangeOp;
struct ArangeOpBuilder;
 
struct ConstantOp;
struct ConstantOpBuilder;
 
struct EmptyOp;
struct EmptyOpBuilder;
 
struct FloatingPointType;
struct FloatingPointTypeBuilder;
 
struct IntegralType;
struct IntegralTypeBuilder;
 
struct FullOp;
struct FullOpBuilder;
 
struct NamedFullOp;
struct NamedFullOpBuilder;
 
enum class FillValueType : uint8_t {
  NONE = 0,
  FP = 1,
  I32 = 2,
  MIN = NONE,
  MAX = I32
};
 
inline const FillValueType (&EnumValuesFillValueType())[3] {
  static const FillValueType values[] = {
    FillValueType::NONE,
    FillValueType::FP,
    FillValueType::I32
  };
  return values;
}
 
inline const char * const *EnumNamesFillValueType() {
  static const char * const names[4] = {
    "NONE",
    "FP",
    "I32",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameFillValueType(FillValueType e) {
  if (::flatbuffers::IsOutRange(e, FillValueType::NONE, FillValueType::I32)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesFillValueType()[index];
}
 
template<typename T> struct FillValueTypeTraits {
  static const FillValueType enum_value = FillValueType::NONE;
};
 
template<> struct FillValueTypeTraits<tt::target::ttnn::FloatingPointType> {
  static const FillValueType enum_value = FillValueType::FP;
};
 
template<> struct FillValueTypeTraits<tt::target::ttnn::IntegralType> {
  static const FillValueType enum_value = FillValueType::I32;
};
 
bool VerifyFillValueType(::flatbuffers::Verifier &verifier, const void *obj, FillValueType type);
bool VerifyFillValueTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<FillValueType> *types);
 
enum class NamedFullOpType : uint32_t {
  Zeros = 0,
  Ones = 1,
  MIN = Zeros,
  MAX = Ones
};
 
inline const NamedFullOpType (&EnumValuesNamedFullOpType())[2] {
  static const NamedFullOpType values[] = {
    NamedFullOpType::Zeros,
    NamedFullOpType::Ones
  };
  return values;
}
 
inline const char * const *EnumNamesNamedFullOpType() {
  static const char * const names[3] = {
    "Zeros",
    "Ones",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameNamedFullOpType(NamedFullOpType e) {
  if (::flatbuffers::IsOutRange(e, NamedFullOpType::Zeros, NamedFullOpType::Ones)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesNamedFullOpType()[index];
}
 
struct ArangeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ArangeOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ArangeOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_START = 4,
    VT_END = 6,
    VT_STEP = 8,
    VT_DTYPE = 10,
    VT_DEVICE = 12,
    VT_MEMCFG = 14,
    VT_OUT = 16
  };
  float start() const {
    return GetField<float>(VT_START, 0.0f);
  }
  float end() const {
    return GetField<float>(VT_END, 0.0f);
  }
  float step() const {
    return GetField<float>(VT_STEP, 0.0f);
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_START, 4) &&
           VerifyField<float>(verifier, VT_END, 4) &&
           VerifyField<float>(verifier, VT_STEP, 4) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ArangeOpBuilder {
  typedef ArangeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_start(float start) {
    fbb_.AddElement<float>(ArangeOp::VT_START, start, 0.0f);
  }
  void add_end(float end) {
    fbb_.AddElement<float>(ArangeOp::VT_END, end, 0.0f);
  }
  void add_step(float step) {
    fbb_.AddElement<float>(ArangeOp::VT_STEP, step, 0.0f);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(ArangeOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ArangeOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(ArangeOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ArangeOp::VT_OUT, out);
  }
  explicit ArangeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ArangeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ArangeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ArangeOp> CreateArangeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float start = 0.0f,
    float end = 0.0f,
    float step = 0.0f,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  ArangeOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_step(step);
  builder_.add_end(end);
  builder_.add_start(start);
  if(dtype) { builder_.add_dtype(*dtype); }
  return builder_.Finish();
}
 
struct ArangeOp::Traits {
  using type = ArangeOp;
  static auto constexpr Create = CreateArangeOp;
};
 
struct ConstantOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConstantOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ConstantOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OUT = 4,
    VT_DATA = 6
  };
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  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_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};
 
struct ConstantOpBuilder {
  typedef ConstantOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ConstantOp::VT_OUT, out);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(ConstantOp::VT_DATA, data);
  }
  explicit ConstantOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConstantOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConstantOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConstantOp> CreateConstantOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
  ConstantOpBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_out(out);
  return builder_.Finish();
}
 
struct ConstantOp::Traits {
  using type = ConstantOp;
  static auto constexpr Create = CreateConstantOp;
};
 
inline ::flatbuffers::Offset<ConstantOp> CreateConstantOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return tt::target::ttnn::CreateConstantOp(
      _fbb,
      out,
      data__);
}
 
struct EmptyOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EmptyOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EmptyOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_DTYPE = 6,
    VT_LAYOUT = 8,
    VT_DEVICE = 10,
    VT_MEMCFG = 12,
    VT_OUT = 14
  };
  const ::flatbuffers::Vector<int64_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SHAPE);
  }
  tt::target::DataType dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DTYPE, 0));
  }
  tt::target::TensorLayout layout() const {
    return static_cast<tt::target::TensorLayout>(GetField<uint16_t>(VT_LAYOUT, 0));
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyField<uint16_t>(verifier, VT_LAYOUT, 2) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EmptyOpBuilder {
  typedef EmptyOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape) {
    fbb_.AddOffset(EmptyOp::VT_SHAPE, shape);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(EmptyOp::VT_DTYPE, static_cast<uint16_t>(dtype), 0);
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(EmptyOp::VT_LAYOUT, static_cast<uint16_t>(layout), 0);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(EmptyOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(EmptyOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EmptyOp::VT_OUT, out);
  }
  explicit EmptyOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EmptyOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EmptyOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EmptyOp> CreateEmptyOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape = 0,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  EmptyOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_shape(shape);
  builder_.add_layout(layout);
  builder_.add_dtype(dtype);
  return builder_.Finish();
}
 
struct EmptyOp::Traits {
  using type = EmptyOp;
  static auto constexpr Create = CreateEmptyOp;
};
 
inline ::flatbuffers::Offset<EmptyOp> CreateEmptyOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *shape = nullptr,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int64_t>(*shape) : 0;
  return tt::target::ttnn::CreateEmptyOp(
      _fbb,
      shape__,
      dtype,
      layout,
      device,
      memcfg,
      out);
}
 
struct FloatingPointType FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FloatingPointTypeBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.FloatingPointType";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUE = 4
  };
  float value() const {
    return GetField<float>(VT_VALUE, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_VALUE, 4) &&
           verifier.EndTable();
  }
};
 
struct FloatingPointTypeBuilder {
  typedef FloatingPointType Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_value(float value) {
    fbb_.AddElement<float>(FloatingPointType::VT_VALUE, value, 0.0f);
  }
  explicit FloatingPointTypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FloatingPointType> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FloatingPointType>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FloatingPointType> CreateFloatingPointType(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float value = 0.0f) {
  FloatingPointTypeBuilder builder_(_fbb);
  builder_.add_value(value);
  return builder_.Finish();
}
 
struct FloatingPointType::Traits {
  using type = FloatingPointType;
  static auto constexpr Create = CreateFloatingPointType;
};
 
struct IntegralType FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef IntegralTypeBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.IntegralType";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUE = 4
  };
  int32_t value() const {
    return GetField<int32_t>(VT_VALUE, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_VALUE, 4) &&
           verifier.EndTable();
  }
};
 
struct IntegralTypeBuilder {
  typedef IntegralType Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_value(int32_t value) {
    fbb_.AddElement<int32_t>(IntegralType::VT_VALUE, value, 0);
  }
  explicit IntegralTypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<IntegralType> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<IntegralType>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<IntegralType> CreateIntegralType(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t value = 0) {
  IntegralTypeBuilder builder_(_fbb);
  builder_.add_value(value);
  return builder_.Finish();
}
 
struct IntegralType::Traits {
  using type = IntegralType;
  static auto constexpr Create = CreateIntegralType;
};
 
struct FullOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FullOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.FullOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_FILL_VALUE_TYPE = 6,
    VT_FILL_VALUE = 8,
    VT_DTYPE = 10,
    VT_LAYOUT = 12,
    VT_DEVICE = 14,
    VT_MEMCFG = 16,
    VT_OUT = 18
  };
  const ::flatbuffers::Vector<int64_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SHAPE);
  }
  tt::target::ttnn::FillValueType fill_value_type() const {
    return static_cast<tt::target::ttnn::FillValueType>(GetField<uint8_t>(VT_FILL_VALUE_TYPE, 0));
  }
  const void *fill_value() const {
    return GetPointer<const void *>(VT_FILL_VALUE);
  }
  template<typename T> const T *fill_value_as() const;
  const tt::target::ttnn::FloatingPointType *fill_value_as_FP() const {
    return fill_value_type() == tt::target::ttnn::FillValueType::FP ? static_cast<const tt::target::ttnn::FloatingPointType *>(fill_value()) : nullptr;
  }
  const tt::target::ttnn::IntegralType *fill_value_as_I32() const {
    return fill_value_type() == tt::target::ttnn::FillValueType::I32 ? static_cast<const tt::target::ttnn::IntegralType *>(fill_value()) : nullptr;
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  ::flatbuffers::Optional<tt::target::TensorLayout> layout() const {
    return GetOptional<uint16_t, tt::target::TensorLayout>(VT_LAYOUT);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<uint8_t>(verifier, VT_FILL_VALUE_TYPE, 1) &&
           VerifyOffset(verifier, VT_FILL_VALUE) &&
           VerifyFillValueType(verifier, fill_value(), fill_value_type()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyField<uint16_t>(verifier, VT_LAYOUT, 2) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::FloatingPointType *FullOp::fill_value_as<tt::target::ttnn::FloatingPointType>() const {
  return fill_value_as_FP();
}
 
template<> inline const tt::target::ttnn::IntegralType *FullOp::fill_value_as<tt::target::ttnn::IntegralType>() const {
  return fill_value_as_I32();
}
 
struct FullOpBuilder {
  typedef FullOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape) {
    fbb_.AddOffset(FullOp::VT_SHAPE, shape);
  }
  void add_fill_value_type(tt::target::ttnn::FillValueType fill_value_type) {
    fbb_.AddElement<uint8_t>(FullOp::VT_FILL_VALUE_TYPE, static_cast<uint8_t>(fill_value_type), 0);
  }
  void add_fill_value(::flatbuffers::Offset<void> fill_value) {
    fbb_.AddOffset(FullOp::VT_FILL_VALUE, fill_value);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(FullOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(FullOp::VT_LAYOUT, static_cast<uint16_t>(layout));
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(FullOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(FullOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(FullOp::VT_OUT, out);
  }
  explicit FullOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FullOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FullOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FullOp> CreateFullOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape = 0,
    tt::target::ttnn::FillValueType fill_value_type = tt::target::ttnn::FillValueType::NONE,
    ::flatbuffers::Offset<void> fill_value = 0,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<tt::target::TensorLayout> layout = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  FullOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_fill_value(fill_value);
  builder_.add_shape(shape);
  if(layout) { builder_.add_layout(*layout); }
  if(dtype) { builder_.add_dtype(*dtype); }
  builder_.add_fill_value_type(fill_value_type);
  return builder_.Finish();
}
 
struct FullOp::Traits {
  using type = FullOp;
  static auto constexpr Create = CreateFullOp;
};
 
inline ::flatbuffers::Offset<FullOp> CreateFullOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *shape = nullptr,
    tt::target::ttnn::FillValueType fill_value_type = tt::target::ttnn::FillValueType::NONE,
    ::flatbuffers::Offset<void> fill_value = 0,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<tt::target::TensorLayout> layout = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int64_t>(*shape) : 0;
  return tt::target::ttnn::CreateFullOp(
      _fbb,
      shape__,
      fill_value_type,
      fill_value,
      dtype,
      layout,
      device,
      memcfg,
      out);
}
 
struct NamedFullOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NamedFullOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.NamedFullOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_SHAPE = 6,
    VT_DTYPE = 8,
    VT_LAYOUT = 10,
    VT_DEVICE = 12,
    VT_MEMCFG = 14,
    VT_OUT = 16
  };
  tt::target::ttnn::NamedFullOpType type() const {
    return static_cast<tt::target::ttnn::NamedFullOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const ::flatbuffers::Vector<int64_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SHAPE);
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  ::flatbuffers::Optional<tt::target::TensorLayout> layout() const {
    return GetOptional<uint16_t, tt::target::TensorLayout>(VT_LAYOUT);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyField<uint16_t>(verifier, VT_LAYOUT, 2) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct NamedFullOpBuilder {
  typedef NamedFullOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::NamedFullOpType type) {
    fbb_.AddElement<uint32_t>(NamedFullOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape) {
    fbb_.AddOffset(NamedFullOp::VT_SHAPE, shape);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(NamedFullOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(NamedFullOp::VT_LAYOUT, static_cast<uint16_t>(layout));
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(NamedFullOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(NamedFullOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(NamedFullOp::VT_OUT, out);
  }
  explicit NamedFullOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NamedFullOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NamedFullOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<NamedFullOp> CreateNamedFullOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::NamedFullOpType type = tt::target::ttnn::NamedFullOpType::Zeros,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape = 0,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<tt::target::TensorLayout> layout = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  NamedFullOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_shape(shape);
  builder_.add_type(type);
  if(layout) { builder_.add_layout(*layout); }
  if(dtype) { builder_.add_dtype(*dtype); }
  return builder_.Finish();
}
 
struct NamedFullOp::Traits {
  using type = NamedFullOp;
  static auto constexpr Create = CreateNamedFullOp;
};
 
inline ::flatbuffers::Offset<NamedFullOp> CreateNamedFullOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::NamedFullOpType type = tt::target::ttnn::NamedFullOpType::Zeros,
    const std::vector<int64_t> *shape = nullptr,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<tt::target::TensorLayout> layout = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int64_t>(*shape) : 0;
  return tt::target::ttnn::CreateNamedFullOp(
      _fbb,
      type,
      shape__,
      dtype,
      layout,
      device,
      memcfg,
      out);
}
 
inline bool VerifyFillValueType(::flatbuffers::Verifier &verifier, const void *obj, FillValueType type) {
  switch (type) {
    case FillValueType::NONE: {
      return true;
    }
    case FillValueType::FP: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::FloatingPointType *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case FillValueType::I32: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::IntegralType *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyFillValueTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<FillValueType> *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 (!VerifyFillValueType(
        verifier,  values->Get(i), types->GetEnum<FillValueType>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_CREATION_TT_TARGET_TTNN_H_