}
  }

  /**
   * Returns true if this stream is open. A stream is open until either:
   *
   *  * A `SYN_RESET` frame abnormally terminates the stream.
   *  * Both input and output streams have transmitted all data and headers.
   *
   * Note that the input stream may continue to yield data even after a stream reports itself as
   * not open. This is because input data is buffered.
   */

 */
package org.codelibs.fess.app.service;

import static org.codelibs.core.stream.StreamUtil.split;
import static org.codelibs.core.stream.StreamUtil.stream;

import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import org.apache.logging.log4j.LogManager;

        return forkOptions;
    }

    @Override
    public Stream<CandidateClassFile> getCandidateClassFiles() {
        return candidateClassFiles.stream();
    }

    @Override
    public Stream<InputFileProperty> getInputFileProperties() {
        return inputFileProperties.stream();
    }

    @Override
    public Stream<OutputFileProperty> getOutputFileProperties() {

                                       bool* stream_was_changed) {
  if (!(*stream) || !(*stream)->ok()) {
    xla::StreamPool::Ptr ptr;
    TF_ASSIGN_OR_RETURN(ptr, backend->BorrowStream(device_ordinal_));
    *stream = std::shared_ptr<se::Stream>(std::move(ptr));
    VLOG(1) << "XlaDevice " << this << " new " << name
            << " stream=" << (*stream);

                            }
                        });
                        final List<String> newGroupList = stream(user.getGroupNames()).get(stream -> stream.collect(Collectors.toList()));
                        stream(user.getGroupNames()).of(stream -> stream.forEach(name -> {
                            if (oldGroupList.contains(name)) {
                                oldGroupList.remove(name);

    @Override
    public int hashCode() {
        return Objects.hash(modelId, location, inputs);
    }

    Stream<InputSource> sources() {
        return inputs != null ? inputs.stream() : Stream.of(this);
    }

    @Override
    public String toString() {
        if (inputs != null) {
            return inputs.stream().map(InputSource::toString).collect(Collectors.joining(", ", "merged[", "]"));
        }

                  TF_Status* const status) {
  *stream = nullptr;
}
void DestroyStream(const SP_Device* const device, SP_Stream stream) {}
void CreateStreamDependency(const SP_Device* const device, SP_Stream dependent,
                            SP_Stream other, TF_Status* const status) {}
void GetStreamStatus(const SP_Device* const device, SP_Stream stream,

      new XlaHostSendDeviceContext(stream.get(), &gpu_dst, shape, done_event);
  TF_ASSERT_OK(device_context->CopyCPUTensorToDeviceSync(
      &origin_cpu_tensor, device_.get(), &device_tensor));

  // Copy the GPU tensor back to CPU to check that copy worked.
  TF_ASSERT_OK(stream->Memcpy(dest_cpu_tensor.data(), gpu_dst, gpu_dst.size()));
  TF_ASSERT_OK(stream->BlockHostUntilDone());

package org.gradle.internal.snapshot;

import java.util.stream.Stream;

/**
 * A snapshot of a part of the file system.
 */
public interface FileSystemSnapshot {
    /**
     * An empty snapshot.
     */
    FileSystemSnapshot EMPTY = new FileSystemSnapshot() {
        @Override
        public Stream<FileSystemLocationSnapshot> roots() {
            return Stream.empty();
        }

        @Override

 * correlated by stream ID.
 *
 *  * [onRequest]
 *  * [onHeaders] (unless canceled)
 *  * [onData] (optional sequence of data frames)
 *
 * As a stream ID is scoped to a single HTTP/2 connection, implementations which target multiple
 * connections should expect repetition of stream IDs.
 *
 * Return true to request cancellation of a pushed stream.  Note that this does not guarantee