OP_REQUIRES_OK(c, c->GetAttr("shared_name", &name_));
}

void XlaAotOnlyVarHandleOp::Compile(XlaOpKernelContext* context) {
  // Look for a resource of the same name. TF also keys that on the container
  // and type attributes, but that doesn't seem necessary.
  for (const auto& resource : context->xla_context()->resources()) {
    if (resource->kind() == XlaResource::kVariable &&
        resource->name() == name_) {

    : std::fstream(temp_file_name, mode), name_(temp_file_name) {}

TempFile::TempFile(TempFile&& rhs)
    : std::fstream(std::move(rhs)), name_(std::move(rhs.name_)) {}

TempFile::~TempFile() {
  std::fstream::close();
  std::remove(name_.c_str());
}

const std::string TempFile::getName() const { return name_; }

bool TempFile::truncate() {
  std::fstream::close();

#include "tensorflow/c/experimental/saved_model/core/signature_def_function_metadata.h"

namespace tensorflow {

SignatureDefParam::SignatureDefParam(std::string name, TensorSpec spec)
    : name_(std::move(name)), spec_(std::move(spec)) {}

const std::string& SignatureDefParam::name() const { return name_; }

const TensorSpec& SignatureDefParam::spec() const { return spec_; }

SignatureDefFunctionMetadata::SignatureDefFunctionMetadata(

  const string& name() const { return name_; }
  const string& description() const { return description_; }
  const ArgType arg_type() const { return arg_type_; }
  const int position() const { return position_; }

 private:
  explicit ArgSpec(const OpDef::ArgDef& arg_def, ArgType arg_type,
                   int position);

  string name_;
  string description_;
  ArgType arg_type_;

FlatTensorFunction::FlatTensorFunction(
    const std::string& name, std::vector<ImmediateTensorHandlePtr> captures,
    ImmediateExecutionContext* ctx)
    : name_(name), captures_(std::move(captures)), ctx_(ctx) {}

FlatTensorFunction::~FlatTensorFunction() {
  Status status = ctx_->RemoveFunction(name_);
  if (!status.ok()) {
    LOG(ERROR) << "Failed to remove functiondef " << name_ << ". "
               << status.message();
  }
}

// An Op.
//
// Essentially, this represents an OpDef and any necessary context (e.g ApiDef).
class OpSpec {
 public:
  static OpSpec Create(const OpDef& op_def, const ApiDef& api_def);

  const string& name() const { return name_; }
  const string& summary() const { return summary_; }
  const string& description() const { return description_; }
  const std::vector<ArgSpec>& Inputs() const { return input_args_; }

class AttrSpec {
 public:
  AttrSpec() = default;
  AttrSpec(const AttrSpec& other) = default;
  static AttrSpec Create(const OpDef::AttrDef& attr_def);

  const string& name() const { return name_; }
  const string& description() const { return description_; }
  const string& full_type() const { return full_type_; }
  const string& base_type() const { return base_type_; }

  // A pointer to the resource variable.  May be null if this VariableInfo is
  // "empty", i.e. it does not track a resource variable.
  Var* var() const { return var_; }

  // Returns the variable name.
  absl::string_view name() const { return name_; }

  // Returns true if the resource variable lock was successfully acquired by
  // this thread.
  bool lock_held() const { return lock_held_; }
  void set_lock_held() { lock_held_ = true; }

namespace tensorflow {

Variable::Variable(ImmediateExecutionContext* ctx, DataType dtype,
                   TensorShape shape, absl::optional<std::string> name,
                   ImmediateTensorHandlePtr handle)
    : TensorHandleConvertible(std::move(handle)),
      name_(name.has_value() ? *name : "Variable"),
      dtype_(dtype),
      shape_(shape),
      ctx_(ctx) {}

Variable::~Variable() {

// Public interface.

// Matches a node with name `name`.
impl::NodeMatcherProperties Name(string name);

// Matches a node with op `op`.
impl::NodeMatcherProperties Op(string op);

// Matches a node with assigned device `assigned_device`.
impl::NodeMatcherProperties AssignedDevice(string assigned_device);

// Matches a node with a boolean typed attribute named `name` and with value
// `value`.