org.infinispan.stream.impl.local.LocalCacheStream Maven / Gradle / Ivy

Go to download
package org.infinispan.stream.impl.local;

import org.infinispan.Cache;
import org.infinispan.CacheStream;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.commons.util.Closeables;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.stream.CacheAware;
import org.infinispan.stream.impl.intops.object.*;

import java.util.Comparator;
import java.util.Optional;
import java.util.Set;
import java.util.Spliterator;
import java.util.concurrent.TimeUnit;
import java.util.function.*;
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;

/**
 * CacheStream that is to be used locally.  This allows for full functionality of a regular stream but also has options
 * to filter by keys and other functionality.
 * @param  type of the stream
 */
public class LocalCacheStream extends AbstractLocalCacheStream> implements CacheStream {

   public LocalCacheStream(StreamSupplier streamSupplier, boolean parallel, ComponentRegistry registry) {
      super(streamSupplier, parallel, registry);
   }

   public LocalCacheStream(AbstractLocalCacheStream other) {
      super(other);
   }

   @Override
   public CacheStream sequentialDistribution() {
      return this;
   }

   @Override
   public CacheStream parallelDistribution() {
      return this;
   }

   @Override
   public CacheStream filterKeySegments(Set segments) {
      segmentsToFilter = segments;
      return this;
   }

   @Override
   public CacheStream filterKeys(Set keys) {
      keysToFilter = keys;
      return this;
   }

   @Override
   public CacheStream distributedBatchSize(int batchSize) {
      // TODO: Does this change cache loader?
      return this;
   }

   @Override
   public CacheStream segmentCompletionListener(SegmentCompletionListener listener) {
      // All segments are completed when the getStream() is completed so we don't track them
      return this;
   }

   @Override
   public CacheStream disableRehashAware() {
      // Local stream doesn't matter for rehash
      return this;
   }

   @Override
   public Stream filter(Predicate predicate) {
      registry.wireDependencies(predicate);
      intermediateOperations.add(new FilterOperation<>(predicate));
      return this;
   }

   @Override
   public  Stream map(Function mapper) {
      registry.wireDependencies(mapper);
      intermediateOperations.add(new MapOperation<>(mapper));
      return (Stream) this;
   }

   @Override
   public IntStream mapToInt(ToIntFunction mapper) {
      intermediateOperations.add(new MapToIntOperation<>(mapper));
      return new LocalIntCacheStream(this);
   }

   @Override
   public LongStream mapToLong(ToLongFunction mapper) {
      intermediateOperations.add(new MapToLongOperation<>(mapper));
      return new LocalLongCacheStream(this);
   }

   @Override
   public DoubleStream mapToDouble(ToDoubleFunction mapper) {
      intermediateOperations.add(new MapToDoubleOperation<>(mapper));
      return new LocalDoubleCacheStream(this);
   }

   @Override
   public  Stream flatMap(Function> mapper) {
      intermediateOperations.add(new FlatMapOperation<>(mapper));
      return (Stream) this;
   }

   @Override
   public IntStream flatMapToInt(Function mapper) {
      intermediateOperations.add(new FlatMapToIntOperation<>(mapper));
      return new LocalIntCacheStream(this);
   }

   @Override
   public LongStream flatMapToLong(Function mapper) {
      intermediateOperations.add(new FlatMapToLongOperation<>(mapper));
      return new LocalLongCacheStream(this);
   }

   @Override
   public DoubleStream flatMapToDouble(Function mapper) {
      intermediateOperations.add(new FlatMapToDoubleOperation<>(mapper));
      return new LocalDoubleCacheStream(this);
   }

   @Override
   public Stream distinct() {
      intermediateOperations.add(DistinctOperation.getInstance());
      return this;
   }

   @Override
   public Stream sorted() {
      intermediateOperations.add(SortedOperation.getInstance());
      return this;
   }

   @Override
   public Stream sorted(Comparator comparator) {
      intermediateOperations.add(new SortedComparatorOperation<>(comparator));
      return this;
   }

   @Override
   public Stream peek(Consumer action) {
      intermediateOperations.add(new PeekOperation<>(action));
      return this;
   }

   @Override
   public Stream limit(long maxSize) {
      intermediateOperations.add(new LimitOperation<>(maxSize));
      return this;
   }

   @Override
   public Stream skip(long n) {
      intermediateOperations.add(new SkipOperation<>(n));
      return this;
   }

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

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

   /**
    * Method to inject a cache into a consumer.  Note we only support this for the consumer at this
    * time.
    * @param cacheAware the instance that may be a {@link CacheAware}
    */
   private void injectCache(Consumer cacheAware) {
      if (cacheAware instanceof CacheAware) {
         ((CacheAware) cacheAware).injectCache(registry.getComponent(Cache.class));
      }
   }

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

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

   @Override
   public R reduce(R identity, BinaryOperator accumulator) {
      return createStream().reduce(identity, accumulator);
   }

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

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

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

   @Override
   public  R1 collect(Collector collector) {
      return createStream().collect(collector);
   }

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

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

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

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

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

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

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

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

   @Override
   public CloseableIterator iterator() {
      // If the stream is null we can assume no intermediate operations and thus we can support remove
      if (intermediateOperations.isEmpty()) {
         return streamSupplier.removableIterator(Closeables.iterator(createStream()));
      } else {
         return Closeables.iterator(createStream());
      }
   }

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

   @Override
   public CacheStream timeout(long timeout, TimeUnit unit) {
      // Timeout does nothing for a local cache stream
      return this;
   }
}