001/*
002 * Copyright 2015 DuraSpace, Inc.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 *     http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.fcrepo.kernel.api.utils;
017
018import java.util.Comparator;
019import java.util.Iterator;
020import java.util.Optional;
021import java.util.Spliterator;
022import java.util.function.BiConsumer;
023import java.util.function.BiFunction;
024import java.util.function.BinaryOperator;
025import java.util.function.Consumer;
026import java.util.function.Function;
027import java.util.function.IntFunction;
028import java.util.function.Predicate;
029import java.util.function.Supplier;
030import java.util.function.ToDoubleFunction;
031import java.util.function.ToIntFunction;
032import java.util.function.ToLongFunction;
033import java.util.stream.Collector;
034import java.util.stream.DoubleStream;
035import java.util.stream.IntStream;
036import java.util.stream.LongStream;
037import java.util.stream.Stream;
038
039/**
040 * Partial Implementation of a Wrapping Stream
041 *
042 * @author acoburn
043 * @since Dec 6, 2015
044 */
045public abstract class WrappingStream<T> implements Stream<T> {
046
047    protected Stream<T> stream;
048
049    @Override
050    public boolean allMatch(final Predicate<? super T> predicate) {
051        return stream.allMatch(predicate);
052    }
053
054    @Override
055    public boolean anyMatch(final Predicate<? super T> predicate) {
056        return stream.anyMatch(predicate);
057    }
058
059    @Override
060    public <R, A> R collect(final Collector<? super T, A, R> collector) {
061        return stream.collect(collector);
062    }
063
064    @Override
065    public <R> R collect(final Supplier<R> supplier, final BiConsumer<R, ? super T> accumulator,
066            final BiConsumer<R,R> combiner) {
067        return stream.collect(supplier, accumulator, combiner);
068    }
069
070    @Override
071    public long count() {
072        return stream.count();
073    }
074
075    @Override
076    public Optional<T> findAny() {
077        return stream.findAny();
078    }
079
080    @Override
081    public Optional<T> findFirst() {
082        return stream.findFirst();
083    }
084
085    @Override
086    public <R> Stream<R> flatMap(final Function<? super T, ? extends Stream<? extends R>> mapper) {
087        return stream.flatMap(mapper);
088    }
089
090    @Override
091    public DoubleStream flatMapToDouble(final Function<? super T, ? extends DoubleStream> mapper) {
092        return stream.flatMapToDouble(mapper);
093    }
094
095    @Override
096    public IntStream flatMapToInt(final Function<? super T, ? extends IntStream> mapper) {
097        return stream.flatMapToInt(mapper);
098    }
099
100    @Override
101    public LongStream flatMapToLong(final Function<? super T, ? extends LongStream> mapper) {
102        return stream.flatMapToLong(mapper);
103    }
104
105    @Override
106    public void forEach(final Consumer<? super T> action) {
107        stream.forEach(action);
108    }
109
110    @Override
111    public void forEachOrdered(final Consumer<? super T> action) {
112        stream.forEachOrdered(action);
113    }
114
115    @Override
116    public <R> Stream<R> map(final Function<? super T,? extends R> mapper) {
117        return stream.map(mapper);
118    }
119
120    @Override
121    public DoubleStream mapToDouble(final ToDoubleFunction<? super T> mapper) {
122        return stream.mapToDouble(mapper);
123    }
124
125    @Override
126    public IntStream mapToInt(final ToIntFunction<? super T> mapper) {
127        return stream.mapToInt(mapper);
128    }
129
130    @Override
131    public LongStream mapToLong(final ToLongFunction<? super T> mapper) {
132        return stream.mapToLong(mapper);
133    }
134
135    @Override
136    public Optional<T> max(final Comparator<? super T> comparator) {
137        return stream.max(comparator);
138    }
139
140    @Override
141    public Optional<T> min(final Comparator<? super T> comparator) {
142        return stream.min(comparator);
143    }
144
145    @Override
146    public boolean noneMatch(final Predicate<? super T> predicate) {
147        return stream.noneMatch(predicate);
148    }
149
150    @Override
151    public Optional<T> reduce(final BinaryOperator<T> accumulator) {
152        return stream.reduce(accumulator);
153    }
154
155    @Override
156    public T reduce(final T identity, final BinaryOperator<T> accumulator) {
157        return stream.reduce(identity, accumulator);
158    }
159
160    @Override
161    public <U> U reduce(final U identity, final BiFunction<U,? super T,U> accumulator,
162            final BinaryOperator<U> combiner) {
163        return stream.reduce(identity, accumulator, combiner);
164    }
165
166    @Override
167    public Object[] toArray() {
168        return stream.toArray();
169    }
170
171    @Override
172    public <A> A[] toArray(final IntFunction<A[]> generator) {
173        return stream.toArray(generator);
174    }
175
176    @Override
177    public void close() {
178        stream.close();
179    }
180
181    @Override
182    public boolean isParallel() {
183        return stream.isParallel();
184    }
185
186    @Override
187    public Iterator<T> iterator() {
188        return stream.iterator();
189    }
190
191    @Override
192    public Spliterator<T> spliterator() {
193        return stream.spliterator();
194    }
195}