Add IOIntConsumer

Author: garydgregory

src/changes/changes.xml

@@ -64,6 +64,7 @@ The <action> type attribute can be add,update,fix,remove.
       <action dev="ggregory" type="add"                due-to="Gary Gregory">Add ValidatingObjectInputStream.ObjectStreamClassPredicate to allow configuration reuse.</action>
       <action dev="ggregory" type="add"                due-to="Gary Gregory">Add RandomAccessFileMode.accept(Path, IOConsumer&lt;RandomAccessFile&gt;).</action>
       <action dev="ggregory" type="add"                due-to="Gary Gregory">Add RandomAccessFileMode.apply(Path, IOFunction&lt;RandomAccessFile&gt;, T).</action>
+      <action dev="ggregory" type="add"                due-to="Gary Gregory">Add IOIntConsumer.</action>
       <!-- UPDATE -->
       <action dev="ggregory" type="update"             due-to="Gary Gregory">Bump org.apache.commons:commons-parent from 74 to 78 #670, #676, #679, #688.</action>
       <action dev="ggregory" type="update"             due-to="Gary Gregory">Bump commons.bytebuddy.version from 1.15.1 to 1.15.8 #672, #673, #685, #686, #694, #696.</action>

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

@@ -0,0 +1,82 @@
+/*
+ * 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.io.UncheckedIOException;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.IntConsumer;
+
+/**
+ * Like {@link IntConsumer} but throws {@link IOException}.
+ *
+ * @since 2.18.0
+ */
+@FunctionalInterface
+public interface IOIntConsumer {
+
+    /**
+     * The constant no-op consumer.
+     */
+    IOIntConsumer NOOP = i -> {/* noop */};
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param value the input argument
+     * @throws IOException if an I/O error occurs.
+     */
+    void accept(int value) throws IOException;
+
+    /**
+     * Returns a composed {@code IOIntConsumer} 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 IOIntConsumer} that performs in sequence this operation followed by the {@code after} operation
+     * @throws NullPointerException if {@code after} is null
+     */
+    default IOIntConsumer andThen(final IOIntConsumer after) {
+        Objects.requireNonNull(after);
+        return (final int i) -> {
+            accept(i);
+            after.accept(i);
+        };
+    }
+
+    /**
+     * Creates a {@link Consumer} for this instance that throws {@link UncheckedIOException} instead of {@link IOException}.
+     *
+     * @return an UncheckedIOException IntConsumer.
+     */
+    default Consumer<Integer> asConsumer() {
+        return i -> Uncheck.accept(this, i);
+    }
+
+    /**
+     * Creates an {@link IntConsumer} for this instance that throws {@link UncheckedIOException} instead of {@link IOException}.
+     *
+     * @return an UncheckedIOException IntConsumer.
+     */
+    default IntConsumer asIntConsumer() {
+        return i -> Uncheck.accept(this, i);
+    }
+
+}

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

@@ -62,6 +62,22 @@ public static <T> void accept(final IOConsumer<T> consumer, final T t) {
         }
     }
 
+    /**
+     * Accepts an IO consumer with the given argument.
+     *
+     * @param i the input argument.
+     * @param consumer Consumes the value.
+     * @throws UncheckedIOException if an I/O error occurs.
+     * @since 2.18.0
+     */
+    public static void accept(final IOIntConsumer consumer, final int i) {
+        try {
+            consumer.accept(i);
+        } catch (final IOException e) {
+            throw wrap(e);
+        }
+    }
+
     /**
      * Accepts an IO consumer with the given arguments.
      *

src/test/java/org/apache/commons/io/function/IOIntConsumerTest.java

@@ -0,0 +1,78 @@
+/*
+ * 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 static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link IOIntConsumer}.
+ */
+public class IOIntConsumerTest {
+
+    @Test
+    void testAccept() throws IOException {
+        assertDoesNotThrow(() -> IOIntConsumer.NOOP.accept(0));
+        assertDoesNotThrow(() -> IOIntConsumer.NOOP.accept('.'));
+        final AtomicReference<String> ref = new AtomicReference<>();
+        final IOIntConsumer consumer = s -> ref.set(s + "-");
+        consumer.accept(65);
+        assertEquals(65 + "-", ref.get());
+    }
+
+    @Test
+    void testAndThen() throws IOException {
+        final AtomicReference<String> ref = new AtomicReference<>();
+        final IOIntConsumer consumer1 = s -> ref.set(s + "-");
+        final IOIntConsumer consumer2 = s -> ref.set(ref.get() + "=" + s);
+        consumer1.andThen(consumer2).accept(66);
+        assertEquals(66 + "-=" + 66, ref.get());
+    }
+
+    @Test
+    void testAsConsumer() {
+        assertThrows(UncheckedIOException.class, () -> Optional.of(65).ifPresent(TestUtils.throwingIOIntConsumer().asConsumer()));
+        final AtomicReference<String> ref = new AtomicReference<>();
+        final IOIntConsumer consumer1 = s -> ref.set(s + "A");
+        Optional.of(2).ifPresent(consumer1.asConsumer());
+        assertEquals("2A", ref.get());
+    }
+
+    @Test
+    void testasIntConsumer() {
+        final AtomicReference<String> ref = new AtomicReference<>();
+        final IOIntConsumer consumer1 = s -> ref.set(s + "A");
+        consumer1.asIntConsumer().accept(2);
+        assertEquals("2A", ref.get());
+    }
+
+    @Test
+    void testNOOP() {
+        // nothing happens:
+        assertDoesNotThrow(() -> IOIntConsumer.NOOP.accept(0));
+    }
+
+}

src/test/java/org/apache/commons/io/function/TestConstants.java

@@ -42,6 +42,8 @@ final class TestConstants {
 
     static IOConsumer<Object> THROWING_IO_CONSUMER = t -> throwIOException();
 
+    static IOIntConsumer THROWING_IO_INT_CONSUMER = t -> throwIOException();
+
     static IOFunction<Object, Object> THROWING_IO_FUNCTION = t -> throwIOException();
 
     static IOIntSupplier THROWING_IO_INT_SUPPLIER = TestConstants::throwIOException;

src/test/java/org/apache/commons/io/function/TestUtils.java

@@ -94,6 +94,10 @@ static <T, U> IOFunction<T, U> throwingIOFunction() {
         return (IOFunction<T, U>) TestConstants.THROWING_IO_FUNCTION;
     }
 
+    static IOIntConsumer throwingIOIntConsumer() {
+        return TestConstants.THROWING_IO_INT_CONSUMER;
+    }
+
     @SuppressWarnings("unchecked")
     static <T> IOPredicate<T> throwingIOPredicate() {
         return (IOPredicate<T>) TestConstants.THROWING_IO_PREDICATE;