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

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

import java.util.Comparator;
import java.util.Map;
import java.util.Optional;
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.BaseStream;
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 interface SearchStream extends BaseStream> {

  SearchStream filter(SearchFieldPredicate predicate);

  SearchStream filter(Predicate predicate);

   SearchStream map(Function field);
  
  Stream map(ToLongFunction mapper);

  IntStream mapToInt(ToIntFunction mapper);

  LongStream mapToLong(ToLongFunction mapper);

  DoubleStream mapToDouble(ToDoubleFunction mapper);

   SearchStream flatMap(Function> mapper);

  IntStream flatMapToInt(Function mapper);

  LongStream flatMapToLong(Function mapper);

  DoubleStream flatMapToDouble(Function mapper);

  SearchStream sorted(Comparator comparator);

  SearchStream sorted(Comparator comparator, SortOrder order);

  SearchStream peek(Consumer action);

  SearchStream limit(long maxSize);

  SearchStream skip(long n);

  void forEach(Consumer action);

  void forEachOrdered(Consumer action);

  Object[] toArray();

   A[] toArray(IntFunction generator);

  E reduce(E identity, BinaryOperator accumulator);

  Optional reduce(BinaryOperator accumulator);

   U reduce(U identity, BiFunction accumulator, BinaryOperator combiner);

   R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner);

   R collect(Collector collector);

  Optional min(Comparator comparator);

  Optional max(Comparator comparator);

  long count();

  boolean anyMatch(Predicate predicate);

  boolean allMatch(Predicate predicate);

  boolean noneMatch(Predicate predicate);

  Optional findFirst();

  Optional findAny();
  
  Stream> mapToLabelledMaps();
}