// SignatureDefFunctionMetadata::returns().
class SignatureDefFunction final {
 public:
  // Returns FunctionMetadata associated with this ConcreteFunction.
  const SignatureDefFunctionMetadata* GetFunctionMetadata();

 private:
  friend class SavedModelAPI;
  friend class ConcreteFunctionList;

  // TODO(bmzhao): Consider adding a macro for wrapping/unwrapping
  // when moving out of experimental.

  // it depends on tensorflow::cc::Tensor and tensorflow::cc::TensorHandle

  // Returns FunctionMetadata associated with this ConcreteFunction.
  const FunctionMetadata* GetFunctionMetadata();

 private:
  friend class SavedModelAPI;
  friend class ConcreteFunctionList;

  // TODO(bmzhao): Consider adding a macro for wrapping/unwrapping
  // when moving out of experimental.

extern "C" {

TF_FunctionMetadata* TF_ConcreteFunctionGetMetadata(TF_ConcreteFunction* func) {
  return tensorflow::wrap(const_cast<tensorflow::FunctionMetadata*>(
      &tensorflow::unwrap(func)->GetFunctionMetadata()));
}

TFE_Op* TF_ConcreteFunctionMakeCallOp(TF_ConcreteFunction* func,
                                      TFE_TensorHandle** inputs, int num_inputs,
                                      TF_Status* status) {

TF_SignatureDefFunctionMetadata* TF_SignatureDefFunctionGetMetadata(
    TF_SignatureDefFunction* func) {
  return tensorflow::wrap(const_cast<tensorflow::SignatureDefFunctionMetadata*>(
      &tensorflow::unwrap(func)->GetFunctionMetadata()));
}

TFE_Op* TF_SignatureDefFunctionMakeCallOp(TF_SignatureDefFunction* func,
                                          TFE_TensorHandle** inputs,

      function_def, std::move(captures), ctx, &func));

  out->reset(new TFConcreteFunction(std::move(func), std::move(metadata)));
  return Status();
}

const FunctionMetadata& TFConcreteFunction::GetFunctionMetadata() const {
  return metadata_;
}

Status TFConcreteFunction::MakeCallOp(
    absl::Span<AbstractTensorHandle* const> inputs, ImmediateOpPtr* out) const {
  return func_->MakeCallOp(inputs, out);
}

  out->reset(new TFSignatureDefFunction(std::move(func), std::move(metadata)));
  return Status();
}

const SignatureDefFunctionMetadata&
TFSignatureDefFunction::GetFunctionMetadata() const {
  return metadata_;
}

Status TFSignatureDefFunction::MakeCallOp(
    absl::Span<AbstractTensorHandle* const> inputs, ImmediateOpPtr* out) const {
  return func_->MakeCallOp(inputs, out);
}

  virtual Status MakeCallOp(absl::Span<AbstractTensorHandle* const> inputs,
                            ImmediateOpPtr* out) const = 0;

  virtual const FunctionMetadata& GetFunctionMetadata() const = 0;
};

}  // namespace tensorflow

  // This method returns the "Call" Op used to execute the function.
  Status MakeCallOp(absl::Span<AbstractTensorHandle* const> inputs,
                    ImmediateOpPtr* out) const override;

  const FunctionMetadata& GetFunctionMetadata() const override;

  ~TFConcreteFunction() override = default;

 private:
  TFConcreteFunction(std::unique_ptr<FlatTensorFunction> func,
                     FunctionMetadata metadata);

  virtual Status MakeCallOp(absl::Span<AbstractTensorHandle* const> inputs,
                            ImmediateOpPtr* out) const = 0;

  virtual const SignatureDefFunctionMetadata& GetFunctionMetadata() const = 0;
};

}  // namespace tensorflow

  Status MakeCallOp(absl::Span<AbstractTensorHandle* const> inputs,
                    ImmediateOpPtr* out) const override;

  const SignatureDefFunctionMetadata& GetFunctionMetadata() const override;

  ~TFSignatureDefFunction() override = default;

 private:
  TFSignatureDefFunction(std::unique_ptr<FlatTensorFunction> func,
                         SignatureDefFunctionMetadata metadata);