1 /*

     2  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package java.util.stream;

    27 

    28 import java.util.Comparator;

    29 import java.util.Iterator;

    30 import java.util.Objects;

    31 import java.util.Optional;

    32 import java.util.Spliterator;

    33 import java.util.function.BiConsumer;

    34 import java.util.function.BiFunction;

    35 import java.util.function.BinaryOperator;

    36 import java.util.function.Consumer;

    37 import java.util.function.Function;

    38 import java.util.function.IntFunction;

    39 import java.util.function.Predicate;

    40 import java.util.function.Supplier;

    41 import java.util.function.ToDoubleFunction;

    42 import java.util.function.ToIntFunction;

    43 import java.util.function.ToLongFunction;

    44 

    45 /**

    46  * A {@code Stream} implementation that delegates operations to another {@code

    47  * Stream}.

    48  *

    49  * @param <T> type of stream elements for this stream and underlying delegate

    50  * stream

    51  *

    52  * @since 1.8

    53  */

    54 public class DelegatingStream<T> implements Stream<T> {

    55     final private Stream<T> delegate;

    56 

    57     /**

    58      * Construct a {@code Stream} that delegates operations to another {@code

    59      * Stream}.

    60      *

    61      * @param delegate the underlying {@link Stream} to which we delegate all

    62      *                 {@code Stream} methods

    63      * @throws NullPointerException if the delegate is null

    64      */

    65     public DelegatingStream(Stream<T> delegate) {

    66         this.delegate = Objects.requireNonNull(delegate);

    67     }

    68 

    69     // -- BaseStream methods --

    70 

    71     @Override

    72     public Spliterator<T> spliterator() {

    73         return delegate.spliterator();

    74     }

    75 

    76     @Override

    77     public boolean isParallel() {

    78         return delegate.isParallel();

    79     }

    80 

    81     @Override

    82     public Iterator<T> iterator() {

    83         return delegate.iterator();

    84     }

    85 

    86     // -- Stream methods --

    87 

    88     @Override

    89     public Stream<T> filter(Predicate<? super T> predicate) {

    90         return delegate.filter(predicate);

    91     }

    92 

    93     @Override

    94     public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {

    95         return delegate.map(mapper);

    96     }

    97 

    98     @Override

    99     public IntStream mapToInt(ToIntFunction<? super T> mapper) {

   100         return delegate.mapToInt(mapper);

   101     }

   102 

   103     @Override

   104     public LongStream mapToLong(ToLongFunction<? super T> mapper) {

   105         return delegate.mapToLong(mapper);

   106     }

   107 

   108     @Override

   109     public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {

   110         return delegate.mapToDouble(mapper);

   111     }

   112 

   113     @Override

   114     public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {

   115         return delegate.flatMap(mapper);

   116     }

   117 

   118     @Override

   119     public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {

   120         return delegate.flatMapToInt(mapper);

   121     }

   122 

   123     @Override

   124     public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {

   125         return delegate.flatMapToLong(mapper);

   126     }

   127 

   128     @Override

   129     public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {

   130         return delegate.flatMapToDouble(mapper);

   131     }

   132 

   133     @Override

   134     public Stream<T> distinct() {

   135         return delegate.distinct();

   136     }

   137 

   138     @Override

   139     public Stream<T> sorted() {

   140         return delegate.sorted();

   141     }

   142 

   143     @Override

   144     public Stream<T> sorted(Comparator<? super T> comparator) {

   145         return delegate.sorted(comparator);

   146     }

   147 

   148     @Override

   149     public void forEach(Consumer<? super T> action) {

   150         delegate.forEach(action);

   151     }

   152 

   153     @Override

   154     public void forEachOrdered(Consumer<? super T> action) {

   155         delegate.forEachOrdered(action);

   156     }

   157 

   158     @Override

   159     public Stream<T> peek(Consumer<? super T> consumer) {

   160         return delegate.peek(consumer);

   161     }

   162 

   163     @Override

   164     public Stream<T> limit(long maxSize) {

   165         return delegate.limit(maxSize);

   166     }

   167 

   168     @Override

   169     public Stream<T> substream(long startingOffset) {

   170         return delegate.substream(startingOffset);

   171     }

   172 

   173     @Override

   174     public Stream<T> substream(long startingOffset, long endingOffset) {

   175         return delegate.substream(startingOffset, endingOffset);

   176     }

   177 

   178     @Override

   179     public <A> A[] toArray(IntFunction<A[]> generator) {

   180         return delegate.toArray(generator);

   181     }

   182 

   183     @Override

   184     public Object[] toArray() {

   185         return delegate.toArray();

   186     }

   187 

   188     @Override

   189     public T reduce(T identity, BinaryOperator<T> accumulator) {

   190         return delegate.reduce(identity, accumulator);

   191     }

   192 

   193     @Override

   194     public Optional<T> reduce(BinaryOperator<T> accumulator) {

   195         return delegate.reduce(accumulator);

   196     }

   197 

   198     @Override

   199     public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator,

   200                         BinaryOperator<U> combiner) {

   201         return delegate.reduce(identity, accumulator, combiner);

   202     }

   203 

   204     @Override

   205     public <R> R collect(Supplier<R> resultFactory,

   206                          BiConsumer<R, ? super T> accumulator,

   207                          BiConsumer<R, R> combiner) {

   208         return delegate.collect(resultFactory, accumulator, combiner);

   209     }

   210 

   211     @Override

   212     public <R, A> R collect(Collector<? super T, A, ? extends R> collector) {

   213         return delegate.collect(collector);

   214     }

   215 

   216     @Override

   217     public Optional<T> max(Comparator<? super T> comparator) {

   218         return delegate.max(comparator);

   219     }

   220 

   221     @Override

   222     public Optional<T> min(Comparator<? super T> comparator) {

   223         return delegate.min(comparator);

   224     }

   225 

   226     @Override

   227     public long count() {

   228         return delegate.count();

   229     }

   230 

   231     @Override

   232     public boolean anyMatch(Predicate<? super T> predicate) {

   233         return delegate.anyMatch(predicate);

   234     }

   235 

   236     @Override

   237     public boolean allMatch(Predicate<? super T> predicate) {

   238         return delegate.allMatch(predicate);

   239     }

   240 

   241     @Override

   242     public boolean noneMatch(Predicate<? super T> predicate) {

   243         return delegate.noneMatch(predicate);

   244     }

   245 

   246     @Override

   247     public Optional<T> findFirst() {

   248         return delegate.findFirst();

   249     }

   250 

   251     @Override

   252     public Optional<T> findAny() {

   253         return delegate.findAny();

   254     }

   255 

   256     @Override

   257     public Stream<T> unordered() {

   258         return delegate.unordered();

   259     }

   260 

   261     @Override

   262     public Stream<T> sequential() {

   263         return delegate.sequential();

   264     }

   265 

   266     @Override

   267     public Stream<T> parallel() {

   268         return delegate.parallel();

   269     }

   270 }