Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[LANG-1568] More failable functional interfaces to match JRE functional 

interfaces.
This commit is contained in:
Gary Gregory 2020-06-14 19:27:23 -04:00
parent 133327272a
commit 7f90306f90
2 changed files with 1825 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

476
src/main/java/org/apache/commons/lang3/Functions.java
View File

@ -27,18 +27,36 @@ import java.util.function.BiFunction;
import java.util.function.BiPredicate; import java.util.function.BiPredicate;
import java.util.function.BooleanSupplier; import java.util.function.BooleanSupplier;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.DoubleBinaryOperator;
import java.util.function.DoubleConsumer; import java.util.function.DoubleConsumer;
import java.util.function.DoubleFunction;
import java.util.function.DoubleSupplier; import java.util.function.DoubleSupplier;
import java.util.function.DoubleToIntFunction;
import java.util.function.DoubleToLongFunction;
import java.util.function.Function; import java.util.function.Function;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer; import java.util.function.IntConsumer;
import java.util.function.IntFunction;
import java.util.function.IntSupplier; import java.util.function.IntSupplier;
import java.util.function.IntToDoubleFunction;
import java.util.function.IntToLongFunction;
import java.util.function.LongBinaryOperator;
import java.util.function.LongConsumer; import java.util.function.LongConsumer;
import java.util.function.LongFunction;
import java.util.function.LongSupplier; import java.util.function.LongSupplier;
import java.util.function.LongToDoubleFunction;
import java.util.function.LongToIntFunction;
import java.util.function.ObjDoubleConsumer; import java.util.function.ObjDoubleConsumer;
import java.util.function.ObjIntConsumer; import java.util.function.ObjIntConsumer;
import java.util.function.ObjLongConsumer; import java.util.function.ObjLongConsumer;
import java.util.function.Predicate; import java.util.function.Predicate;
import java.util.function.Supplier; import java.util.function.Supplier;
import java.util.function.ToDoubleBiFunction;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntBiFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongBiFunction;
import java.util.function.ToLongFunction;
import java.util.stream.Stream; import java.util.stream.Stream;
import org.apache.commons.lang3.Streams.FailableStream; import org.apache.commons.lang3.Streams.FailableStream;
@ -79,7 +97,7 @@ import org.apache.commons.lang3.Streams.FailableStream;
public class Functions { public class Functions {
/** /**
* A functional interface like {@link BiConsumer} that declares a Throwable. * A functional interface like {@link BiConsumer} that declares a {@code Throwable}.
* *
* @param <O1> Consumed type 1. * @param <O1> Consumed type 1.
* @param <O2> Consumed type 2. * @param <O2> Consumed type 2.
@ -99,15 +117,15 @@ public class Functions {
} }
/** /**
* A functional interface like {@link BiFunction} that declares a Throwable. * A functional interface like {@link BiFunction} that declares a {@code Throwable}.
* *
* @param <I1> Input type 1. * @param <O1> Input type 1.
* @param <I2> Input type 2. * @param <O2> Input type 2.
* @param <R> Return type. * @param <R> Return type.
* @param <T> Thrown exception. * @param <T> Thrown exception.
*/ */
@FunctionalInterface @FunctionalInterface
public interface FailableBiFunction<I1, I2, R, T extends Throwable> { public interface FailableBiFunction<O1, O2, R, T extends Throwable> {
/** /**
* Applies this function. * Applies this function.
@ -115,20 +133,20 @@ public class Functions {
* @param input1 the first input for the function * @param input1 the first input for the function
* @param input2 the second input for the function * @param input2 the second input for the function
* @return the result of the function * @return the result of the function
* @throws T if the function fails * @throws T Thrown when the function fails.
*/ */
R apply(I1 input1, I2 input2) throws T; R apply(O1 input1, O2 input2) throws T;
} }
/** /**
* A functional interface like {@link BiPredicate} that declares a Throwable. * A functional interface like {@link BiPredicate} that declares a {@code Throwable}.
* *
* @param <I1> Predicate type 1. * @param <O1> Predicate type 1.
* @param <I2> Predicate type 2. * @param <O2> Predicate type 2.
* @param <T> Thrown exception. * @param <T> Thrown exception.
*/ */
@FunctionalInterface @FunctionalInterface
public interface FailableBiPredicate<I1, I2, T extends Throwable> { public interface FailableBiPredicate<O1, O2, T extends Throwable> {
/** /**
* Tests the predicate. * Tests the predicate.
@ -138,11 +156,11 @@ public class Functions {
* @return the predicate's evaluation * @return the predicate's evaluation
* @throws T if the predicate fails * @throws T if the predicate fails
*/ */
boolean test(I1 object1, I2 object2) throws T; boolean test(O1 object1, O2 object2) throws T;
} }
/** /**
* A functional interface like {@link BooleanSupplier} that declares a Throwable. * A functional interface like {@link BooleanSupplier} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
* @since 3.11 * @since 3.11
@ -160,7 +178,7 @@ public class Functions {
} }
/** /**
* A functional interface like {@link java.util.concurrent.Callable} that declares a Throwable. * A functional interface like {@link java.util.concurrent.Callable} that declares a {@code Throwable}.
* *
* @param <R> Return type. * @param <R> Return type.
* @param <T> Thrown exception. * @param <T> Thrown exception.
@ -178,7 +196,7 @@ public class Functions {
} }
/** /**
* A functional interface like {@link Consumer} that declares a Throwable. * A functional interface like {@link Consumer} that declares a {@code Throwable}.
* *
* @param <O> Consumed type 1. * @param <O> Consumed type 1.
* @param <T> Thrown exception. * @param <T> Thrown exception.
@ -196,7 +214,27 @@ public class Functions {
} }
/** /**
* A functional interface like {@link DoubleConsumer} that declares a Throwable. * A functional interface like {@link DoubleBinaryOperator} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableDoubleBinaryOperator<T extends Throwable> {
/**
* Applies this operator to the given operands.
*
* @param left the first operand
* @param right the second operand
* @return the operator result
* @throws T if the operation fails
*/
double applyAsDouble(double left, double right) throws T;
}
/**
* A functional interface like {@link DoubleConsumer} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
* @since 3.11 * @since 3.11
@ -214,7 +252,26 @@ public class Functions {
} }
/** /**
* A functional interface like {@link DoubleSupplier} that declares a Throwable. * A functional interface like {@link DoubleFunction} that declares a {@code Throwable}.
*
* @param <R> Return type.
* @param <T> Thrown exception.
*/
@FunctionalInterface
public interface FailableDoubleFunction<R, T 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.
*/
R apply(double input) throws T;
}
/**
* A functional interface like {@link DoubleSupplier} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
* @since 3.11 * @since 3.11
@ -232,7 +289,45 @@ public class Functions {
} }
/** /**
* A functional interface like {@link Function} that declares a Throwable. * A functional interface like {@link DoubleToIntFunction} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableDoubleToIntFunction<T 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.
*/
int applyAsInt(double value) throws T;
}
/**
* A functional interface like {@link DoubleToLongFunction} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableDoubleToLongFunction<T extends Throwable> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
* @throws T if the operation fails
*/
int applyAsLong(double value) throws T;
}
/**
* A functional interface like {@link Function} that declares a {@code Throwable}.
* *
* @param <I> Input type 1. * @param <I> Input type 1.
* @param <R> Return type. * @param <R> Return type.
@ -246,13 +341,33 @@ public class Functions {
* *
* @param input the input for the function * @param input the input for the function
* @return the result of the function * @return the result of the function
* @throws T if the function fails * @throws T Thrown when the function fails.
*/ */
R apply(I input) throws T; R apply(I input) throws T;
} }
/** /**
* A functional interface like {@link IntConsumer} that declares a Throwable. * A functional interface like {@link IntBinaryOperator} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableIntBinaryOperator<T extends Throwable> {
/**
* Applies this operator to the given operands.
*
* @param left the first operand
* @param right the second operand
* @return the operator result
* @throws T if the operation fails
*/
int applyAsInt(int left, int right) throws T;
}
/**
* A functional interface like {@link IntConsumer} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
* @since 3.11 * @since 3.11
@ -270,7 +385,26 @@ public class Functions {
} }
/** /**
* A functional interface like {@link IntSupplier} that declares a Throwable. * A functional interface like {@link IntFunction} that declares a {@code Throwable}.
*
* @param <R> Return type.
* @param <T> Thrown exception.
*/
@FunctionalInterface
public interface FailableIntFunction<R, T 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.
*/
R apply(int input) throws T;
}
/**
* A functional interface like {@link IntSupplier} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
* @since 3.11 * @since 3.11
@ -288,7 +422,65 @@ public class Functions {
} }
/** /**
* A functional interface like {@link LongConsumer} that declares a Throwable. * A functional interface like {@link IntToDoubleFunction} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableIntToDoubleFunction<T 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.
*/
double applyAsDouble(int value) throws T;
}
/**
* A functional interface like {@link IntToLongFunction} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableIntToLongFunction<T 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.
*/
long applyAsLong(int value) throws T;
}
/**
* A functional interface like {@link LongBinaryOperator} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableLongBinaryOperator<T extends Throwable> {
/**
* Applies this operator to the given operands.
*
* @param left the first operand
* @param right the second operand
* @return the operator result
* @throws T if the operation fails
*/
long applyAsLong(long left, long right) throws T;
}
/**
* A functional interface like {@link LongConsumer} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
* @since 3.11 * @since 3.11
@ -306,7 +498,26 @@ public class Functions {
} }
/** /**
* A functional interface like {@link LongSupplier} that declares a Throwable. * A functional interface like {@link LongFunction} that declares a {@code Throwable}.
*
* @param <R> Return type.
* @param <T> Thrown exception.
*/
@FunctionalInterface
public interface FailableLongFunction<R, T 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.
*/
R apply(long input) throws T;
}
/**
* A functional interface like {@link LongSupplier} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
* @since 3.11 * @since 3.11
@ -324,7 +535,45 @@ public class Functions {
} }
/** /**
* A functional interface like {@link ObjDoubleConsumer} that declares a Throwable. * A functional interface like {@link LongToDoubleFunction} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableLongToDoubleFunction<T 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.
*/
double applyAsDouble(long value) throws T;
}
/**
* A functional interface like {@link LongToIntFunction} that declares a {@code Throwable}.
*
* @param <T> Thrown exception.
* @since 3.11
*/
@FunctionalInterface
public interface FailableLongToIntFunction<T 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.
*/
int applyAsInt(long value) throws T;
}
/**
* A functional interface like {@link ObjDoubleConsumer} that declares a {@code Throwable}.
* *
* @param <O> the type of the object argument to the operation. * @param <O> the type of the object argument to the operation.
* @param <T> Thrown exception. * @param <T> Thrown exception.
@ -344,7 +593,7 @@ public class Functions {
} }
/** /**
* A functional interface like {@link ObjIntConsumer} that declares a Throwable. * A functional interface like {@link ObjIntConsumer} that declares a {@code Throwable}.
* *
* @param <O> the type of the object argument to the operation. * @param <O> the type of the object argument to the operation.
* @param <T> Thrown exception. * @param <T> Thrown exception.
@ -364,7 +613,7 @@ public class Functions {
} }
/** /**
* A functional interface like {@link ObjLongConsumer} that declares a Throwable. * A functional interface like {@link ObjLongConsumer} that declares a {@code Throwable}.
* *
* @param <O> the type of the object argument to the operation. * @param <O> the type of the object argument to the operation.
* @param <T> Thrown exception. * @param <T> Thrown exception.
@ -384,7 +633,7 @@ public class Functions {
} }
/** /**
* A functional interface like {@link Predicate} that declares a Throwable. * A functional interface like {@link Predicate} that declares a {@code Throwable}.
* *
* @param <I> Predicate type 1. * @param <I> Predicate type 1.
* @param <T> Thrown exception. * @param <T> Thrown exception.
@ -403,7 +652,7 @@ public class Functions {
} }
/** /**
* A functional interface like {@link Runnable} that declares a Throwable. * A functional interface like {@link Runnable} that declares a {@code Throwable}.
* *
* @param <T> Thrown exception. * @param <T> Thrown exception.
*/ */
@ -413,13 +662,13 @@ public class Functions {
/** /**
* Runs the function. * Runs the function.
* *
* @throws T if the function fails * @throws T Thrown when the function fails.
*/ */
void run() throws T; void run() throws T;
} }
/** /**
* A functional interface like {@link Supplier} that declares a Throwable. * A functional interface like {@link Supplier} that declares a {@code Throwable}.
* *
* @param <R> Return type. * @param <R> Return type.
* @param <T> Thrown exception. * @param <T> Thrown exception.
@ -436,6 +685,132 @@ public class Functions {
R get() throws T; R get() throws T;
} }
/**
* 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.
* @since 3.11
*/
@FunctionalInterface
public interface FailableToDoubleBiFunction<O1, O2, T extends Throwable> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @param u the second function argument
* @return the function result
* @throws T Thrown when the function fails.
*/
double applyAsDouble(O1 t, O2 u) throws T;
}
/**
* 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.
* @since 3.11
*/
@FunctionalInterface
public interface FailableToDoubleFunction<I, T 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.
*/
double applyAsDouble(I t) throws T;
}
/**
* 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.
* @since 3.11
*/
@FunctionalInterface
public interface FailableToIntBiFunction<O1, O2, T extends Throwable> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @param u the second function argument
* @return the function result
* @throws T Thrown when the function fails.
*/
int applyAsInt(O1 t, O2 u) throws T;
}
/**
* 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.
* @since 3.11
*/
@FunctionalInterface
public interface FailableToIntFunction<I, T 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.
*/
int applyAsInt(I t) throws T;
}
/**
* 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.
* @since 3.11
*/
@FunctionalInterface
public interface FailableToLongBiFunction<O1, O2, T extends Throwable> {
/**
* Applies this function to the given arguments.
*
* @param t the first function argument
* @param u the second function argument
* @return the function result
* @throws T Thrown when the function fails.
*/
long applyAsLong(O1 t, O2 u) throws T;
}
/**
* 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.
* @since 3.11
*/
@FunctionalInterface
public interface FailableToLongFunction<I, T 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.
*/
long applyAsLong(I t) throws T;
}
/** /**
* Consumes a consumer and rethrows any exception as a {@link RuntimeException}. * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
* *
@ -505,14 +880,14 @@ public class Functions {
* @param function the function to apply * @param function the function to apply
* @param input1 the first input to apply {@code function} on * @param input1 the first input to apply {@code function} on
* @param input2 the second input to apply {@code function} on * @param input2 the second input to apply {@code function} on
* @param <I1> the type of the first argument the function accepts * @param <O1> the type of the first argument the function accepts
* @param <I2> the type of the second argument the function accepts * @param <O2> the type of the second argument the function accepts
* @param <O> the return type of the function * @param <O> the return type of the function
* @param <T> the type of checked exception the function may throw * @param <T> the type of checked exception the function may throw
* @return the value returned from the function * @return the value returned from the function
*/ */
public static <I1, I2, O, T extends Throwable> O apply(final FailableBiFunction<I1, I2, O, T> function, public static <O1, O2, O, T extends Throwable> O apply(final FailableBiFunction<O1, O2, O, T> function,
final I1 input1, final I2 input2) { final O1 input1, final O2 input2) {
return get(() -> function.apply(input1, input2)); return get(() -> function.apply(input1, input2));
} }
@ -530,43 +905,58 @@ public class Functions {
return get(() -> function.apply(input)); return get(() -> function.apply(input));
} }
/**
* Applies a function and rethrows any exception as a {@link RuntimeException}.
*
* @param function the function to apply
* @param left the first input to apply {@code function} on
* @param right the second input to apply {@code function} on
* @param <T> the type of checked exception the function may throw
* @return the value returned from the function
* @since 3.11
*/
public static <T extends Throwable> double applyAsDouble(final FailableDoubleBinaryOperator<T> function,
final double left, final double right) {
return getAsDouble(() -> function.applyAsDouble(left, right));
}
/** /**
* Converts the given {@link FailableBiConsumer} into a standard {@link BiConsumer}. * Converts the given {@link FailableBiConsumer} into a standard {@link BiConsumer}.
* *
* @param <I1> the type of the first argument of the consumers * @param <O1> the type of the first argument of the consumers
* @param <I2> the type of the second argument of the consumers * @param <O2> the type of the second argument of the consumers
* @param consumer a failable {@code BiConsumer} * @param consumer a failable {@code BiConsumer}
* @return a standard {@code BiConsumer} * @return a standard {@code BiConsumer}
* @since 3.10 * @since 3.10
*/ */
public static <I1, I2> BiConsumer<I1, I2> asBiConsumer(final FailableBiConsumer<I1, I2, ?> consumer) { public static <O1, O2> BiConsumer<O1, O2> asBiConsumer(final FailableBiConsumer<O1, O2, ?> consumer) {
return (input1, input2) -> accept(consumer, input1, input2); return (input1, input2) -> accept(consumer, input1, input2);
} }
/** /**
* Converts the given {@link FailableBiFunction} into a standard {@link BiFunction}. * Converts the given {@link FailableBiFunction} into a standard {@link BiFunction}.
* *
* @param <I1> the type of the first argument of the input of the functions * @param <O1> the type of the first argument of the input of the functions
* @param <I2> the type of the second argument of the input of the functions * @param <O2> the type of the second argument of the input of the functions
* @param <O> the type of the output of the functions * @param <O> the type of the output of the functions
* @param function a {@code FailableBiFunction} * @param function a {@code FailableBiFunction}
* @return a standard {@code BiFunction} * @return a standard {@code BiFunction}
* @since 3.10 * @since 3.10
*/ */
public static <I1, I2, O> BiFunction<I1, I2, O> asBiFunction(final FailableBiFunction<I1, I2, O, ?> function) { public static <O1, O2, O> BiFunction<O1, O2, O> asBiFunction(final FailableBiFunction<O1, O2, O, ?> function) {
return (input1, input2) -> apply(function, input1, input2); return (input1, input2) -> apply(function, input1, input2);
} }
/** /**
* Converts the given {@link FailableBiPredicate} into a standard {@link BiPredicate}. * Converts the given {@link FailableBiPredicate} into a standard {@link BiPredicate}.
* *
* @param <I1> the type of the first argument used by the predicates * @param <O1> the type of the first argument used by the predicates
* @param <I2> the type of the second argument used by the predicates * @param <O2> the type of the second argument used by the predicates
* @param predicate a {@code FailableBiPredicate} * @param predicate a {@code FailableBiPredicate}
* @return a standard {@code BiPredicate} * @return a standard {@code BiPredicate}
* @since 3.10 * @since 3.10
*/ */
public static <I1, I2> BiPredicate<I1, I2> asBiPredicate(final FailableBiPredicate<I1, I2, ?> predicate) { public static <O1, O2> BiPredicate<O1, O2> asBiPredicate(final FailableBiPredicate<O1, O2, ?> predicate) {
return (input1, input2) -> test(predicate, input1, input2); return (input1, input2) -> test(predicate, input1, input2);
} }

1616
src/test/java/org/apache/commons/lang3/FunctionsTest.java
View File

File diff suppressed because it is too large Load Diff