//  initialize - Non owning pointer to the initialize function associated with
  //               this object. Must be NON-NULL.
  //  destroy_resource - Non owning pointer to the destroy_resource function
  //                     associated with this object. Ideally this should be
  //                     NON-NULL, but in order to support models saved prior to

        resource.initialize = &objects->concrete_functions[child_node_id];
      } else if (child.local_name() == "_destroy_resource" &&
                 obj_graph.nodes(child.node_id()).kind_case() ==
                     SavedObject::kFunction) {
        resource.destroy_resource = &objects->concrete_functions[child_node_id];
      }
    }
  }

  objects->signatures_map = std::move(signatures_map);

  // did not have their destroy_resource function saved, meaning they will
  // leak resources.
  //
  // Check that handle is null before calling destroy_resource function in case
  // destructor is invoked unintentionally.
  if (destroy_resource_ != nullptr && handle() != nullptr) {
    Status status = ExecuteNoArgDummyReturnFunction(destroy_resource_);
    if (!status.ok()) {
      LOG(WARNING)

      }
    }

    TFConcreteFunction* destroy_resource = nullptr;
    if (resource_revival_state.destroy_resource != nullptr) {
      destroy_resource = revived->concrete_functions.Find(
          resource_revival_state.destroy_resource->node_id);
      if (destroy_resource == nullptr) {
        return absl::FailedPreconditionError(absl::StrCat(
            "'destroy_resource' function with node id ",

struct RestoredResourceRevivalState {
  std::string device;
  TFConcreteFunctionRevivalState* create_resource = nullptr;
  TFConcreteFunctionRevivalState* initialize = nullptr;
  TFConcreteFunctionRevivalState* destroy_resource = nullptr;
  ImmediateTensorHandlePtr resource_handle = nullptr;
};

}  // namespace tensorflow

// the cleanup that occurs in a tf.Variable's EagerResourceDeleter:
// https://github.com/tensorflow/tensorflow/blob/516608035f85cec8b126712b0ff8407220206b22/tensorflow/python/ops/resource_variable_ops.py#L289-L290
Status DestroyResource(ImmediateExecutionContext* ctx,
                       ImmediateExecutionTensorHandle* handle);

}  // namespace internal
}  // namespace tensorflow

    return errors::Internal("Unexpected tensor handle kind.");
  }
  output->reset(
      reinterpret_cast<ImmediateExecutionTensorHandle*>(owned_value.release()));
  return Status();
}

Status DestroyResource(ImmediateExecutionContext* ctx,
                       ImmediateExecutionTensorHandle* handle) {
  ImmediateOpPtr destroy_op(ctx->CreateOperation());
  TF_RETURN_IF_ERROR(destroy_op->Reset("DestroyResourceOp", nullptr));

  ImmediateTensorHandlePtr handle;
  TF_EXPECT_OK(internal::CreateUninitializedResourceVariable(
      context(), DT_FLOAT, {}, nullptr, &handle));

  // Destroy the variable
  TF_EXPECT_OK(internal::DestroyResource(context(), handle.get()));
}

// Sanity check for handle assignment and reading
TEST_F(VariableOpsTest, AssignVariableAndReadSuccessful) {
  // Create a DT_Resource TensorHandle that points to a scalar DT_FLOAT tensor

Variable::~Variable() {
  // If the handle is null (perhaps because variable was std::moved from), then
  // we don't have to do anything.
  if (handle_ == nullptr) {
    return;
  }

  Status status = internal::DestroyResource(ctx_, handle_.get());
  if (!status.ok()) {
    LOG(ERROR) << "Error destroying variable: " << name_
               << "due to: " << status;
  }
}

DataType Variable::dtype() { return dtype_; }