Merge branch 'master' into IOUtils-closewitherrors

Author: wodencafe

src/changes/changes.xml

@@ -120,6 +120,12 @@ The <action> type attribute can be add,update,fix,remove.
       <action dev="ggregory" type="fix" due-to="Arturo Bernal">
         Minor changes #287.
       </action>
+      <action issue="IO-756" dev="ggregory" type="fix" due-to="wodencafe, Gary Gregory, Bruno P. Kinoshita">
+        Update FileWriterWithEncoding to extend ProxyWriter #296.
+      </action>
+      <action dev="ggregory" type="fix" due-to="Gary Gregory">
+        Initialize the message of an IOExceptionList to a default if null.
+      </action>
       <!-- ADD -->
       <action dev="ggregory" type="add" due-to="Gary Gregory">
         Add BrokenReader.INSTANCE.
@@ -275,6 +281,15 @@ The <action> type attribute can be add,update,fix,remove.
       <action dev="ggregory" type="add" due-to="Gary Gregory">
         Add PathUtils.readAttributes(Path, Class, LinkOption...). #290
       </action>
+      <action dev="ggregory" type="add" due-to="Gary Gregory">
+        Add IOExceptionList.checkEmpty(List, Object).
+      </action>
+      <action dev="ggregory" type="add" due-to="Gary Gregory">
+        Add IOBiConsumer.
+      </action>
+      <action dev="ggregory" type="add" due-to="Gary Gregory">
+        Add and reuse IOConsumer.forEach(T[], IOConsumer) and forEachIndexed(Stream, IOConsumer).
+      </action>
       <!-- UPDATE -->
       <action dev="ggregory" type="add" due-to="Gary Gregory">
         Update FileEntry to use FileTime instead of long for file time stamps.

src/main/java/org/apache/commons/io/FileUtils.java

@@ -76,6 +76,7 @@
 import org.apache.commons.io.filefilter.IOFileFilter;
 import org.apache.commons.io.filefilter.SuffixFileFilter;
 import org.apache.commons.io.filefilter.TrueFileFilter;
+import org.apache.commons.io.function.IOConsumer;
 
 /**
  * General file manipulation utilities.
@@ -340,20 +341,7 @@ public static long checksumCRC32(final File file) throws IOException {
      * @see #forceDelete(File)
      */
     public static void cleanDirectory(final File directory) throws IOException {
-        final File[] files = listFiles(directory, null);
-
-        final List<Exception> causeList = new ArrayList<>();
-        for (final File file : files) {
-            try {
-                forceDelete(file);
-            } catch (final IOException ioe) {
-                causeList.add(ioe);
-            }
-        }
-
-        if (!causeList.isEmpty()) {
-            throw new IOExceptionList(directory.toString(), causeList);
-        }
+        IOConsumer.forEach(listFiles(directory, null), file -> forceDelete(file));
     }
 
     /**
@@ -366,20 +354,7 @@ public static void cleanDirectory(final File directory) throws IOException {
      * @see #forceDeleteOnExit(File)
      */
     private static void cleanDirectoryOnExit(final File directory) throws IOException {
-        final File[] files = listFiles(directory, null);
-
-        final List<Exception> causeList = new ArrayList<>();
-        for (final File file : files) {
-            try {
-                forceDeleteOnExit(file);
-            } catch (final IOException ioe) {
-                causeList.add(ioe);
-            }
-        }
-
-        if (!causeList.isEmpty()) {
-            throw new IOExceptionList(causeList);
-        }
+        IOConsumer.forEach(listFiles(directory, null), file -> forceDeleteOnExit(file));
     }
 
     /**

src/main/java/org/apache/commons/io/IOExceptionList.java

@@ -20,9 +20,10 @@
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 /**
- * A IOException based on a list of Throwable causes.
+ * An IOException based on a list of Throwable causes.
  * <p>
  * The first exception in the list is used as this exception's cause and is accessible with the usual
  * {@link #getCause()} while the complete list is accessible with {@link #getCauseList()}.
@@ -33,6 +34,29 @@
 public class IOExceptionList extends IOException {
 
     private static final long serialVersionUID = 1L;
+
+    /**
+     * Throws this exception if the list is not null or empty.
+     *
+     * @param causeList The list to test.
+     * @param message The detail message, see {@link #getMessage()}.
+     * @throws IOExceptionList if the list is not null or empty.
+     * @since 2.12.0
+     */
+    public static void checkEmpty(final List<? extends Throwable> causeList, final Object message) throws IOExceptionList {
+        if (!isEmpty(causeList)) {
+            throw new IOExceptionList(Objects.toString(message, null), causeList);
+        }
+    }
+
+    private static boolean isEmpty(final List<? extends Throwable> causeList) {
+        return causeList == null || causeList.isEmpty();
+    }
+
+    private static String toMessage(final List<? extends Throwable> causeList) {
+        return String.format("%,d exception(s): %s", causeList == null ? 0 : causeList.size(), causeList);
+    }
+
     private final List<? extends Throwable> causeList;
 
     /**
@@ -41,7 +65,7 @@ public class IOExceptionList extends IOException {
      * @param causeList a list of cause exceptions.
      */
     public IOExceptionList(final List<? extends Throwable> causeList) {
-        this(String.format("%,d exceptions: %s", causeList == null ? 0 : causeList.size(), causeList), causeList);
+        this(toMessage(causeList), causeList);
     }
 
     /**
@@ -52,7 +76,7 @@ public IOExceptionList(final List<? extends Throwable> causeList) {
      * @since 2.9.0
      */
     public IOExceptionList(final String message, final List<? extends Throwable> causeList) {
-        super(message, causeList == null || causeList.isEmpty() ? null : causeList.get(0));
+        super(message != null ? message : toMessage(causeList), isEmpty(causeList) ? null : causeList.get(0));
         this.causeList = causeList == null ? Collections.emptyList() : causeList;
     }
 
