com.redis.om.spring.search.stream.WrapperSearchStream Maven / Gradle / Ivy

Go to download
package com.redis.om.spring.search.stream;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.Spliterator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.stream.Collector;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;

import com.redis.om.spring.search.stream.predicates.SearchFieldPredicate;

import io.redisearch.aggregation.SortedField.SortOrder;

public class WrapperSearchStream implements SearchStream {

  private Stream backingStream = Stream.empty();
  private Runnable closeHandler;

  public WrapperSearchStream(Stream backingStream) {
    this.backingStream = backingStream;
  }

  @Override
  public Iterator iterator() {
    return backingStream.iterator();
  }

  @Override
  public Spliterator spliterator() {
    return backingStream.spliterator();
  }

  @Override
  public boolean isParallel() {
    return backingStream.isParallel();
  }

  @Override
  public SearchStream sequential() {
    return new WrapperSearchStream<>(backingStream.sequential());
  }

  @Override
  public SearchStream parallel() {
    return new WrapperSearchStream<>(backingStream.parallel());
  }

  @Override
  public SearchStream unordered() {
    return new WrapperSearchStream<>(backingStream.unordered());
  }

  @Override
  public SearchStream onClose(Runnable closeHandler) {
    this.closeHandler = closeHandler;
    return this;
  }

  @Override
  public void close() {
    if (closeHandler == null) {
      backingStream.close();
    } else {
      backingStream.onClose(closeHandler);
      backingStream.close();
    }
  }

  @Override
  public SearchStream filter(SearchFieldPredicate predicate) {
    // NO-OP
    return this;
  }

  @SuppressWarnings("unchecked")
  @Override
  public SearchStream filter(Predicate predicate) {
    // TODO: need to test this cast!
    return new WrapperSearchStream<>(backingStream.filter((Predicate) predicate));
  }

  @Override
  public  SearchStream map(Function mapper) {
    return new WrapperSearchStream<>(backingStream.map(mapper));
  }

  @Override
  public IntStream mapToInt(ToIntFunction mapper) {
    return backingStream.mapToInt(mapper);
  }

  @Override
  public LongStream mapToLong(ToLongFunction mapper) {
    return backingStream.mapToLong(mapper);
  }

  @Override
  public DoubleStream mapToDouble(ToDoubleFunction mapper) {
    return backingStream.mapToDouble(mapper);
  }

  @Override
  public  SearchStream flatMap(Function> mapper) {
    return new WrapperSearchStream<>(backingStream.flatMap(mapper));
  }

  @Override
  public IntStream flatMapToInt(Function mapper) {
    return backingStream.flatMapToInt(mapper);
  }

  @Override
  public LongStream flatMapToLong(Function mapper) {
    return backingStream.flatMapToLong(mapper);
  }

  @Override
  public DoubleStream flatMapToDouble(Function mapper) {
    return backingStream.flatMapToDouble(mapper);
  }

  @Override
  public SearchStream sorted(Comparator comparator) {
    return new WrapperSearchStream<>(backingStream.sorted(comparator));
  }

  @Override
  public SearchStream sorted(Comparator comparator, SortOrder order) {
    return new WrapperSearchStream<>(backingStream.sorted(comparator));
  }

  @Override
  public SearchStream peek(Consumer action) {
    return new WrapperSearchStream<>(backingStream.peek(action));
  }

  @Override
  public SearchStream limit(long maxSize) {
    return new WrapperSearchStream<>(backingStream.limit(maxSize));
  }

  @Override
  public SearchStream skip(long n) {
    return new WrapperSearchStream<>(backingStream.skip(n));
  }

  @Override
  public void forEach(Consumer action) {
    backingStream.forEach(action);
  }

  @Override
  public void forEachOrdered(Consumer action) {
    backingStream.forEachOrdered(action);
  }

  @Override
  public Object[] toArray() {
    return backingStream.toArray();
  }

  @Override
  public  A[] toArray(IntFunction generator) {
    return backingStream.toArray(generator);
  }

  @Override
  public E reduce(E identity, BinaryOperator accumulator) {
    return backingStream.reduce(identity, accumulator);
  }

  @Override
  public Optional reduce(BinaryOperator accumulator) {
    return backingStream.reduce(accumulator);
  }

  @Override
  public  U reduce(U identity, BiFunction accumulator, BinaryOperator combiner) {
    return backingStream.reduce(identity, accumulator, combiner);
  }

  @Override
  public  R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) {
    return backingStream.collect(supplier, accumulator, combiner);
  }

  @Override
  public  R collect(Collector collector) {
    return backingStream.collect(collector);
  }

  @Override
  public Optional min(Comparator comparator) {
    return backingStream.min(comparator);
  }

  @Override
  public Optional max(Comparator comparator) {
    return backingStream.max(comparator);
  }

  @Override
  public long count() {
    return backingStream.count();
  }

  @Override
  public boolean anyMatch(Predicate predicate) {
    return backingStream.anyMatch(predicate);
  }

  @Override
  public boolean allMatch(Predicate predicate) {
    return backingStream.allMatch(predicate);
  }

  @Override
  public boolean noneMatch(Predicate predicate) {
    return backingStream.noneMatch(predicate);
  }

  @Override
  public Optional findFirst() {
    return backingStream.findFirst();
  }

  @Override
  public Optional findAny() {
    return backingStream.findAny();
  }

  @Override
  public Stream map(ToLongFunction mapper) {
    return backingStream.mapToLong(mapper).boxed();
  }

  @Override
  public Stream> mapToLabelledMaps() {
    throw new UnsupportedOperationException("mapToLabelledMaps is not supported on a WrappedSearchStream");
  }

}