return s;
  }

  void Destroy() {
    if (stream_handle_ != nullptr) {
      stream_executor_->destroy_stream(device_, stream_handle_);
      stream_handle_ = nullptr;
    }
  }
  absl::Status RefreshStatus() override {
    tensorflow::TF_StatusPtr c_status(TF_NewStatus());
    stream_executor_->get_stream_status(device_, stream_handle_,
                                        c_status.get());

 * limitations under the License.
 */

package org.gradle.process.internal;

import org.gradle.internal.concurrent.Stoppable;

import java.util.concurrent.Executor;

public interface StreamsHandler extends Stoppable {
    /**
     * Collects whatever state is required the given process. Should not start work.
     */
    void connectStreams(Process process, String processName, Executor executor);

    /**

 * response data before all request data has been received.
 *
 * See [okhttp3.RequestBody.isDuplex].
 */
@ExperimentalOkHttpApi
interface StreamHandler {
  fun handle(stream: Stream)

        }
        return effectiveHandler;
    }

    public AbstractExecHandleBuilder streamsHandler(StreamsHandler streamsHandler) {
        this.streamsHandler = streamsHandler;
        return this;
    }

    /**
     * Merge the process' error stream into its output stream
     */
    public AbstractExecHandleBuilder redirectErrorStream() {

    private final Executor executor;

    private Process process;
    private boolean aborted;
    private final StreamsHandler streamsHandler;
    private volatile BuildOperationRef associatedBuildOperation;

    public ExecHandleRunner(
        DefaultExecHandle execHandle, StreamsHandler streamsHandler, ProcessLauncher processLauncher, Executor executor,
        BuildOperationRef associatedBuildOperation
    ) {

     */
    ExecHandleBuilder setDaemon(boolean daemon);

    /**
     * Sets a handler for the output streams of the process.
     */
    ExecHandleBuilder streamsHandler(StreamsHandler streamsHandler);

    /**
     * Sets the start-up timeout, when spawning a process. Not used when forking a process (the default).
     */
    ExecHandleBuilder setTimeout(int timeoutMillis);

        super.setStandardInput(inputStream);
        return this;
    }

    @Override
    public DefaultExecHandleBuilder streamsHandler(StreamsHandler streamsHandler) {
        super.streamsHandler(streamsHandler);
        return this;
    }

    @Override
    public DefaultExecHandleBuilder listener(ExecHandleListener listener) {
        super.listener(listener);

import org.gradle.api.UncheckedIOException;
import org.gradle.process.internal.StreamsHandler;

import java.io.IOException;
import java.util.concurrent.Executor;

/**
 * A handler that writes nothing to the process' stdin
 */
public class EmptyStdInStreamsHandler implements StreamsHandler {
    @Override
    public void connectStreams(Process process, String processName, Executor executor) {

 * limitations under the License.
 */

package org.gradle.process.internal.streams;

import org.gradle.api.UncheckedIOException;
import org.gradle.internal.UncheckedException;
import org.gradle.process.internal.StreamsHandler;
import org.gradle.util.internal.DisconnectableInputStream;

import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;

/**

import org.gradle.process.internal.StreamsHandler;

import java.io.OutputStream;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;

/**
 * Reads from the process' stdout and stderr (if not merged into stdout) and forwards to {@link OutputStream}.
 */
public class OutputStreamsForwarder implements StreamsHandler {
    private final OutputStream standardOutput;