org.apache.commons.io.function.IOStream Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.io.function;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Optional;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BiFunction;
import java.util.function.IntFunction;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.UnaryOperator;
import java.util.stream.Collector;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.apache.commons.io.IOExceptionList;
/**
* Like {@link Stream} but throws {@link IOException}.
*
* @param the type of the stream elements.
* @since 2.12.0
*/
public interface IOStream extends IOBaseStream, Stream> {
/**
* Constructs a new IOStream for the given Stream.
*
* @param the type of the stream elements.
* @param stream The stream to delegate.
* @return a new IOStream.
*/
static IOStream adapt(final Stream stream) {
return IOStreamAdapter.adapt(stream);
}
/**
* This class' version of {@link Stream#empty()}.
*
* @param the type of the stream elements
* @return an empty sequential {@code IOStreamImpl}.
* @see Stream#empty()
*/
static IOStream empty() {
return IOStreamAdapter.adapt(Stream.empty());
}
/**
* Like {@link Stream#iterate(Object, UnaryOperator)} but for IO.
*
* @param the type of stream elements.
* @param seed the initial element.
* @param f a function to be applied to the previous element to produce a new element.
* @return a new sequential {@code IOStream}.
*/
static IOStream iterate(final T seed, final IOUnaryOperator f) {
Objects.requireNonNull(f);
final Iterator iterator = new Iterator() {
@SuppressWarnings("unchecked")
T t = (T) IOStreams.NONE;
@Override
public boolean hasNext() {
return true;
}
@Override
public T next() throws NoSuchElementException {
try {
return t = t == IOStreams.NONE ? seed : f.apply(t);
} catch (final IOException e) {
final NoSuchElementException nsee = new NoSuchElementException();
nsee.initCause(e);
throw nsee;
}
}
};
return adapt(StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED | Spliterator.IMMUTABLE), false));
}
/**
* Null-safe version of {@link StreamSupport#stream(java.util.Spliterator, boolean)}.
*
* Copied from Apache Commons Lang.
*
* @param the type of stream elements.
* @param values the elements of the new stream, may be {@code null}.
* @return the new stream on {@code values} or {@link Stream#empty()}.
*/
@SuppressWarnings("resource") // call to #empty()
static IOStream of(final Iterable values) {
return values == null ? empty() : adapt(StreamSupport.stream(values.spliterator(), false));
}
/**
* Null-safe version of {@link Stream#of(Object[])} for an IO stream.
*
* @param the type of stream elements.
* @param values the elements of the new stream, may be {@code null}.
* @return the new stream on {@code values} or {@link Stream#empty()}.
*/
@SuppressWarnings("resource")
@SafeVarargs // Creating a stream from an array is safe
static IOStream of(final T... values) {
return values == null || values.length == 0 ? empty() : adapt(Arrays.stream(values));
}
/**
* Returns a sequential {@code IOStreamImpl} containing a single element.
*
* @param t the single element
* @param the type of stream elements
* @return a singleton sequential stream
*/
static IOStream of(final T t) {
return adapt(Stream.of(t));
}
/**
* Like {@link Stream#allMatch(java.util.function.Predicate)} but throws {@link IOException}.
*
* @param predicate {@link Stream#allMatch(java.util.function.Predicate)}.
* @return Like {@link Stream#allMatch(java.util.function.Predicate)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default boolean allMatch(final IOPredicate predicate) throws IOException {
return unwrap().allMatch(t -> Erase.test(predicate, t));
}
/**
* Like {@link Stream#anyMatch(java.util.function.Predicate)} but throws {@link IOException}.
*
* @param predicate {@link Stream#anyMatch(java.util.function.Predicate)}.
* @return Like {@link Stream#anyMatch(java.util.function.Predicate)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default boolean anyMatch(final IOPredicate predicate) throws IOException {
return unwrap().anyMatch(t -> Erase.test(predicate, t));
}
/**
* TODO Package-private for now, needs IOCollector?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#collect(Collector)}.
*
* Package private for now.
*
* @param Like {@link Stream#collect(Collector)}.
* @param Like {@link Stream#collect(Collector)}.
* @param collector Like {@link Stream#collect(Collector)}.
* @return Like {@link Stream#collect(Collector)}.
*/
default R collect(final Collector collector) {
return unwrap().collect(collector);
}
/**
* Like
* {@link Stream#collect(java.util.function.Supplier, java.util.function.BiConsumer, java.util.function.BiConsumer)}.
*
* @param Like
* {@link Stream#collect(java.util.function.Supplier, java.util.function.BiConsumer, java.util.function.BiConsumer)}.
* @param supplier Like
* {@link Stream#collect(java.util.function.Supplier, java.util.function.BiConsumer, java.util.function.BiConsumer)}.
* @param accumulator Like
* {@link Stream#collect(java.util.function.Supplier, java.util.function.BiConsumer, java.util.function.BiConsumer)}.
* @param combiner Like
* {@link Stream#collect(java.util.function.Supplier, java.util.function.BiConsumer, java.util.function.BiConsumer)}.
* @return Like
* {@link Stream#collect(java.util.function.Supplier, java.util.function.BiConsumer, java.util.function.BiConsumer)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default R collect(final IOSupplier supplier, final IOBiConsumer accumulator, final IOBiConsumer combiner) throws IOException {
return unwrap().collect(() -> Erase.get(supplier), (t, u) -> Erase.accept(accumulator, t, u), (t, u) -> Erase.accept(combiner, t, u));
}
/**
* Like {@link Stream#count()}.
*
* @return Like {@link Stream#count()}.
*/
default long count() {
return unwrap().count();
}
/**
* Like {@link Stream#distinct()}.
*
* @return Like {@link Stream#distinct()}.
*/
default IOStream distinct() {
return adapt(unwrap().distinct());
}
/**
* Like {@link Stream#filter(java.util.function.Predicate)}.
*
* @param predicate Like {@link Stream#filter(java.util.function.Predicate)}.
* @return Like {@link Stream#filter(java.util.function.Predicate)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default IOStream filter(final IOPredicate predicate) throws IOException {
return adapt(unwrap().filter(t -> Erase.test(predicate, t)));
}
/**
* Like {@link Stream#findAny()}.
*
* @return Like {@link Stream#findAny()}.
*/
default Optional findAny() {
return unwrap().findAny();
}
/**
* Like {@link Stream#findFirst()}.
*
* @return Like {@link Stream#findFirst()}.
*/
default Optional findFirst() {
return unwrap().findFirst();
}
/**
* Like {@link Stream#flatMap(java.util.function.Function)}.
*
* @param Like {@link Stream#flatMap(java.util.function.Function)}.
* @param mapper Like {@link Stream#flatMap(java.util.function.Function)}.
* @return Like {@link Stream#flatMap(java.util.function.Function)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default IOStream flatMap(final IOFunction> mapper) throws IOException {
return adapt(unwrap().flatMap(t -> Erase.apply(mapper, t).unwrap()));
}
/**
* TODO Package-private for now, needs IODoubleStream?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#flatMapToDouble(java.util.function.Function)}.
*
* @param mapper Like {@link Stream#flatMapToDouble(java.util.function.Function)}.
* @return Like {@link Stream#flatMapToDouble(java.util.function.Function)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default DoubleStream flatMapToDouble(final IOFunction mapper) throws IOException {
return unwrap().flatMapToDouble(t -> Erase.apply(mapper, t));
}
/**
* TODO Package-private for now, needs IOIntStream?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#flatMapToInt(java.util.function.Function)}.
*
* @param mapper Like {@link Stream#flatMapToInt(java.util.function.Function)}.
* @return Like {@link Stream#flatMapToInt(java.util.function.Function)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default IntStream flatMapToInt(final IOFunction mapper) throws IOException {
return unwrap().flatMapToInt(t -> Erase.apply(mapper, t));
}
/**
* TODO Package-private for now, needs IOLongStream?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#flatMapToLong(java.util.function.Function)}.
*
* @param mapper Like {@link Stream#flatMapToLong(java.util.function.Function)}.
* @return Like {@link Stream#flatMapToLong(java.util.function.Function)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default LongStream flatMapToLong(final IOFunction mapper) throws IOException {
return unwrap().flatMapToLong(t -> Erase.apply(mapper, t));
}
/**
* Performs an action for each element gathering any exceptions.
*
* @param action The action to apply to each element.
* @throws IOExceptionList if any I/O errors occur.
*/
default void forAll(final IOConsumer action) throws IOExceptionList {
forAll(action, (i, e) -> e);
}
/**
* Performs an action for each element gathering any exceptions.
*
* @param action The action to apply to each element.
* @param exSupplier The exception supplier.
* @throws IOExceptionList if any I/O errors occur.
*/
default void forAll(final IOConsumer action, final BiFunction exSupplier) throws IOExceptionList {
final AtomicReference> causeList = new AtomicReference<>();
final AtomicInteger index = new AtomicInteger();
final IOConsumer safeAction = IOStreams.toIOConsumer(action);
unwrap().forEach(e -> {
try {
safeAction.accept(e);
} catch (final IOException innerEx) {
if (causeList.get() == null) {
// Only allocate if required
causeList.set(new ArrayList<>());
}
if (exSupplier != null) {
causeList.get().add(exSupplier.apply(index.get(), innerEx));
}
}
index.incrementAndGet();
});
IOExceptionList.checkEmpty(causeList.get(), null);
}
/**
* Like {@link Stream#forEach(java.util.function.Consumer)} but throws {@link IOException}.
*
* @param action Like {@link Stream#forEach(java.util.function.Consumer)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default void forEach(final IOConsumer action) throws IOException {
unwrap().forEach(e -> Erase.accept(action, e));
}
/**
* Like {@link Stream#forEachOrdered(java.util.function.Consumer)}.
*
* @param action Like {@link Stream#forEachOrdered(java.util.function.Consumer)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default void forEachOrdered(final IOConsumer action) throws IOException {
unwrap().forEachOrdered(e -> Erase.accept(action, e));
}
/**
* Like {@link Stream#limit(long)}.
*
* @param maxSize Like {@link Stream#limit(long)}.
* @return Like {@link Stream#limit(long)}.
*/
default IOStream limit(final long maxSize) {
return adapt(unwrap().limit(maxSize));
}
/**
* Like {@link Stream#map(java.util.function.Function)}.
*
* @param Like {@link Stream#map(java.util.function.Function)}.
* @param mapper Like {@link Stream#map(java.util.function.Function)}.
* @return Like {@link Stream#map(java.util.function.Function)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default IOStream map(final IOFunction mapper) throws IOException {
return adapt(unwrap().map(t -> Erase.apply(mapper, t)));
}
/**
* TODO Package-private for now, needs IOToDoubleFunction?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#mapToDouble(ToDoubleFunction)}.
*
* Package private for now.
*
* @param mapper Like {@link Stream#mapToDouble(ToDoubleFunction)}.
* @return Like {@link Stream#mapToDouble(ToDoubleFunction)}.
*/
default DoubleStream mapToDouble(final ToDoubleFunction mapper) {
return unwrap().mapToDouble(mapper);
}
/**
* TODO Package-private for now, needs IOToIntFunction?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#mapToInt(ToIntFunction)}.
*
* Package private for now.
*
* @param mapper Like {@link Stream#mapToInt(ToIntFunction)}.
* @return Like {@link Stream#mapToInt(ToIntFunction)}.
*/
default IntStream mapToInt(final ToIntFunction mapper) {
return unwrap().mapToInt(mapper);
}
/**
* TODO Package-private for now, needs IOToLongFunction?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#mapToLong(ToLongFunction)}.
*
* Package private for now.
*
* @param mapper Like {@link Stream#mapToLong(ToLongFunction)}.
* @return Like {@link Stream#mapToLong(ToLongFunction)}.
*/
default LongStream mapToLong(final ToLongFunction mapper) {
return unwrap().mapToLong(mapper);
}
/**
* Like {@link Stream#max(java.util.Comparator)}.
*
* @param comparator Like {@link Stream#max(java.util.Comparator)}.
* @return Like {@link Stream#max(java.util.Comparator)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default Optional max(final IOComparator comparator) throws IOException {
return unwrap().max((t, u) -> Erase.compare(comparator, t, u));
}
/**
* Like {@link Stream#min(java.util.Comparator)}.
*
* @param comparator Like {@link Stream#min(java.util.Comparator)}.
* @return Like {@link Stream#min(java.util.Comparator)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default Optional min(final IOComparator comparator) throws IOException {
return unwrap().min((t, u) -> Erase.compare(comparator, t, u));
}
/**
* Like {@link Stream#noneMatch(java.util.function.Predicate)}.
*
* @param predicate Like {@link Stream#noneMatch(java.util.function.Predicate)}.
* @return Like {@link Stream#noneMatch(java.util.function.Predicate)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default boolean noneMatch(final IOPredicate predicate) throws IOException {
return unwrap().noneMatch(t -> Erase.test(predicate, t));
}
/**
* Like {@link Stream#peek(java.util.function.Consumer)}.
*
* @param action Like {@link Stream#peek(java.util.function.Consumer)}.
* @return Like {@link Stream#peek(java.util.function.Consumer)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default IOStream peek(final IOConsumer action) throws IOException {
return adapt(unwrap().peek(t -> Erase.accept(action, t)));
}
/**
* Like {@link Stream#reduce(java.util.function.BinaryOperator)}.
*
* @param accumulator Like {@link Stream#reduce(java.util.function.BinaryOperator)}.
* @return Like {@link Stream#reduce(java.util.function.BinaryOperator)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default Optional reduce(final IOBinaryOperator accumulator) throws IOException {
return unwrap().reduce((t, u) -> Erase.apply(accumulator, t, u));
}
/**
* Like {@link Stream#reduce(Object, java.util.function.BinaryOperator)}.
*
* @param identity Like {@link Stream#reduce(Object, java.util.function.BinaryOperator)}.
* @param accumulator Like {@link Stream#reduce(Object, java.util.function.BinaryOperator)}.
* @return Like {@link Stream#reduce(Object, java.util.function.BinaryOperator)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default T reduce(final T identity, final IOBinaryOperator accumulator) throws IOException {
return unwrap().reduce(identity, (t, u) -> Erase.apply(accumulator, t, u));
}
/**
* Like {@link Stream#reduce(Object, BiFunction, java.util.function.BinaryOperator)}.
*
* @param Like {@link Stream#reduce(Object, BiFunction, java.util.function.BinaryOperator)}.
* @param identity Like {@link Stream#reduce(Object, BiFunction, java.util.function.BinaryOperator)}.
* @param accumulator Like {@link Stream#reduce(Object, BiFunction, java.util.function.BinaryOperator)}.
* @param combiner Like {@link Stream#reduce(Object, BiFunction, java.util.function.BinaryOperator)}.
* @return Like {@link Stream#reduce(Object, BiFunction, java.util.function.BinaryOperator)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default U reduce(final U identity, final IOBiFunction accumulator, final IOBinaryOperator combiner) throws IOException {
return unwrap().reduce(identity, (t, u) -> Erase.apply(accumulator, t, u), (t, u) -> Erase.apply(combiner, t, u));
}
/**
* Like {@link Stream#skip(long)}.
*
* @param n Like {@link Stream#skip(long)}.
* @return Like {@link Stream#skip(long)}.
*/
default IOStream skip(final long n) {
return adapt(unwrap().skip(n));
}
/**
* Like {@link Stream#sorted()}.
*
* @return Like {@link Stream#sorted()}.
*/
default IOStream sorted() {
return adapt(unwrap().sorted());
}
/**
* Like {@link Stream#sorted(java.util.Comparator)}.
*
* @param comparator Like {@link Stream#sorted(java.util.Comparator)}.
* @return Like {@link Stream#sorted(java.util.Comparator)}.
* @throws IOException if an I/O error occurs.
*/
@SuppressWarnings("unused") // thrown by Erase.
default IOStream sorted(final IOComparator comparator) throws IOException {
return adapt(unwrap().sorted((t, u) -> Erase.compare(comparator, t, u)));
}
/**
* Like {@link Stream#toArray()}.
*
* @return {@link Stream#toArray()}.
*/
default Object[] toArray() {
return unwrap().toArray();
}
/**
* TODO Package-private for now, needs IOIntFunction?
*
* Adding this method now and an IO version later is an issue because call sites would have to type-cast to pick one. It
* would be ideal to have only one.
*
* Like {@link Stream#toArray(IntFunction)}.
*
* Package private for now.
*
* @param Like {@link Stream#toArray(IntFunction)}.
* @param generator Like {@link Stream#toArray(IntFunction)}.
* @return Like {@link Stream#toArray(IntFunction)}.
*/
default A[] toArray(final IntFunction generator) {
return unwrap().toArray(generator);
}
}