se.ugli.java.util.stream.ResourceStream Maven / Gradle / Ivy

Go to download
package se.ugli.java.util.stream;

import java.util.Comparator;
import java.util.Iterator;
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;

public class ResourceStream extends ResourceBase implements Stream {

    private final Stream stream;

    public ResourceStream(final Stream stream, final boolean closeOnTerminalOperation,
            final AutoCloseable... resources) {
        super(stream, closeOnTerminalOperation, resources);
        this.stream = stream;
    }

    @Override
    public Iterator iterator() {
        // This is a terminal operation
        return evalAndclose(() -> stream.iterator());
    }

    @Override
    public Spliterator spliterator() {
        // This is a terminal operation
        return evalAndclose(() -> stream.spliterator());
    }

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

    @Override
    public Stream sequential() {
        return new ResourceStream<>(stream.sequential(), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream parallel() {
        return new ResourceStream<>(stream.parallel(), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream unordered() {
        return new ResourceStream<>(stream.unordered(), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream onClose(final Runnable closeHandler) {
        return new ResourceStream<>(stream.onClose(closeHandler), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream filter(final Predicate predicate) {
        return new ResourceStream<>(stream.filter(predicate), closeOnTerminalOperation, resources);
    }

    @Override
    public  Stream map(final Function mapper) {
        return new ResourceStream<>(stream.map(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public IntStream mapToInt(final ToIntFunction mapper) {
        return new IntResourceStream(stream.mapToInt(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public LongStream mapToLong(final ToLongFunction mapper) {
        return new LongResourceStream(stream.mapToLong(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public DoubleStream mapToDouble(final ToDoubleFunction mapper) {
        return new DoubleResourceStream(stream.mapToDouble(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public  Stream flatMap(final Function> mapper) {
        return new ResourceStream<>(stream.flatMap(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public IntStream flatMapToInt(final Function mapper) {
        return new IntResourceStream(stream.flatMapToInt(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public LongStream flatMapToLong(final Function mapper) {
        return new LongResourceStream(stream.flatMapToLong(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public DoubleStream flatMapToDouble(final Function mapper) {
        return new DoubleResourceStream(stream.flatMapToDouble(mapper), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream distinct() {
        return new ResourceStream<>(stream.distinct(), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream sorted() {
        return new ResourceStream<>(stream.sorted(), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream sorted(final Comparator comparator) {
        return new ResourceStream<>(stream.sorted(comparator), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream peek(final Consumer action) {
        return new ResourceStream<>(stream.peek(action), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream limit(final long maxSize) {
        return new ResourceStream<>(stream.limit(maxSize), closeOnTerminalOperation, resources);
    }

    @Override
    public Stream skip(final long n) {
        return new ResourceStream<>(stream.skip(n), closeOnTerminalOperation, resources);
    }

    @Override
    public void forEach(final Consumer action) {
        // This is a terminal operation
        executeAndClose(() -> stream.forEach(action));
    }

    @Override
    public void forEachOrdered(final Consumer action) {
        // This is a terminal operation
        executeAndClose(() -> stream.forEachOrdered(action));
    }

    @Override
    public Object[] toArray() {
        // This is a terminal operation
        return evalAndclose(() -> stream.toArray());
    }

    @Override
    public  A[] toArray(final IntFunction generator) {
        // This is a terminal operation
        return evalAndclose(() -> stream.toArray(generator));
    }

    @Override
    public T reduce(final T identity, final BinaryOperator accumulator) {
        // This is a terminal operation
        return evalAndclose(() -> stream.reduce(identity, accumulator));
    }

    @Override
    public Optional reduce(final BinaryOperator accumulator) {
        // This is a terminal operation
        return evalAndclose(() -> stream.reduce(accumulator));
    }

    @Override
    public  U reduce(final U identity, final BiFunction accumulator,
            final BinaryOperator combiner) {
        // This is a terminal operation
        return evalAndclose(() -> stream.reduce(identity, accumulator, combiner));
    }

    @Override
    public  R collect(final Supplier supplier, final BiConsumer accumulator,
            final BiConsumer combiner) {
        // This is a terminal operation
        return evalAndclose(() -> stream.collect(supplier, accumulator, combiner));
    }

    @Override
    public  R collect(final Collector collector) {
        // This is a terminal operation
        return evalAndclose(() -> stream.collect(collector));
    }

    @Override
    public Optional min(final Comparator comparator) {
        // This is a terminal operation
        return evalAndclose(() -> stream.min(comparator));
    }

    @Override
    public Optional max(final Comparator comparator) {
        // This is a terminal operation
        return evalAndclose(() -> stream.max(comparator));
    }

    @Override
    public long count() {
        // This is a terminal operation
        return evalAndclose(() -> stream.count());
    }

    @Override
    public boolean anyMatch(final Predicate predicate) {
        // This is a terminal operation
        return evalAndclose(() -> stream.anyMatch(predicate));
    }

    @Override
    public boolean allMatch(final Predicate predicate) {
        // This is a terminal operation
        return evalAndclose(() -> stream.allMatch(predicate));
    }

    @Override
    public boolean noneMatch(final Predicate predicate) {
        // This is a terminal operation
        return evalAndclose(() -> stream.noneMatch(predicate));
    }

    @Override
    public Optional findFirst() {
        // This is a terminal operation
        return evalAndclose(() -> stream.findFirst());
    }

    @Override
    public Optional findAny() {
        // This is a terminal operation
        return evalAndclose(() -> stream.findAny());
    }

}