return FlattenOperationResult.of(specs.stream().filter(e -> !ignoreSpec.test(e)).collect(toSet()));
    }

    private Stream<ExcludeSpec> maybeFilter(Set<ExcludeSpec> specs, Predicate<ExcludeSpec> ignoreSpec, boolean filtered) {
        Stream<ExcludeSpec> stream = specs.stream();
        if (filtered) {
            stream = stream.filter(e -> !ignoreSpec.test(e));
        }
        return stream;

          writeBytesTotal >= writeBytesMaximum ||
          stream.writeBytesTotal >= stream.writeBytesMaximum
        if (stream.isOpen) {
          streams[streamId] = stream
        }
      }
      if (associatedStreamId == 0) {
        writer.headers(outFinished, streamId, requestHeaders)
      } else {
        require(!client) { "client streams shouldn't have associated stream IDs" }
        // HTTP/2 has a PUSH_PROMISE frame.

  }
  return stream_executor_->ClearAllocatorStats();
}

XlaDeviceContext::XlaDeviceContext(
    std::shared_ptr<se::Stream> compute_stream,
    std::shared_ptr<se::Stream> host_to_device_stream,
    std::shared_ptr<se::Stream> device_to_host_stream,
    std::vector<std::shared_ptr<se::Stream>> device_to_device_streams,
    xla::LocalClient* client,
    XlaShapeLayoutHelpers::ShapeDeterminationFns shape_determination_fns,

                                           &HostCallbackTrampoline, ctx);
  }
  void DeallocateStream(Stream* stream) override {
    static_cast<CStream*>(stream)->Destroy();
  }
  absl::Status BlockHostForEvent(Stream* stream, Event* event) {
    OwnedTFStatus c_status(TF_NewStatus());
    SP_Event event_handle = static_cast<CEvent*>(event)->Handle();
    stream_executor_->block_host_for_event(&device_, event_handle,

        def serviceLocator = new DefaultServiceLocator(classLoader, classLoader2)

        def serviceFile1 = stream('org.gradle.ImplClass')
        def serviceFile2 = stream('org.gradle.ImplClass2')
        def serviceFile3 = stream('org.gradle.ImplClass')
        def serviceFile4 = stream('org.gradle.ImplClass3')

        when:
        def result = serviceLocator.getAll(CharSequence.class)

        then:

    }
  }

  /**
   * 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;

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

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.admin.relatedquery;

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

import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.annotation.Resource;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.admin.labeltype;

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

import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.annotation.Resource;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;