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}