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