001/*
002 * The contents of this file are subject to the license and copyright
003 * detailed in the LICENSE and NOTICE files at the root of the source
004 * tree.
005 */
006package org.fcrepo.kernel.api.utils;
007
008import java.util.Comparator;
009import java.util.Iterator;
010import java.util.Optional;
011import java.util.Spliterator;
012import java.util.function.BiConsumer;
013import java.util.function.BiFunction;
014import java.util.function.BinaryOperator;
015import java.util.function.Consumer;
016import java.util.function.Function;
017import java.util.function.IntFunction;
018import java.util.function.Predicate;
019import java.util.function.Supplier;
020import java.util.function.ToDoubleFunction;
021import java.util.function.ToIntFunction;
022import java.util.function.ToLongFunction;
023import java.util.stream.Collector;
024import java.util.stream.DoubleStream;
025import java.util.stream.IntStream;
026import java.util.stream.LongStream;
027import java.util.stream.Stream;
028
029/**
030 * Partial Implementation of a Wrapping Stream
031 *
032 * @author acoburn
033 * @since Dec 6, 2015
034 */
035public abstract class WrappingStream<T> implements Stream<T> {
036
037    protected Stream<T> stream;
038
039    @Override
040    public boolean allMatch(final Predicate<? super T> predicate) {
041        return stream.allMatch(predicate);
042    }
043
044    @Override
045    public boolean anyMatch(final Predicate<? super T> predicate) {
046        return stream.anyMatch(predicate);
047    }
048
049    @Override
050    public <R, A> R collect(final Collector<? super T, A, R> collector) {
051        return stream.collect(collector);
052    }
053
054    @Override
055    public <R> R collect(final Supplier<R> supplier, final BiConsumer<R, ? super T> accumulator,
056            final BiConsumer<R,R> combiner) {
057        return stream.collect(supplier, accumulator, combiner);
058    }
059
060    @Override
061    public long count() {
062        return stream.count();
063    }
064
065    @Override
066    public Optional<T> findAny() {
067        return stream.findAny();
068    }
069
070    @Override
071    public Optional<T> findFirst() {
072        return stream.findFirst();
073    }
074
075    @Override
076    public <R> Stream<R> flatMap(final Function<? super T, ? extends Stream<? extends R>> mapper) {
077        return stream.flatMap(mapper);
078    }
079
080    @Override
081    public DoubleStream flatMapToDouble(final Function<? super T, ? extends DoubleStream> mapper) {
082        return stream.flatMapToDouble(mapper);
083    }
084
085    @Override
086    public IntStream flatMapToInt(final Function<? super T, ? extends IntStream> mapper) {
087        return stream.flatMapToInt(mapper);
088    }
089
090    @Override
091    public LongStream flatMapToLong(final Function<? super T, ? extends LongStream> mapper) {
092        return stream.flatMapToLong(mapper);
093    }
094
095    @Override
096    public void forEach(final Consumer<? super T> action) {
097        stream.forEach(action);
098    }
099
100    @Override
101    public void forEachOrdered(final Consumer<? super T> action) {
102        stream.forEachOrdered(action);
103    }
104
105    @Override
106    public <R> Stream<R> map(final Function<? super T,? extends R> mapper) {
107        return stream.map(mapper);
108    }
109
110    @Override
111    public DoubleStream mapToDouble(final ToDoubleFunction<? super T> mapper) {
112        return stream.mapToDouble(mapper);
113    }
114
115    @Override
116    public IntStream mapToInt(final ToIntFunction<? super T> mapper) {
117        return stream.mapToInt(mapper);
118    }
119
120    @Override
121    public LongStream mapToLong(final ToLongFunction<? super T> mapper) {
122        return stream.mapToLong(mapper);
123    }
124
125    @Override
126    public Optional<T> max(final Comparator<? super T> comparator) {
127        return stream.max(comparator);
128    }
129
130    @Override
131    public Optional<T> min(final Comparator<? super T> comparator) {
132        return stream.min(comparator);
133    }
134
135    @Override
136    public boolean noneMatch(final Predicate<? super T> predicate) {
137        return stream.noneMatch(predicate);
138    }
139
140    @Override
141    public Optional<T> reduce(final BinaryOperator<T> accumulator) {
142        return stream.reduce(accumulator);
143    }
144
145    @Override
146    public T reduce(final T identity, final BinaryOperator<T> accumulator) {
147        return stream.reduce(identity, accumulator);
148    }
149
150    @Override
151    public <U> U reduce(final U identity, final BiFunction<U,? super T,U> accumulator,
152            final BinaryOperator<U> combiner) {
153        return stream.reduce(identity, accumulator, combiner);
154    }
155
156    @Override
157    public Object[] toArray() {
158        return stream.toArray();
159    }
160
161    @Override
162    public <A> A[] toArray(final IntFunction<A[]> generator) {
163        return stream.toArray(generator);
164    }
165
166    @Override
167    public void close() {
168        stream.close();
169    }
170
171    @Override
172    public boolean isParallel() {
173        return stream.isParallel();
174    }
175
176    @Override
177    public Iterator<T> iterator() {
178        return stream.iterator();
179    }
180
181    @Override
182    public Spliterator<T> spliterator() {
183        return stream.spliterator();
184    }
185}