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}