no.finn.lambdacompanion.ExtendedStream Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lambda-companion Show documentation
Functional structures and utilities for Java 8 and lambdas
There is a newer version: 0.27
package no.finn.lambdacompanion;

import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import java.util.Set;
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.Collectors;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;

/**
 * Wrapper around an {@link java.util.stream.Stream} that provides some missed functions like
 * {@link #foldRight(java.util.function.BiFunction, Object)}, {@link #toList()} and {@link #toSet()}
 */
public class ExtendedStream implements Stream {

    private final Stream delegate;

    protected ExtendedStream(final Stream delegate) {
        this.delegate = delegate;
    }

    public  R foldRight(final BiFunction accumulator, final R identity) {
        return Functions.foldRight(accumulator, identity, this.toList());
    }

    public  R foldLeft(final BiFunction accumulator, final R identity) {
        return Functions.foldLeft(accumulator, identity, this.toList());
    }

    public StreamableOptional findLast() {
        return StreamableOptional.ofOptional(this.reduce((a, b) -> b));
    }

    public List toList() {
        return collect(Collectors.toList());
    }

    public Set toSet() {
        return collect(Collectors.toSet());
    }

    // ---- Delegation of inherited methods

    @Override
    public  ExtendedStream map(final Function mapper) {
        return of(delegate.map(mapper));
    }

    @Override
    public  ExtendedStream flatMap(final Function> mapper) {
        return of(delegate.flatMap(mapper));
    }

    public  ExtendedStream flatMapCollection(final Function> mapper) {
        return of(delegate.map(mapper).flatMap(Collection::stream));
    }

    public  ExtendedStream flatMapOptional(final Function> mapper) {
        return of(delegate.map(mapper).flatMap(maybe -> maybe.map(Stream::of).orElseGet(Stream::empty)));
    }

    @Override
    public ExtendedStream filter(final Predicate predicate) {
        return of(delegate.filter(predicate));
    }

    @Override
    public ExtendedStream distinct() {
        return of(delegate.distinct());
    }

    @Override
    public ExtendedStream sorted() {
        return of(delegate.sorted());
    }

    @Override
    public ExtendedStream sorted(final Comparator comparator) {
        return of(delegate.sorted(comparator));
    }

    @Override
    public ExtendedStream peek(final Consumer action) {
        return of(delegate.peek(action));
    }

    @Override
    public ExtendedStream limit(final long maxSize) {
        return of(delegate.limit(maxSize));
    }

    @Override
    public ExtendedStream skip(final long n) {
        return of(delegate.skip(n));
    }

    @Override
    public ExtendedStream sequential() {
        return of(delegate.sequential());
    }

    @Override
    public ExtendedStream parallel() {
        return of(delegate.parallel());
    }

    @Override
    public ExtendedStream unordered() {
        return of(delegate.unordered());
    }

    @Override
    public ExtendedStream onClose(final Runnable closeHandler) {
        return of(delegate.onClose(closeHandler));
    }

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

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

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

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

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

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

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

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

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

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

    @Override
    public T reduce(final T identity, final BinaryOperator accumulator) {
        return delegate.reduce(identity, accumulator);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    public static  ExtendedStream of(final Stream stream) {
        return new ExtendedStream<>(stream);
    }

}