org.jobrunr.storage.nosql.redis.AbstractPipelinedStream Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jobrunr Show documentation
An easy way to perform background processing on the JVM. Backed by persistent storage. Open and free for commercial use.
There is a newer version: 7.3.1
Show newest version
package org.jobrunr.storage.nosql.redis;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Optional;
import java.util.Spliterator;
import java.util.function.*;
import java.util.stream.*;

public abstract class AbstractPipelinedStream implements Stream {

    protected final Stream initialStream;

    protected AbstractPipelinedStream(Stream initialStream) {
        this.initialStream = initialStream;
    }

    @Override
    public Stream filter(Predicate predicate) {
        return initialStream.filter(predicate);
    }

    @Override
    public  Stream map(Function function) {
        return initialStream.map(function);
    }

    @Override
    public IntStream mapToInt(ToIntFunction toIntFunction) {
        return initialStream.mapToInt(toIntFunction);
    }

    @Override
    public LongStream mapToLong(ToLongFunction toLongFunction) {
        return initialStream.mapToLong(toLongFunction);
    }

    @Override
    public DoubleStream mapToDouble(ToDoubleFunction toDoubleFunction) {
        return initialStream.mapToDouble(toDoubleFunction);
    }

    @Override
    public  Stream flatMap(Function> function) {
        return initialStream.flatMap(function);
    }

    @Override
    public IntStream flatMapToInt(Function function) {
        return initialStream.flatMapToInt(function);
    }

    @Override
    public LongStream flatMapToLong(Function function) {
        return initialStream.flatMapToLong(function);
    }

    @Override
    public DoubleStream flatMapToDouble(Function function) {
        return initialStream.flatMapToDouble(function);
    }

    @Override
    public Stream distinct() {
        return initialStream.distinct();
    }

    @Override
    public Stream sorted() {
        return initialStream.sorted();
    }

    @Override
    public Stream sorted(Comparator comparator) {
        return initialStream.sorted(comparator);
    }

    @Override
    public Stream peek(Consumer consumer) {
        return initialStream.peek(consumer);
    }

    @Override
    public void forEach(Consumer consumer) {
        initialStream.forEach(consumer);
    }

    @Override
    public void forEachOrdered(Consumer consumer) {
        initialStream.forEachOrdered(consumer);
    }

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

    @Override
    public  A[] toArray(IntFunction intFunction) {
        return initialStream.toArray(intFunction);
    }

    @Override
    public T reduce(T t, BinaryOperator binaryOperator) {
        return initialStream.reduce(t, binaryOperator);
    }

    @Override
    public Optional reduce(BinaryOperator binaryOperator) {
        return initialStream.reduce(binaryOperator);
    }

    @Override
    public  U reduce(U u, BiFunction biFunction, BinaryOperator binaryOperator) {
        return initialStream.reduce(u, biFunction, binaryOperator);
    }

    @Override
    public  R collect(Supplier supplier, BiConsumer biConsumer, BiConsumer biConsumer1) {
        return initialStream.collect(supplier, biConsumer, biConsumer1);
    }

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

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

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

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

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

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

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

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

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

    public static  Builder builder() {
        return Stream.builder();
    }

    public static  Stream empty() {
        return Stream.empty();
    }

    public static  Stream of(T1 t1) {
        return Stream.of(t1);
    }

    @SafeVarargs
    public static  Stream of(T1... values) {
        return Stream.of(values);
    }

    public static  Stream iterate(T1 seed, UnaryOperator f) {
        return Stream.iterate(seed, f);
    }

    public static  Stream generate(Supplier s) {
        return Stream.generate(s);
    }

    public static  Stream concat(Stream a, Stream b) {
        return Stream.concat(a, b);
    }

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

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

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

    @Override
    public Stream sequential() {
        return initialStream.sequential();
    }

    @Override
    public Stream parallel() {
        return initialStream.parallel();
    }

    @Override
    public Stream unordered() {
        return initialStream.unordered();
    }

    @Override
    public Stream onClose(Runnable runnable) {
        return initialStream.onClose(runnable);
    }

    @Override
    public void close() {
        initialStream.close();
    }
}