@@ -76,7 +100,7 @@ public <T extends Throwable> T getCause(final int index) {
      * @return The list of causes.
      */
     public <T extends Throwable> T getCause(final int index, final Class<T> clazz) {
-        return clazz.cast(causeList.get(index));
+        return clazz.cast(getCause(index));
     }
 
     /**

src/main/java/org/apache/commons/io/IOUtils.java

@@ -384,29 +384,14 @@ public static void close(final Closeable closeable) throws IOException {
     }
 
     /**
-     * Closes the given {@link Closeable} as a null-safe operation.
+     * Closes the given {@link Closeable}s as null-safe operations.
      *
      * @param closeables The resource(s) to close, may be null.
      * @throws IOException if an I/O error occurs.
      * @since 2.8.0
      */
     public static void close(final Closeable... closeables) throws IOException {
-        if (closeables != null) {
-            List<IOException> exceptions = null;
-            for (final Closeable closeable : closeables) {
-                try {
-                    close(closeable);
-                } catch (IOException ex) {
-                    if (exceptions == null) {
-                        exceptions = new ArrayList<>();
-                    }
-                    exceptions.add(ex);
-                }
-            }
-            if (exceptions != null) {
-                throw new IOExceptionList(exceptions);
-            }
-        }
+        IOConsumer.forEach(closeables, IOUtils::close);
     }
 
     /**

src/main/java/org/apache/commons/io/function/IOBiConsumer.java

@@ -0,0 +1,63 @@
+/*
+ * 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.Objects;
+import java.util.function.BiConsumer;
+
+/**
+ * Like {@link BiConsumer} but throws {@link IOException}.
+ *
+ * @param <T> the type of the first argument to the operation
+ * @param <U> the type of the second argument to the operation
+ *
+ * @see BiConsumer
+ * @since 1.8
+ */
+@FunctionalInterface
+public interface IOBiConsumer<T, U> {
+
+    /**
+     * Performs this operation on the given arguments.
+     *
+     * @param t the first input argument
+     * @param u the second input argument
+     * @throws IOException if an I/O error occurs.
+     */
+    void accept(T t, U u) throws IOException;
+
+    /**
+     * Returns a composed {@code BiConsumer} that performs, in sequence, this operation followed by the {@code after}
+     * operation. If performing either operation throws an exception, it is relayed to the caller of the composed operation.
+     * If performing this operation throws an exception, the {@code after} operation will not be performed.
+     *
+     * @param after the operation to perform after this operation
+     * @return a composed {@code BiConsumer} that performs in sequence this operation followed by the {@code after}
+     *         operation
+     * @throws NullPointerException if {@code after} is null
+     */
+    default IOBiConsumer<T, U> andThen(IOBiConsumer<? super T, ? super U> after) {
+        Objects.requireNonNull(after);
+
+        return (l, r) -> {
+            accept(l, r);
+            after.accept(l, r);
+        };
+    }
+}

src/main/java/org/apache/commons/io/function/IOConsumer.java

@@ -20,6 +20,10 @@
 import java.io.IOException;
 import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.IOExceptionList;
+import org.apache.commons.io.IOIndexedException;
 
 /**
  * Like {@link Consumer} but throws {@link IOException}.
@@ -35,6 +39,32 @@ public interface IOConsumer<T> {
      */
     IOConsumer<?> NOOP_IO_CONSUMER = t -> {/* noop */};
 
+    /**
+     * Performs an action for each element of this stream.
+     *
+     * @param <T> The element type.
+     * @param array The input to stream.
+     * @param action The action to apply to each input element.
+     * @throws IOException if an I/O error occurs.
+     * @since 2.12.0
+     */
+    static <T> void forEach(final T[] array, final IOConsumer<T> action) throws IOException {
+        IOStreams.forEach(IOStreams.of(array), action);
+    }
+
+    /**
+     * Performs an action for each element of this stream.
+     *
+     * @param <T> The element type.
+     * @param stream The input to stream.
+     * @param action The action to apply to each input element.
+     * @throws IOExceptionList if an I/O error occurs.
+     * @since 2.12.0
+     */
+    static <T> void forEachIndexed(final Stream<T> stream, final IOConsumer<T> action) throws IOExceptionList {
+        IOStreams.forEachIndexed(stream, action, IOIndexedException::new);
+    }
+
     /**
      * Returns a constant NOOP consumer.
      *
@@ -56,13 +86,12 @@ static <T> IOConsumer<T> noop() {
     void accept(T t) throws IOException;
 
     /**
-     * Returns a composed {@code IoConsumer} that performs, in sequence, this operation followed by the {@code after}
-     * operation. If performing either operation throws an exception, it is relayed to the caller of the composed
-     * operation. If performing this operation throws an exception, the {@code after} operation will not be performed.
+     * Returns a composed {@code IOConsumer} that performs, in sequence, this operation followed by the {@code after}
+     * operation. If performing either operation throws an exception, it is relayed to the caller of the composed operation.
+     * If performing this operation throws an exception, the {@code after} operation will not be performed.
      *
      * @param after the operation to perform after this operation
-     * @return a composed {@code Consumer} that performs in sequence this operation followed by the {@code after}
-     *         operation
+     * @return a composed {@code Consumer} that performs in sequence this operation followed by the {@code after} operation
      * @throws NullPointerException if {@code after} is null
      */
     default IOConsumer<T> andThen(final IOConsumer<? super T> after) {

src/main/java/org/apache/commons/io/function/IOStreams.java

@@ -0,0 +1,71 @@
+/*
+ * 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.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiFunction;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.IOExceptionList;
+
+/**
+ * Keeps code package private for now.
+ */
+class IOStreams {
+
+    /**
+     * Null-safe version of {@link Stream#of(Object[])}.
+     *
+     * Copied from Apache Commons Lang.
+     *
+     * @param <T> 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()}.
+     */
+    @SafeVarargs // Creating a stream from an array is safe
+    static <T> Stream<T> of(final T... values) {
+        return values == null ? Stream.empty() : Stream.of(values);
+    }
+
+    static <T> void forEach(final Stream<T> stream, final IOConsumer<T> action) throws IOException {
+        forEachIndexed(stream, action, (i, e) -> e);
+    }
+
+    static <T> void forEachIndexed(final Stream<T> stream, final IOConsumer<T> action, final BiFunction<Integer, IOException, IOException> exSupplier)
+        throws IOExceptionList {
+        final AtomicReference<List<IOException>> causeList = new AtomicReference<>();
+        final AtomicInteger index = new AtomicInteger();
+        stream.forEach(e -> {
+            try {
+                action.accept(e);
+            } catch (final IOException ioex) {
+                if (causeList.get() == null) {
+                    causeList.set(new ArrayList<>());
+                }
+                causeList.get().add(exSupplier.apply(index.get(), ioex));
+            }
+            index.incrementAndGet();
+        });
+        IOExceptionList.checkEmpty(causeList.get(), "forEach");
+    }
+
+}