load_cached_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_LOADCACHED_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_LOADCACHED_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 LoadCachedOp;
struct LoadCachedOpBuilder;
 
struct LoadCachedOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LoadCachedOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.LoadCachedOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUTS = 4,
    VT_CALLEE_NAME = 6,
    VT_PROGRAM_IDX = 8,
    VT_OUTPUTS = 10
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *>(VT_INPUTS);
  }
  const ::flatbuffers::String *callee_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CALLEE_NAME);
  }
  uint32_t program_idx() const {
    return GetField<uint32_t>(VT_PROGRAM_IDX, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *>(VT_OUTPUTS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           VerifyOffset(verifier, VT_CALLEE_NAME) &&
           verifier.VerifyString(callee_name()) &&
           VerifyField<uint32_t>(verifier, VT_PROGRAM_IDX, 4) &&
           VerifyOffset(verifier, VT_OUTPUTS) &&
           verifier.VerifyVector(outputs()) &&
           verifier.VerifyVectorOfTables(outputs()) &&
           verifier.EndTable();
  }
};
 
struct LoadCachedOpBuilder {
  typedef LoadCachedOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> inputs) {
    fbb_.AddOffset(LoadCachedOp::VT_INPUTS, inputs);
  }
  void add_callee_name(::flatbuffers::Offset<::flatbuffers::String> callee_name) {
    fbb_.AddOffset(LoadCachedOp::VT_CALLEE_NAME, callee_name);
  }
  void add_program_idx(uint32_t program_idx) {
    fbb_.AddElement<uint32_t>(LoadCachedOp::VT_PROGRAM_IDX, program_idx, 0);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> outputs) {
    fbb_.AddOffset(LoadCachedOp::VT_OUTPUTS, outputs);
  }
  explicit LoadCachedOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LoadCachedOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LoadCachedOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<LoadCachedOp> CreateLoadCachedOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::String> callee_name = 0,
    uint32_t program_idx = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> outputs = 0) {
  LoadCachedOpBuilder builder_(_fbb);
  builder_.add_outputs(outputs);
  builder_.add_program_idx(program_idx);
  builder_.add_callee_name(callee_name);
  builder_.add_inputs(inputs);
  return builder_.Finish();
}
 
struct LoadCachedOp::Traits {
  using type = LoadCachedOp;
  static auto constexpr Create = CreateLoadCachedOp;
};
 
inline ::flatbuffers::Offset<LoadCachedOp> CreateLoadCachedOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *inputs = nullptr,
    const char *callee_name = nullptr,
    uint32_t program_idx = 0,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *outputs = nullptr) {
  auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>(*inputs) : 0;
  auto callee_name__ = callee_name ? _fbb.CreateString(callee_name) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>(*outputs) : 0;
  return tt::target::ttnn::CreateLoadCachedOp(
      _fbb,
      inputs__,
      callee_name__,
      program_idx,
      outputs__);
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_LOADCACHED_TT_TARGET_TTNN_H_