system_desc_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_SYSTEMDESC_TT_TARGET_H_
#define FLATBUFFERS_GENERATED_SYSTEMDESC_TT_TARGET_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 "types_generated.h"
#include "version_generated.h"
 
// For access to the binary schema that produced this file.
#include "system_desc_bfbs_generated.h"
 
namespace tt {
namespace target {
 
struct SystemDescRoot;
struct SystemDescRootBuilder;
 
struct SystemDescRoot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SystemDescRootBuilder Builder;
  typedef tt::target::SystemDescRootBinarySchema BinarySchema;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VERSION = 4,
    VT_TTMLIR_GIT_HASH = 6,
    VT_PRODUCT_IDENTIFIER = 8,
    VT_SYSTEM_DESC = 10
  };
  const tt::target::Version *version() const {
    return GetStruct<const tt::target::Version *>(VT_VERSION);
  }
  const ::flatbuffers::String *ttmlir_git_hash() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TTMLIR_GIT_HASH);
  }
  const ::flatbuffers::String *product_identifier() const {
    return GetPointer<const ::flatbuffers::String *>(VT_PRODUCT_IDENTIFIER);
  }
  const tt::target::SystemDesc *system_desc() const {
    return GetPointer<const tt::target::SystemDesc *>(VT_SYSTEM_DESC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::Version>(verifier, VT_VERSION, 4) &&
           VerifyOffset(verifier, VT_TTMLIR_GIT_HASH) &&
           verifier.VerifyString(ttmlir_git_hash()) &&
           VerifyOffset(verifier, VT_PRODUCT_IDENTIFIER) &&
           verifier.VerifyString(product_identifier()) &&
           VerifyOffset(verifier, VT_SYSTEM_DESC) &&
           verifier.VerifyTable(system_desc()) &&
           verifier.EndTable();
  }
};
 
struct SystemDescRootBuilder {
  typedef SystemDescRoot Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_version(const tt::target::Version *version) {
    fbb_.AddStruct(SystemDescRoot::VT_VERSION, version);
  }
  void add_ttmlir_git_hash(::flatbuffers::Offset<::flatbuffers::String> ttmlir_git_hash) {
    fbb_.AddOffset(SystemDescRoot::VT_TTMLIR_GIT_HASH, ttmlir_git_hash);
  }
  void add_product_identifier(::flatbuffers::Offset<::flatbuffers::String> product_identifier) {
    fbb_.AddOffset(SystemDescRoot::VT_PRODUCT_IDENTIFIER, product_identifier);
  }
  void add_system_desc(::flatbuffers::Offset<tt::target::SystemDesc> system_desc) {
    fbb_.AddOffset(SystemDescRoot::VT_SYSTEM_DESC, system_desc);
  }
  explicit SystemDescRootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SystemDescRoot> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SystemDescRoot>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<SystemDescRoot> CreateSystemDescRoot(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Version *version = nullptr,
    ::flatbuffers::Offset<::flatbuffers::String> ttmlir_git_hash = 0,
    ::flatbuffers::Offset<::flatbuffers::String> product_identifier = 0,
    ::flatbuffers::Offset<tt::target::SystemDesc> system_desc = 0) {
  SystemDescRootBuilder builder_(_fbb);
  builder_.add_system_desc(system_desc);
  builder_.add_product_identifier(product_identifier);
  builder_.add_ttmlir_git_hash(ttmlir_git_hash);
  builder_.add_version(version);
  return builder_.Finish();
}
 
struct SystemDescRoot::Traits {
  using type = SystemDescRoot;
  static auto constexpr Create = CreateSystemDescRoot;
};
 
inline ::flatbuffers::Offset<SystemDescRoot> CreateSystemDescRootDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Version *version = nullptr,
    const char *ttmlir_git_hash = nullptr,
    const char *product_identifier = nullptr,
    ::flatbuffers::Offset<tt::target::SystemDesc> system_desc = 0) {
  auto ttmlir_git_hash__ = ttmlir_git_hash ? _fbb.CreateString(ttmlir_git_hash) : 0;
  auto product_identifier__ = product_identifier ? _fbb.CreateString(product_identifier) : 0;
  return tt::target::CreateSystemDescRoot(
      _fbb,
      version,
      ttmlir_git_hash__,
      product_identifier__,
      system_desc);
}
 
inline const tt::target::SystemDescRoot *GetSystemDescRoot(const void *buf) {
  return ::flatbuffers::GetRoot<tt::target::SystemDescRoot>(buf);
}
 
inline const tt::target::SystemDescRoot *GetSizePrefixedSystemDescRoot(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<tt::target::SystemDescRoot>(buf);
}
 
inline const char *SystemDescRootIdentifier() {
  return "TTSY";
}
 
inline bool SystemDescRootBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, SystemDescRootIdentifier());
}
 
inline bool SizePrefixedSystemDescRootBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, SystemDescRootIdentifier(), true);
}
 
inline bool VerifySystemDescRootBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<tt::target::SystemDescRoot>(SystemDescRootIdentifier());
}
 
inline bool VerifySizePrefixedSystemDescRootBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<tt::target::SystemDescRoot>(SystemDescRootIdentifier());
}
 
inline const char *SystemDescRootExtension() {
  return "ttsys";
}
 
inline void FinishSystemDescRootBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<tt::target::SystemDescRoot> root) {
  fbb.Finish(root, SystemDescRootIdentifier());
}
 
inline void FinishSizePrefixedSystemDescRootBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<tt::target::SystemDescRoot> root) {
  fbb.FinishSizePrefixed(root, SystemDescRootIdentifier());
}
 
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_SYSTEMDESC_TT_TARGET_H_