}
      *handle = assets_iter->second->handle();
      return Status();
    }
    case SavedObject::kResource: {
      const auto& resource_iter = objects.restored_resources.find(node_id);
      if (resource_iter == objects.restored_resources.end()) {
        return absl::FailedPreconditionError(absl::StrCat(
            "Tried to convert node id ", node_id,

  gtl::FlatMap<int, std::unique_ptr<TFSignatureDefFunction>>
      signature_def_functions;
  RevivedObjectContainer<TFConcreteFunction> concrete_functions;
  gtl::FlatMap<int, RestoredResource> restored_resources;
  gtl::FlatMap<std::string, int> signatures_map;
};

}  // namespace tensorflow

  gtl::FlatMap<int, TFConcreteFunctionRevivalState> concrete_functions;
  gtl::FlatMap<int, TFSignatureDefFunctionRevivalState> signature_def_functions;
  gtl::FlatMap<int, RestoredResourceRevivalState> restored_resources;
  gtl::FlatMap<std::string, int> signatures_map;

  Status Build(ImmediateExecutionContext* ctx,
               const SavedObjectGraph& obj_graph, RevivedObjects* revived);
};

}  // namespace tensorflow

      // We'll set the resource's functions in a subsequent pass, once we get
      // all functions in a partially revived state.
      resource_revival_state.device = node.resource().device();
      objects->restored_resources[i] = std::move(resource_revival_state);
    } else if (node.kind_case() == SavedObject::kFunction) {
      // Get the SavedFunction node and skip if it has no concrete functions.

      }));

  return Status();
}

Status InitializeAllResources(const RevivedObjects& revived) {
  for (const auto& node_and_resource : revived.restored_resources) {
    const RestoredResource& resource = node_and_resource.second;
    TF_RETURN_IF_ERROR(resource.Initialize());
  }
  return Status();
}

}  // namespace

      device_(device),
      create_resource_(create_resource),
      initialize_(initialize),
      destroy_resource_(destroy_resource) {}

Status RestoredResource::Initialize() const {
  return ExecuteNoArgDummyReturnFunction(initialize_);
}

RestoredResource::~RestoredResource() {
  // Note(bmzhao): SavedModels saved before
  // https://github.com/tensorflow/tensorflow/commit/3c806101f57768e479f8646e7518bbdff1632ca3

  RestoredResource& operator=(RestoredResource&& other) = default;

  ~RestoredResource() override;

 private:
  std::string device_;
  TFConcreteFunction* create_resource_;
  TFConcreteFunction* initialize_;
  TFConcreteFunction* destroy_resource_;
};

}  // namespace tensorflow

        "@com_google_absl//absl/strings",
        "@com_google_absl//absl/types:span",
    ],
)

cc_library(
    name = "restored_resource",
    srcs = [
        "restored_resource.cc",
    ],
    hdrs = [
        "restored_resource.h",
    ],
    deps = [
        ":tensorhandle_convertible",
        ":tf_concrete_function",
        "//tensorflow/c/eager:abstract_tensor_handle",