You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2020/06/24 16:51:15 UTC
[commons-lang] 02/02: Use the same generic parameter names as the
JRE.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit 1861ab9388ebd997799720e5913b2c8553c6514c
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Wed Jun 24 12:51:04 2020 -0400
Use the same generic parameter names as the JRE.
---
src/changes/changes.xml | 11 ++++++-----
.../apache/commons/lang3/function/FailableBiConsumer.java | 13 +++++++------
.../apache/commons/lang3/function/FailableBiFunction.java | 12 ++++++------
.../apache/commons/lang3/function/FailableBiPredicate.java | 12 ++++++------
.../commons/lang3/function/FailableBooleanSupplier.java | 8 ++++----
.../org/apache/commons/lang3/function/FailableCallable.java | 8 ++++----
.../org/apache/commons/lang3/function/FailableConsumer.java | 8 ++++----
.../lang3/function/FailableDoubleBinaryOperator.java | 8 ++++----
.../commons/lang3/function/FailableDoubleConsumer.java | 8 ++++----
.../commons/lang3/function/FailableDoubleFunction.java | 8 ++++----
.../commons/lang3/function/FailableDoublePredicate.java | 8 ++++----
.../commons/lang3/function/FailableDoubleSupplier.java | 8 ++++----
.../commons/lang3/function/FailableDoubleToIntFunction.java | 8 ++++----
.../lang3/function/FailableDoubleToLongFunction.java | 8 ++++----
.../org/apache/commons/lang3/function/FailableFunction.java | 10 +++++-----
.../commons/lang3/function/FailableIntBinaryOperator.java | 8 ++++----
.../apache/commons/lang3/function/FailableIntConsumer.java | 8 ++++----
.../apache/commons/lang3/function/FailableIntFunction.java | 8 ++++----
.../apache/commons/lang3/function/FailableIntPredicate.java | 8 ++++----
.../apache/commons/lang3/function/FailableIntSupplier.java | 8 ++++----
.../commons/lang3/function/FailableIntToDoubleFunction.java | 8 ++++----
.../commons/lang3/function/FailableIntToLongFunction.java | 8 ++++----
.../commons/lang3/function/FailableLongBinaryOperator.java | 8 ++++----
.../apache/commons/lang3/function/FailableLongConsumer.java | 8 ++++----
.../apache/commons/lang3/function/FailableLongFunction.java | 8 ++++----
.../commons/lang3/function/FailableLongPredicate.java | 8 ++++----
.../apache/commons/lang3/function/FailableLongSupplier.java | 8 ++++----
.../lang3/function/FailableLongToDoubleFunction.java | 8 ++++----
.../commons/lang3/function/FailableLongToIntFunction.java | 8 ++++----
.../commons/lang3/function/FailableObjDoubleConsumer.java | 10 +++++-----
.../commons/lang3/function/FailableObjIntConsumer.java | 10 +++++-----
.../commons/lang3/function/FailableObjLongConsumer.java | 10 +++++-----
.../apache/commons/lang3/function/FailablePredicate.java | 10 +++++-----
.../org/apache/commons/lang3/function/FailableRunnable.java | 8 ++++----
.../org/apache/commons/lang3/function/FailableSupplier.java | 8 ++++----
.../commons/lang3/function/FailableToDoubleBiFunction.java | 12 ++++++------
.../commons/lang3/function/FailableToDoubleFunction.java | 10 +++++-----
.../commons/lang3/function/FailableToIntBiFunction.java | 12 ++++++------
.../commons/lang3/function/FailableToIntFunction.java | 10 +++++-----
.../commons/lang3/function/FailableToLongBiFunction.java | 12 ++++++------
.../commons/lang3/function/FailableToLongFunction.java | 10 +++++-----
41 files changed, 187 insertions(+), 185 deletions(-)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 04c5729..9c8259b 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -48,11 +48,6 @@ The <action> type attribute can be add,update,fix,remove.
<release version="3.11" date="2020-MM-DD" description="New features and bug fixes..">
<action type="update" dev="kinow" due-to="XenoAmess">remove encoding and docEncoding and use inherited values from commons-parent</action>
<action type="fix" dev="kinow" due-to="contextshuffling">Fix Javadoc for StringUtils.appendIfMissingIgnoreCase() #507.</action>
- <action type="update" dev="ggregory">org.apache.commons:commons-parent 50 -> 51.</action>
- <action type="update" dev="ggregory">org.junit-pioneer:junit-pioneer 0.5.4 -> 0.6.0.</action>
- <action type="update" dev="ggregory">org.junit.jupiter:junit-jupiter 5.6.0 -> 5.6.1.</action>
- <action type="update" dev="ggregory">com.github.spotbugs:spotbugs 4.0.0 -> 4.0.5.</action>
- <action type="update" dev="ggregory">com.puppycrawl.tools:checkstyle 8.29 -> 8.33.</action>
<action type="update" dev="ggregory" due-to="Isira Seneviratne, Bruno P. Kinoshita">Simplify null checks in Pair.hashCode() using Objects.hashCode(). #517.</action>
<action type="update" dev="ggregory" due-to="Isira Seneviratne, Bruno P. Kinoshita">Simplify null checks in Triple.hashCode() using Objects.hashCode(). #516.</action>
<action type="update" dev="ggregory" due-to="Isira Seneviratne, Bruno P. Kinoshita">Simplify some if statements in StringUtils. #521.</action>
@@ -84,6 +79,12 @@ The <action> type attribute can be add,update,fix,remove.
<action type="add" dev="ggregory">Add ObjectUtils.toString(Object, Supplier<String>).</action>
<action issue="LANG-1567" type="update" dev="ggregory" due-to="Miguel Muñoz, Bruno P. Kinoshita, Gary Gregory">Fixed Javadocs for setTestRecursive() #556.</action>
<action issue="LANG-1542" type="update" dev="ggregory" due-to=" Trần Ngọc Khoa, Gary Gregory">ToStringBuilder.reflectionToString - Wrong JSON format when object has a List of Enum.</action>
+ <action type="update" dev="ggregory">org.apache.commons:commons-parent 50 -> 51.</action>
+ <action type="update" dev="ggregory">org.junit-pioneer:junit-pioneer 0.5.4 -> 0.6.0.</action>
+ <action type="update" dev="ggregory">org.junit.jupiter:junit-jupiter 5.6.0 -> 5.6.1.</action>
+ <action type="update" dev="ggregory">com.github.spotbugs:spotbugs 4.0.0 -> 4.0.6.</action>
+ <action type="update" dev="ggregory">com.puppycrawl.tools:checkstyle 8.29 -> 8.33.</action>
+ <action type="update" dev="ggregory">commons.surefire.version 3.0.0-M4 -> 3.0.0-M5..</action>
</release>
<release version="3.10" date="2020-03-22" description="New features and bug fixes. Requires Java 8, supports Java 9, 10, 11.">
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableBiConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableBiConsumer.java
index cd9bede..342f5ec 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableBiConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableBiConsumer.java
@@ -22,20 +22,21 @@ import java.util.function.BiConsumer;
/**
* A functional interface like {@link BiConsumer} that declares a {@code Throwable}.
*
- * @param <O1> Consumed type 1.
- * @param <O2> Consumed type 2.
- * @param <T> Thrown exception.
+ * @param <T> Consumed type 1.
+ * @param <U> Consumed type 2.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableBiConsumer<O1, O2, T extends Throwable> {
+public interface FailableBiConsumer<T, U, E extends Throwable> {
/**
* Accepts the consumer.
*
* @param object1 the first parameter for the consumable to accept
* @param object2 the second parameter for the consumable to accept
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(O1 object1, O2 object2) throws T;
+ void accept(T object1, U object2) throws E;
+
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableBiFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableBiFunction.java
index ccb87c1..d112be8 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableBiFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableBiFunction.java
@@ -22,14 +22,14 @@ import java.util.function.BiFunction;
/**
* A functional interface like {@link BiFunction} that declares a {@code Throwable}.
*
- * @param <O1> Input type 1.
- * @param <O2> Input type 2.
+ * @param <T> Input type 1.
+ * @param <U> Input type 2.
* @param <R> Return type.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableBiFunction<O1, O2, R, T extends Throwable> {
+public interface FailableBiFunction<T, U, R, E extends Throwable> {
/**
* Applies this function.
@@ -37,7 +37,7 @@ public interface FailableBiFunction<O1, O2, R, T extends Throwable> {
* @param input1 the first input for the function
* @param input2 the second input for the function
* @return the result of the function
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- R apply(O1 input1, O2 input2) throws T;
+ R apply(T input1, U input2) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableBiPredicate.java b/src/main/java/org/apache/commons/lang3/function/FailableBiPredicate.java
index 7255880..2299357 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableBiPredicate.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableBiPredicate.java
@@ -22,13 +22,13 @@ import java.util.function.BiPredicate;
/**
* A functional interface like {@link BiPredicate} that declares a {@code Throwable}.
*
- * @param <O1> Predicate type 1.
- * @param <O2> Predicate type 2.
- * @param <T> Thrown exception.
+ * @param <T> Predicate type 1.
+ * @param <U> Predicate type 2.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableBiPredicate<O1, O2, T extends Throwable> {
+public interface FailableBiPredicate<T, U, E extends Throwable> {
/**
* Tests the predicate.
@@ -36,7 +36,7 @@ public interface FailableBiPredicate<O1, O2, T extends Throwable> {
* @param object1 the first object to test the predicate on
* @param object2 the second object to test the predicate on
* @return the predicate's evaluation
- * @throws T if the predicate fails
+ * @throws E if the predicate fails
*/
- boolean test(O1 object1, O2 object2) throws T;
+ boolean test(T object1, U object2) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
index 25870de..89facde 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
@@ -22,17 +22,17 @@ import java.util.function.BooleanSupplier;
/**
* A functional interface like {@link BooleanSupplier} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableBooleanSupplier<T extends Throwable> {
+public interface FailableBooleanSupplier<E extends Throwable> {
/**
* Supplies a boolean.
*
* @return a result
- * @throws T if the supplier fails
+ * @throws E if the supplier fails
*/
- boolean getAsBoolean() throws T;
+ boolean getAsBoolean() throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableCallable.java b/src/main/java/org/apache/commons/lang3/function/FailableCallable.java
index 5d0d637..7e3a4d4 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableCallable.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableCallable.java
@@ -21,17 +21,17 @@ package org.apache.commons.lang3.function;
* A functional interface like {@link java.util.concurrent.Callable} that declares a {@code Throwable}.
*
* @param <R> Return type.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableCallable<R, T extends Throwable> {
+public interface FailableCallable<R, E extends Throwable> {
/**
* Calls the callable.
*
* @return The value returned from the callable
- * @throws T if the callable fails
+ * @throws E if the callable fails
*/
- R call() throws T;
+ R call() throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableConsumer.java
index f969dc1..acb73cc 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableConsumer.java
@@ -23,17 +23,17 @@ import java.util.function.Consumer;
* A functional interface like {@link Consumer} that declares a {@code Throwable}.
*
* @param <O> Consumed type 1.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableConsumer<O, T extends Throwable> {
+public interface FailableConsumer<O, E extends Throwable> {
/**
* Accepts the consumer.
*
* @param object the parameter for the consumable to accept
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(O object) throws T;
+ void accept(O object) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
index 1968044..aefc8b7 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
@@ -22,11 +22,11 @@ import java.util.function.DoubleBinaryOperator;
/**
* A functional interface like {@link DoubleBinaryOperator} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableDoubleBinaryOperator<T extends Throwable> {
+public interface FailableDoubleBinaryOperator<E extends Throwable> {
/**
* Applies this operator to the given operands.
@@ -34,7 +34,7 @@ public interface FailableDoubleBinaryOperator<T extends Throwable> {
* @param left the first operand
* @param right the second operand
* @return the operator result
- * @throws T if the operation fails
+ * @throws E if the operation fails
*/
- double applyAsDouble(double left, double right) throws T;
+ double applyAsDouble(double left, double right) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
index 63bc40e..9b70da8 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
@@ -22,17 +22,17 @@ import java.util.function.DoubleConsumer;
/**
* A functional interface like {@link DoubleConsumer} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableDoubleConsumer<T extends Throwable> {
+public interface FailableDoubleConsumer<E extends Throwable> {
/**
* Accepts the consumer.
*
* @param value the parameter for the consumable to accept
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(double value) throws T;
+ void accept(double value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
index 48dec10..175a05e 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
@@ -23,18 +23,18 @@ import java.util.function.DoubleFunction;
* A functional interface like {@link DoubleFunction} that declares a {@code Throwable}.
*
* @param <R> Return type.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableDoubleFunction<R, T extends Throwable> {
+public interface FailableDoubleFunction<R, E extends Throwable> {
/**
* Applies this function.
*
* @param input the input for the function
* @return the result of the function
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- R apply(double input) throws T;
+ R apply(double input) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
index e4bf163..abdd2cb 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
@@ -22,18 +22,18 @@ import java.util.function.DoublePredicate;
/**
* A functional interface like {@link DoublePredicate} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableDoublePredicate<T extends Throwable> {
+public interface FailableDoublePredicate<E extends Throwable> {
/**
* Tests the predicate.
*
* @param value the parameter for the predicate to accept.
* @return {@code true} if the input argument matches the predicate, {@code false} otherwise.
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- boolean test(double value) throws T;
+ boolean test(double value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
index 47ac129..0024ef2 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
@@ -22,17 +22,17 @@ import java.util.function.DoubleSupplier;
/**
* A functional interface like {@link DoubleSupplier} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableDoubleSupplier<T extends Throwable> {
+public interface FailableDoubleSupplier<E extends Throwable> {
/**
* Supplies a double.
*
* @return a result
- * @throws T if the supplier fails
+ * @throws E if the supplier fails
*/
- double getAsDouble() throws T;
+ double getAsDouble() throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
index 403400f..eb9e940 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
@@ -22,18 +22,18 @@ import java.util.function.DoubleToIntFunction;
/**
* A functional interface like {@link DoubleToIntFunction} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableDoubleToIntFunction<T extends Throwable> {
+public interface FailableDoubleToIntFunction<E extends Throwable> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- int applyAsInt(double value) throws T;
+ int applyAsInt(double value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
index 71cab0e..2a5b0ff 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
@@ -22,18 +22,18 @@ import java.util.function.DoubleToLongFunction;
/**
* A functional interface like {@link DoubleToLongFunction} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableDoubleToLongFunction<T extends Throwable> {
+public interface FailableDoubleToLongFunction<E extends Throwable> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
- * @throws T if the operation fails
+ * @throws E if the operation fails
*/
- int applyAsLong(double value) throws T;
+ int applyAsLong(double value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableFunction.java
index 3aad210..7de4437 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableFunction.java
@@ -22,20 +22,20 @@ import java.util.function.Function;
/**
* A functional interface like {@link Function} that declares a {@code Throwable}.
*
- * @param <I> Input type 1.
+ * @param <T> Input type 1.
* @param <R> Return type.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableFunction<I, R, T extends Throwable> {
+public interface FailableFunction<T, R, E extends Throwable> {
/**
* Applies this function.
*
* @param input the input for the function
* @return the result of the function
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- R apply(I input) throws T;
+ R apply(T input) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
index 7e41e54..bc22630 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
@@ -22,11 +22,11 @@ import java.util.function.IntBinaryOperator;
/**
* A functional interface like {@link IntBinaryOperator} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableIntBinaryOperator<T extends Throwable> {
+public interface FailableIntBinaryOperator<E extends Throwable> {
/**
* Applies this operator to the given operands.
@@ -34,7 +34,7 @@ public interface FailableIntBinaryOperator<T extends Throwable> {
* @param left the first operand
* @param right the second operand
* @return the operator result
- * @throws T if the operation fails
+ * @throws E if the operation fails
*/
- int applyAsInt(int left, int right) throws T;
+ int applyAsInt(int left, int right) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
index e7ce74c..506cb67 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
@@ -22,17 +22,17 @@ import java.util.function.IntConsumer;
/**
* A functional interface like {@link IntConsumer} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableIntConsumer<T extends Throwable> {
+public interface FailableIntConsumer<E extends Throwable> {
/**
* Accepts the consumer.
*
* @param value the parameter for the consumable to accept
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(int value) throws T;
+ void accept(int value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
index 907f098..7c2d0bc 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
@@ -23,18 +23,18 @@ import java.util.function.IntFunction;
* A functional interface like {@link IntFunction} that declares a {@code Throwable}.
*
* @param <R> Return type.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableIntFunction<R, T extends Throwable> {
+public interface FailableIntFunction<R, E extends Throwable> {
/**
* Applies this function.
*
* @param input the input for the function
* @return the result of the function
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- R apply(int input) throws T;
+ R apply(int input) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
index 3687f9c..837ba31 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
@@ -22,18 +22,18 @@ import java.util.function.IntPredicate;
/**
* A functional interface like {@link IntPredicate} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableIntPredicate<T extends Throwable> {
+public interface FailableIntPredicate<E extends Throwable> {
/**
* Tests the predicate.
*
* @param value the parameter for the predicate to accept.
* @return {@code true} if the input argument matches the predicate, {@code false} otherwise.
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- boolean test(int value) throws T;
+ boolean test(int value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
index f1f72e4..d1478aa 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
@@ -22,17 +22,17 @@ import java.util.function.IntSupplier;
/**
* A functional interface like {@link IntSupplier} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableIntSupplier<T extends Throwable> {
+public interface FailableIntSupplier<E extends Throwable> {
/**
* Supplies an int.
*
* @return a result
- * @throws T if the supplier fails
+ * @throws E if the supplier fails
*/
- int getAsInt() throws T;
+ int getAsInt() throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
index 51a81ac..93afd89 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
@@ -22,18 +22,18 @@ import java.util.function.IntToDoubleFunction;
/**
* A functional interface like {@link IntToDoubleFunction} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableIntToDoubleFunction<T extends Throwable> {
+public interface FailableIntToDoubleFunction<E extends Throwable> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- double applyAsDouble(int value) throws T;
+ double applyAsDouble(int value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
index aef8c57..de23ae7 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
@@ -22,18 +22,18 @@ import java.util.function.IntToLongFunction;
/**
* A functional interface like {@link IntToLongFunction} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableIntToLongFunction<T extends Throwable> {
+public interface FailableIntToLongFunction<E extends Throwable> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- long applyAsLong(int value) throws T;
+ long applyAsLong(int value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
index 6ddf2ab..a7a3e08 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
@@ -22,11 +22,11 @@ import java.util.function.LongBinaryOperator;
/**
* A functional interface like {@link LongBinaryOperator} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableLongBinaryOperator<T extends Throwable> {
+public interface FailableLongBinaryOperator<E extends Throwable> {
/**
* Applies this operator to the given operands.
@@ -34,7 +34,7 @@ public interface FailableLongBinaryOperator<T extends Throwable> {
* @param left the first operand
* @param right the second operand
* @return the operator result
- * @throws T if the operation fails
+ * @throws E if the operation fails
*/
- long applyAsLong(long left, long right) throws T;
+ long applyAsLong(long left, long right) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
index 465112e..0565ff3 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
@@ -22,17 +22,17 @@ import java.util.function.LongConsumer;
/**
* A functional interface like {@link LongConsumer} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableLongConsumer<T extends Throwable> {
+public interface FailableLongConsumer<E extends Throwable> {
/**
* Accepts the consumer.
*
* @param object the parameter for the consumable to accept
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(long object) throws T;
+ void accept(long object) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
index b36b272..2811e74 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
@@ -23,18 +23,18 @@ import java.util.function.LongFunction;
* A functional interface like {@link LongFunction} that declares a {@code Throwable}.
*
* @param <R> Return type.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableLongFunction<R, T extends Throwable> {
+public interface FailableLongFunction<R, E extends Throwable> {
/**
* Applies this function.
*
* @param input the input for the function
* @return the result of the function
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- R apply(long input) throws T;
+ R apply(long input) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
index 3255082..3c756ca 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
@@ -22,18 +22,18 @@ import java.util.function.LongPredicate;
/**
* A functional interface like {@link LongPredicate} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableLongPredicate<T extends Throwable> {
+public interface FailableLongPredicate<E extends Throwable> {
/**
* Tests the predicate.
*
* @param value the parameter for the predicate to accept.
* @return {@code true} if the input argument matches the predicate, {@code false} otherwise.
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- boolean test(long value) throws T;
+ boolean test(long value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
index 31d42a2..07d246d 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
@@ -22,17 +22,17 @@ import java.util.function.LongSupplier;
/**
* A functional interface like {@link LongSupplier} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableLongSupplier<T extends Throwable> {
+public interface FailableLongSupplier<E extends Throwable> {
/**
* Supplies a long.
*
* @return a result
- * @throws T if the supplier fails
+ * @throws E if the supplier fails
*/
- long getAsLong() throws T;
+ long getAsLong() throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
index f83d6a2..b272c9d 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
@@ -22,18 +22,18 @@ import java.util.function.LongToDoubleFunction;
/**
* A functional interface like {@link LongToDoubleFunction} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableLongToDoubleFunction<T extends Throwable> {
+public interface FailableLongToDoubleFunction<E extends Throwable> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- double applyAsDouble(long value) throws T;
+ double applyAsDouble(long value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
index 825491e..1066c3c 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
@@ -22,18 +22,18 @@ import java.util.function.LongToIntFunction;
/**
* A functional interface like {@link LongToIntFunction} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableLongToIntFunction<T extends Throwable> {
+public interface FailableLongToIntFunction<E extends Throwable> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- int applyAsInt(long value) throws T;
+ int applyAsInt(long value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
index 70555d5..105c874 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
@@ -22,19 +22,19 @@ import java.util.function.ObjDoubleConsumer;
/**
* A functional interface like {@link ObjDoubleConsumer} that declares a {@code Throwable}.
*
- * @param <O> the type of the object argument to the operation.
- * @param <T> Thrown exception.
+ * @param <T> the type of the object argument to the operation.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableObjDoubleConsumer<O, T extends Throwable> {
+public interface FailableObjDoubleConsumer<T, E extends Throwable> {
/**
* Accepts the consumer.
*
* @param object the object parameter for the consumable to accept.
* @param value the double parameter for the consumable to accept.
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(O object, double value) throws T;
+ void accept(T object, double value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
index 68954a4..71c8925 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
@@ -22,19 +22,19 @@ import java.util.function.ObjIntConsumer;
/**
* A functional interface like {@link ObjIntConsumer} that declares a {@code Throwable}.
*
- * @param <O> the type of the object argument to the operation.
- * @param <T> Thrown exception.
+ * @param <T> the type of the object argument to the operation.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableObjIntConsumer<O, T extends Throwable> {
+public interface FailableObjIntConsumer<T, E extends Throwable> {
/**
* Accepts the consumer.
*
* @param object the object parameter for the consumable to accept.
* @param value the int parameter for the consumable to accept.
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(O object, int value) throws T;
+ void accept(T object, int value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java b/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
index a503f5e..b84b4d7 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
@@ -22,19 +22,19 @@ import java.util.function.ObjLongConsumer;
/**
* A functional interface like {@link ObjLongConsumer} that declares a {@code Throwable}.
*
- * @param <O> the type of the object argument to the operation.
- * @param <T> Thrown exception.
+ * @param <T> the type of the object argument to the operation.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableObjLongConsumer<O, T extends Throwable> {
+public interface FailableObjLongConsumer<T, E extends Throwable> {
/**
* Accepts the consumer.
*
* @param object the object parameter for the consumable to accept.
* @param value the long parameter for the consumable to accept.
- * @throws T Thrown when the consumer fails.
+ * @throws E Thrown when the consumer fails.
*/
- void accept(O object, long value) throws T;
+ void accept(T object, long value) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailablePredicate.java b/src/main/java/org/apache/commons/lang3/function/FailablePredicate.java
index 6e461ce..999107a 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailablePredicate.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailablePredicate.java
@@ -22,19 +22,19 @@ import java.util.function.Predicate;
/**
* A functional interface like {@link Predicate} that declares a {@code Throwable}.
*
- * @param <I> Predicate type 1.
- * @param <T> Thrown exception.
+ * @param <T> Predicate type 1.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailablePredicate<I, T extends Throwable> {
+public interface FailablePredicate<T, E extends Throwable> {
/**
* Tests the predicate.
*
* @param object the object to test the predicate on
* @return the predicate's evaluation
- * @throws T if the predicate fails
+ * @throws E if the predicate fails
*/
- boolean test(I object) throws T;
+ boolean test(T object) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableRunnable.java b/src/main/java/org/apache/commons/lang3/function/FailableRunnable.java
index f783b33..06bd72f 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableRunnable.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableRunnable.java
@@ -20,16 +20,16 @@ package org.apache.commons.lang3.function;
/**
* A functional interface like {@link Runnable} that declares a {@code Throwable}.
*
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableRunnable<T extends Throwable> {
+public interface FailableRunnable<E extends Throwable> {
/**
* Runs the function.
*
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- void run() throws T;
+ void run() throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableSupplier.java b/src/main/java/org/apache/commons/lang3/function/FailableSupplier.java
index a8ff768..1a10956 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableSupplier.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableSupplier.java
@@ -23,17 +23,17 @@ import java.util.function.Supplier;
* A functional interface like {@link Supplier} that declares a {@code Throwable}.
*
* @param <R> Return type.
- * @param <T> Thrown exception.
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableSupplier<R, T extends Throwable> {
+public interface FailableSupplier<R, E extends Throwable> {
/**
* Supplies an object
*
* @return a result
- * @throws T if the supplier fails
+ * @throws E if the supplier fails
*/
- R get() throws T;
+ R get() throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
index 766383b..4ac14bd 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
@@ -22,13 +22,13 @@ import java.util.function.ToDoubleBiFunction;
/**
* A functional interface like {@link ToDoubleBiFunction} that declares a {@code Throwable}.
*
- * @param <O1> the type of the first argument to the function
- * @param <O2> the type of the second argument to the function
- * @param <T> Thrown exception.
+ * @param <T> the type of the first argument to the function
+ * @param <U> the type of the second argument to the function
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableToDoubleBiFunction<O1, O2, T extends Throwable> {
+public interface FailableToDoubleBiFunction<T, U, E extends Throwable> {
/**
* Applies this function to the given arguments.
@@ -36,7 +36,7 @@ public interface FailableToDoubleBiFunction<O1, O2, T extends Throwable> {
* @param t the first function argument
* @param u the second function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- double applyAsDouble(O1 t, O2 u) throws T;
+ double applyAsDouble(T t, U u) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
index 9e3fedd..43feba5 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
@@ -22,19 +22,19 @@ import java.util.function.ToDoubleFunction;
/**
* A functional interface like {@link ToDoubleFunction} that declares a {@code Throwable}.
*
- * @param <I> the type of the first argument to the function
- * @param <T> Thrown exception.
+ * @param <T> the type of the first argument to the function
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableToDoubleFunction<I, T extends Throwable> {
+public interface FailableToDoubleFunction<T, E extends Throwable> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- double applyAsDouble(I t) throws T;
+ double applyAsDouble(T t) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
index 7430a09..1b7c3e2 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
@@ -22,13 +22,13 @@ import java.util.function.ToIntBiFunction;
/**
* A functional interface like {@link ToIntBiFunction} that declares a {@code Throwable}.
*
- * @param <O1> the type of the first argument to the function
- * @param <O2> the type of the second argument to the function
- * @param <T> Thrown exception.
+ * @param <T> the type of the first argument to the function
+ * @param <U> the type of the second argument to the function
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableToIntBiFunction<O1, O2, T extends Throwable> {
+public interface FailableToIntBiFunction<T, U, E extends Throwable> {
/**
* Applies this function to the given arguments.
@@ -36,7 +36,7 @@ public interface FailableToIntBiFunction<O1, O2, T extends Throwable> {
* @param t the first function argument
* @param u the second function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- int applyAsInt(O1 t, O2 u) throws T;
+ int applyAsInt(T t, U u) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
index 0fc91ad..1bba1c9 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
@@ -22,19 +22,19 @@ import java.util.function.ToIntFunction;
/**
* A functional interface like {@link ToIntFunction} that declares a {@code Throwable}.
*
- * @param <I> the type of the first argument to the function
- * @param <T> Thrown exception.
+ * @param <T> the type of the first argument to the function
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableToIntFunction<I, T extends Throwable> {
+public interface FailableToIntFunction<T, E extends Throwable> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- int applyAsInt(I t) throws T;
+ int applyAsInt(T t) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
index 6a34026..e49347f 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
@@ -22,13 +22,13 @@ import java.util.function.ToLongBiFunction;
/**
* A functional interface like {@link ToLongBiFunction} that declares a {@code Throwable}.
*
- * @param <O1> the type of the first argument to the function
- * @param <O2> the type of the second argument to the function
- * @param <T> Thrown exception.
+ * @param <T> the type of the first argument to the function
+ * @param <U> the type of the second argument to the function
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableToLongBiFunction<O1, O2, T extends Throwable> {
+public interface FailableToLongBiFunction<T, U, E extends Throwable> {
/**
* Applies this function to the given arguments.
@@ -36,7 +36,7 @@ public interface FailableToLongBiFunction<O1, O2, T extends Throwable> {
* @param t the first function argument
* @param u the second function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- long applyAsLong(O1 t, O2 u) throws T;
+ long applyAsLong(T t, U u) throws E;
}
diff --git a/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java b/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
index f46bbcc..5b790af 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
@@ -22,19 +22,19 @@ import java.util.function.ToLongFunction;
/**
* A functional interface like {@link ToLongFunction} that declares a {@code Throwable}.
*
- * @param <I> the type of the first argument to the function
- * @param <T> Thrown exception.
+ * @param <T> the type of the first argument to the function
+ * @param <E> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
-public interface FailableToLongFunction<I, T extends Throwable> {
+public interface FailableToLongFunction<T, E extends Throwable> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @return the function result
- * @throws T Thrown when the function fails.
+ * @throws E Thrown when the function fails.
*/
- long applyAsLong(I t) throws T;
+ long applyAsLong(T t) throws E;
}