//                     we allow null here. This will, however, leak resources.
  RestoredResource(const std::string& device,
                   TFConcreteFunction* create_resource,
                   TFConcreteFunction* initialize,
                   TFConcreteFunction* destroy_resource,
                   ImmediateTensorHandlePtr resource_handle);

  Status Initialize() const;

// TF Eager Runtime-based implementation of a "ConcreteFunction" loaded from a
// saved model.
class TFConcreteFunction : public ConcreteFunction {
 public:
  // Factory function for creating a TFConcreteFunction.
  //
  // Params:
  //  function_def - The function_def associated with the created
  //                 TFConcreteFunction. TFConcreteFunction will register this
  //                 function_def with `ctx` on creation, and de-register it on

#include "tensorflow/core/protobuf/struct.pb.h"

namespace tensorflow {

TFConcreteFunction::TFConcreteFunction(std::unique_ptr<FlatTensorFunction> func,
                                       FunctionMetadata metadata)
    : func_(std::move(func)), metadata_(std::move(metadata)) {}

Status TFConcreteFunction::Create(
    const FunctionDef* function_def,
    std::vector<ImmediateExecutionTensorHandle*> captures,

  captures[5] = std::make_unique<DummyCapture>(context(), 10);

  std::unique_ptr<TFConcreteFunction> result;
  Status status = internal::LoadTFConcreteFunction(saved, &func, captures,
                                                   context(), &result);
  TF_EXPECT_OK(status) << status.message();
}

// A TFConcreteFunction should register functiondefs on creation, and
// remove them upon deletion.

  return Status();
}

}  // namespace

RestoredResource::RestoredResource(const std::string& device,
                                   TFConcreteFunction* create_resource,
                                   TFConcreteFunction* initialize,
                                   TFConcreteFunction* destroy_resource,
                                   ImmediateTensorHandlePtr resource_handle)
    : TensorHandleConvertible(std::move(resource_handle)),

                              const SavedObjectGraph& obj_graph,
                              const PartiallyRevivedObjects& objects,
                              std::unique_ptr<TFConcreteFunction>* out) {
  const auto& capture_node_ids = builder.saved_concrete_func->bound_inputs();
  std::vector<ImmediateExecutionTensorHandle*> captures;
  captures.reserve(capture_node_ids.size());

  //             of each handle, and will decrement them on destruction).
  //  ctx      - A handle to the Tensorflow runtime. This MUST be non-null and
  //             outlive TFConcreteFunction.
  //  out      - The output FlatTensorFunction.
  static Status Create(const FunctionDef* function_def,
                       std::vector<ImmediateExecutionTensorHandle*> captures,

// Creates a TFConcreteFunction from a SavedConcreteFunction.
Status LoadTFConcreteFunction(
    const SavedConcreteFunction& saved_concrete_function,
    const FunctionDef* function_def,
    const std::unordered_map<int, std::unique_ptr<TensorHandleConvertible>>&
        captured_objects,
    ImmediateExecutionContext* ctx, std::unique_ptr<TFConcreteFunction>* out);

  // the graph def function library.
  for (const FunctionDef& function :
       bundle.meta_graph_def().graph_def().library().function()) {
    std::unique_ptr<TFConcreteFunction> concrete_function;
    TF_RETURN_IF_ERROR(TFConcreteFunction::Create(/*function_def=*/&function,
                                                  /*captures=*/{},
                                                  /*metadata=*/{},

  //                 non-null, but otherwise has no lifetime requirements.
  //  captures - The captured TensorHandles associated with this
  //             TFConcreteFunction.
  //  metadata - FunctionMetadata associated with this TFSignatureDefFunction.
  //  ctx      - A handle to the Tensorflow runtime. This MUST be non-null and
  //             outlive TFSignatureDefFunction.