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 <garydgreg...@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; }