Add ThrowingBiObjLongConsumer and ThrowingObjLongConsumer, re #63

Author: safris

src/main/java/org/libj/util/function/Throwing.java

@@ -22,6 +22,7 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.ObjIntConsumer;
+import java.util.function.ObjLongConsumer;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
@@ -147,6 +148,30 @@ public static <T> ObjIntConsumer<T> rethrow(final ThrowingObjIntConsumer<T,?> co
     return consumer;
   }
 
+  /**
+   * Rethrows the checked exception from the specified {@link ThrowingObjLongConsumer}.
+   * <p>
+   * An example of this pattern:
+   *
+   * <pre>
+   * {@code
+   * ObjLongConsumer<Integer> consumer = Throwing.rethrow((Integer s, long i) -> {
+   *   if (i == 0)
+   *     throw new IOException("i=" + i);
+   * });
+   * for (int i = 3; i >= 0; --i)
+   *   consumer.accept(i, -(long)i);
+   * }
+   * </pre>
+   *
+   * @param <T> The type of the first input to the consumer's operation.
+   * @param consumer The {@link ThrowingObjLongConsumer}.
+   * @return The specified {@link ObjLongConsumer} instance.
+   */
+  public static <T> ObjLongConsumer<T> rethrow(final ThrowingObjLongConsumer<T,?> consumer) {
+    return consumer;
+  }
+
   /**
    * Rethrows the checked exception from the specified {@link ThrowingObjBiIntConsumer}.
    * <p>
@@ -245,6 +270,31 @@ public static <T,U> BiObjBooleanConsumer<T,U> rethrow(final ThrowingBiObjBoolean
     return predicate;
   }
 
+  /**
+   * Rethrows the checked exception from the specified {@link ThrowingBiObjBiIntPredicate}.
+   * <p>
+   * An example of this pattern:
+   *
+   * <pre>
+   * {@code
+   * BiObjLongConsumer<Integer,Integer> consumer = Throwing.rethrow((Integer s, Integer t, int i, int j) -> {
+   *   if (i == 0)
+   *     throw new IOException("i=" + i);
+   * });
+   * for (int i = 3; i >= 0; --i)
+   *   consumer.accept(i, -i, i / 2, i * 2);
+   * }
+   * </pre>
+   *
+   * @param <T> The type of the first input to the predicate's operation.
+   * @param <U> The type of the second input to the predicate's operation.
+   * @param predicate The {@link ThrowingBiObjLongConsumer}.
+   * @return The specified {@link BiObjLongConsumer} instance.
+   */
+  public static <T,U> BiObjLongConsumer<T,U> rethrow(final ThrowingBiObjLongConsumer<T,U,?> predicate) {
+    return predicate;
+  }
+
   /**
    * Rethrows the checked exception from the specified {@link ThrowingTriConsumer}.
    * <p>

src/main/java/org/libj/util/function/ThrowingBiObjLongConsumer.java

@@ -0,0 +1,74 @@
+/* Copyright (c) 2024 LibJ
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * You should have received a copy of The MIT License (MIT) along with this
+ * program. If not, see <http://opensource.org/licenses/MIT/>.
+ */
+
+package org.libj.util.function;
+
+import java.util.function.BiPredicate;
+
+/**
+ * Represents a consumer (long-valued function) that accepts two object-valued and a {@code long}-valued argument.
+ * <p>
+ * The {@link ThrowingBiObjLongConsumer} distinguishes itself from {@link ObjBiIntPredicate} by allowing the functional interface
+ * to throw any {@link Throwable}. This can be used to allow lambda expressions to propagate checked exceptions up the expression's
+ * call stack. An example of this pattern:
+ *
+ * <pre>
+ * {@code
+ * BiObjLongConsumer<Integer,Integer> consumer = Throwing.rethrow((Integer s, Integer t, long b) -> {
+ *   if (!b)
+ *     throw new IOException("i=" + i);
+ *   return false;
+ * });
+ * consumer.accept(i, -i, true);
+ * consumer.accept(i, -i, false);
+ * }
+ * </pre>
+ *
+ * @param <T> The type of the first argument to the consumer.
+ * @param <U> The type of the second argument to the consumer.
+ * @param <E> The type of {@link Throwable} that can be thrown.
+ * @see Throwing#rethrow(ThrowingBiObjLongConsumer)
+ */
+@FunctionalInterface
+public interface ThrowingBiObjLongConsumer<T,U,E extends Throwable> extends BiObjLongConsumer<T,U> {
+  /**
+   * Evaluates this consumer on the given arguments.
+   *
+   * @param t The first input argument.
+   * @param u The second input argument.
+   * @param b The third input argument.
+   */
+  @Override
+  default void accept(final T t, final U u, final long b) {
+    try {
+      acceptThrows(t, u, b);
+    }
+    catch (final Throwable e) {
+      Throwing.rethrow(e);
+    }
+  }
+
+  /**
+   * Evaluates this consumer on the given arguments, allowing a checked exception to be thrown.
+   *
+   * @param t The first input argument.
+   * @param u The second input argument.
+   * @param b The third input argument.
+   * @throws E If an exception has occurred.
+   * @see BiPredicate#test(Object,Object)
+   */
+  void acceptThrows(T t, U u, long b) throws E;
+}

src/main/java/org/libj/util/function/ThrowingObjLongConsumer.java

@@ -0,0 +1,65 @@
+/* Copyright (c) 2021 LibJ
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * You should have received a copy of The MIT License (MIT) along with this
+ * program. If not, see <http://opensource.org/licenses/MIT/>.
+ */
+
+package org.libj.util.function;
+
+import java.util.function.ObjLongConsumer;
+
+/**
+ * Represents an operation that accepts an object-valued and a {@code long}-valued argument, and returns no result. Unlike most other
+ * functional interfaces, {@link ObjLongConsumer} is expected to operate via side-effects.
+ * <p>
+ * The {@link ThrowingObjLongConsumer} distinguishes itself from {@link ObjLongConsumer} by allowing the functional interface to throw
+ * any {@link Throwable}. This can be used to allow lambda expressions to propagate checked exceptions up the expression's call
+ * stack. An example of this pattern:
+ *
+ * <pre>
+ * {@code
+ * ObjLongConsumer<String> consumer = Throwing.rethrow((String s, long i) -> {
+ *   if (i == 0)
+ *     throw new IOException("i=" + i);
+ * });
+ * for (long i = 3; i >= 0; --i)
+ *   consumer.accept(i, -i);
+ * }
+ * </pre>
+ *
+ * @param <T> The type of the object argument to the operation.
+ * @param <E> The type of {@link Throwable} that can be thrown.
+ * @see Throwing#rethrow(ThrowingObjLongConsumer)
+ */
+@FunctionalInterface
+public interface ThrowingObjLongConsumer<T,E extends Throwable> extends ObjLongConsumer<T> {
+  @Override
+  default void accept(final T t, final long value) {
+    try {
+      acceptThrows(t, value);
+    }
+    catch (final Throwable e) {
+      Throwing.rethrow(e);
+    }
+  }
+
+  /**
+   * Performs this operation on the given argument, allowing a checked exception to be thrown.
+   *
+   * @param t The first input argument.
+   * @param value The second input argument.
+   * @throws E If an exception has occurred.
+   * @see ObjLongConsumer#accept(Object,long)
+   */
+  void acceptThrows(T t, long value) throws E;
+}