class TensorHandleConvertible {
 public:
  explicit TensorHandleConvertible(ImmediateTensorHandlePtr handle)
      : handle_(std::move(handle)) {}

  ImmediateExecutionTensorHandle* handle() { return handle_.get(); }

  // TensorHandleConvertible is movable, but not copyable.
  TensorHandleConvertible(TensorHandleConvertible&& other) = default;

  // CHECK: "tf.TensorArrayV3"
  %handle_12, %flow_13 = "tf.TensorArrayV3"(%max_iter) {device = "/job:localhost/replica:0/task:0/device:CPU:0", dtype = !tf_type.variant, dynamic_size = false, element_shape = #tf_type.shape<*>, identical_element_shapes = true, tensor_array_name = ""} : (tensor<i32>) -> (tensor<2x!tf_type.resource<tensor<*x!tf_type.variant>>>, tensor<f32>)
  // CHECK: "tf.TensorArrayV3"

  void Reset(TFE_TensorHandle* handle) { handle_.reset(handle); }

  struct TFETensorHandleDeleter {
    void operator()(TFE_TensorHandle* p) const { TFE_DeleteTensorHandle(p); }
  };
  std::unique_ptr<TFE_TensorHandle, TFETensorHandleDeleter> handle_;
};

inline Tensor TensorHandle::Resolve(Status* status) {
  TF_Tensor* tensor =
      TFE_TensorHandleResolve(handle_.get(), status->GetTFStatus());
  if (!status->ok()) {

      TFE_NewOp(context, "DestroyResourceOp", status), &TFE_DeleteOp);
  if (TF_GetCode(status) != TF_OK) return;
  TFE_OpAddInput(op.get(), handle_, status);
  if (TF_GetCode(status) != TF_OK) return;
  const char* device = TFE_TensorHandleDeviceName(handle_, status);
  if (TF_GetCode(status) != TF_OK) return;
  TFE_OpSetDevice(op.get(), device, status);
  if (TF_GetCode(status) != TF_OK) return;
  int num_retvals = 0;

      ctx_(ctx) {}

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;
  }
}

}

TapeTensor::TapeTensor(AbstractTensorHandle* handle) : handle_(handle) {
  handle_->Ref();
}
TapeTensor::TapeTensor(const TapeTensor& other) {
  handle_ = other.handle_;
  handle_->Ref();
}
TapeTensor::~TapeTensor() { handle_->Unref(); }

int64_t TapeTensor::GetID() const { return ToId(handle_); }

tensorflow::DataType TapeTensor::GetDType() const {
  return handle_->DataType();
}

package log

import (
	"encoding/json"
	"io"
	"net"
	"net/http"
	"path/filepath"
	"reflect"
	"testing"
	"time"
)

type udsServer struct {
	messages []string
}

func (us *udsServer) handleLog(w http.ResponseWriter, r *http.Request) {
	var body []byte
	if r.Body != nil {
		if data, err := io.ReadAll(r.Body); err == nil {
			body = data
		}
	}
	messages := []string{}

package org.gradle.launcher.daemon

import org.gradle.integtests.fixtures.AvailableJavaHomes
import org.gradle.internal.jvm.Jvm
import org.gradle.launcher.daemon.registry.DaemonDir
import org.gradle.launcher.daemon.server.api.HandleStop
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.test.preconditions.UnitTestPreconditions

/**

	Arbitrary map[string]any `json:"-"`
}

func NewUDSLogger(level istiolog.Level) *UDSLogger {
	l := &UDSLogger{}
	mux := http.NewServeMux()
	mux.HandleFunc(constants.UDSLogPath, l.handleLog)
	loggingServer := &http.Server{
		Handler: mux,
	}
	l.loggingServer = loggingServer
	pluginLog.SetOutputLevel(level)
	return l
}

import org.gradle.launcher.daemon.server.api.HandleInvalidateVirtualFileSystem;
import org.gradle.launcher.daemon.server.api.HandleReportStatus;
import org.gradle.launcher.daemon.server.api.HandleStop;
import org.gradle.launcher.daemon.server.exec.CleanUpVirtualFileSystemAfterBuild;
import org.gradle.launcher.daemon.server.exec.DaemonCommandExecuter;
import org.gradle.launcher.daemon.server.exec.EstablishBuildEnvironment;