Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache Commons Lang v3 Source Code Files
Apache Commons Lang 3 is the 3rd version of Apache Commons Lang, which provides a host of helper utilities for the java.lang API.
Apache Commons Lang 3 Source Code files are provided in both binary packge (commons-lang3-3.12.0-bin.zip) and source package (commons-lang3-3.12.0-src.zip). You can download them at Apache Commons Lang Website.
Apache Commons Lang 3 Source Code has no dependencies and is compatible with Java 8 and newer versions. You can compile it to generate your own version of Apache Commons Lang 3 JAR file.
You can also browse the source code below:
✍: FYIcenter
⏎ org/apache/commons/lang3/Functions.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.lang3; import java.io.IOException; import java.io.UncheckedIOException; import java.lang.reflect.UndeclaredThrowableException; import java.util.Collection; import java.util.Objects; import java.util.concurrent.Callable; import java.util.function.BiConsumer; import java.util.function.BiFunction; import java.util.function.BiPredicate; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; import java.util.stream.Stream; import org.apache.commons.lang3.Streams.FailableStream; import org.apache.commons.lang3.function.FailableBooleanSupplier; /** * This class provides utility functions, and classes for working with the {@code java.util.function} package, or more * generally, with Java 8 lambdas. More specifically, it attempts to address the fact that lambdas are supposed not to * throw Exceptions, at least not checked Exceptions, AKA instances of {@link Exception}. This enforces the use of * constructs like: * * <pre> * {@code * Consumer<java.lang.reflect.Method> consumer = m -> { * try { * m.invoke(o, args); * } catch (Throwable t) { * throw Functions.rethrow(t); * } * }; * }</pre> * * <p> * By replacing a {@link java.util.function.Consumer Consumer<O>} with a {@link FailableConsumer * FailableConsumer<O,? extends Throwable>}, this can be written like follows: * </p> * * <pre> * {@code * Functions.accept((m) -> m.invoke(o,args)); * }</pre> * * <p> * Obviously, the second version is much more concise and the spirit of Lambda expressions is met better than the second * version. * </p> * @since 3.9 * @deprecated Use {@link org.apache.commons.lang3.function.Failable}. */ @Deprecated public class Functions { /** * A functional interface like {@link BiConsumer} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <O1> Consumed type 1. * @param <O2> Consumed type 2. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableBiConsumer}. */ @Deprecated @FunctionalInterface public interface FailableBiConsumer<O1, O2, T 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. */ void accept(O1 object1, O2 object2) throws T; } /** * A functional interface like {@link BiFunction} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <O1> Input type 1. * @param <O2> Input type 2. * @param <R> Return type. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableBiFunction}. */ @Deprecated @FunctionalInterface public interface FailableBiFunction<O1, O2, R, T extends Throwable> { /** * Applies this function. * * @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. */ R apply(O1 input1, O2 input2) throws T; } /** * A functional interface like {@link BiPredicate} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <O1> Predicate type 1. * @param <O2> Predicate type 2. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableBiPredicate}. */ @Deprecated @FunctionalInterface public interface FailableBiPredicate<O1, O2, T extends Throwable> { /** * Tests the predicate. * * @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 */ boolean test(O1 object1, O2 object2) throws T; } /** * A functional interface like {@link java.util.concurrent.Callable} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <R> Return type. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableCallable}. */ @Deprecated @FunctionalInterface public interface FailableCallable<R, T extends Throwable> { /** * Calls the callable. * * @return The value returned from the callable * @throws T if the callable fails */ R call() throws T; } /** * A functional interface like {@link Consumer} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <O> Consumed type 1. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableConsumer}. */ @Deprecated @FunctionalInterface public interface FailableConsumer<O, T extends Throwable> { /** * Accepts the consumer. * * @param object the parameter for the consumable to accept * @throws T Thrown when the consumer fails. */ void accept(O object) throws T; } /** * A functional interface like {@link Function} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <I> Input type 1. * @param <R> Return type. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableFunction}. */ @Deprecated @FunctionalInterface public interface FailableFunction<I, 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(I input) throws T; } /** * A functional interface like {@link Predicate} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <I> Predicate type 1. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailablePredicate}. */ @Deprecated @FunctionalInterface public interface FailablePredicate<I, T 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 */ boolean test(I object) throws T; } /** * A functional interface like {@link Runnable} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableRunnable}. */ @Deprecated @FunctionalInterface public interface FailableRunnable<T extends Throwable> { /** * Runs the function. * * @throws T Thrown when the function fails. */ void run() throws T; } /** * A functional interface like {@link Supplier} that declares a {@code Throwable}. * * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p> * * @param <R> Return type. * @param <T> Thrown exception. * @deprecated Use {@link org.apache.commons.lang3.function.FailableSupplier}. */ @Deprecated @FunctionalInterface public interface FailableSupplier<R, T extends Throwable> { /** * Supplies an object * * @return a result * @throws T if the supplier fails */ R get() throws T; } /** * Consumes a consumer and rethrows any exception as a {@link RuntimeException}. * * @param consumer the consumer to consume * @param object1 the first object to consume by {@code consumer} * @param object2 the second object to consume by {@code consumer} * @param <O1> the type of the first argument the consumer accepts * @param <O2> the type of the second argument the consumer accepts * @param <T> the type of checked exception the consumer may throw */ public static <O1, O2, T extends Throwable> void accept(final FailableBiConsumer<O1, O2, T> consumer, final O1 object1, final O2 object2) { run(() -> consumer.accept(object1, object2)); } /** * Consumes a consumer and rethrows any exception as a {@link RuntimeException}. * * @param consumer the consumer to consume * @param object the object to consume by {@code consumer} * @param <O> the type the consumer accepts * @param <T> the type of checked exception the consumer may throw */ public static <O, T extends Throwable> void accept(final FailableConsumer<O, T> consumer, final O object) { run(() -> consumer.accept(object)); } /** * Applies a function and rethrows any exception as a {@link RuntimeException}. * * @param function the function to apply * @param input1 the first input to apply {@code function} on * @param input2 the second input to apply {@code function} on * @param <O1> the type of the first argument the function accepts * @param <O2> the type of the second argument the function accepts * @param <O> the return type of the function * @param <T> the type of checked exception the function may throw * @return the value returned from the function */ public static <O1, O2, O, T extends Throwable> O apply(final FailableBiFunction<O1, O2, O, T> function, final O1 input1, final O2 input2) { return get(() -> function.apply(input1, input2)); } /** * Applies a function and rethrows any exception as a {@link RuntimeException}. * * @param function the function to apply * @param input the input to apply {@code function} on * @param <I> the type of the argument the function accepts * @param <O> the return type of the function * @param <T> the type of checked exception the function may throw * @return the value returned from the function */ public static <I, O, T extends Throwable> O apply(final FailableFunction<I, O, T> function, final I input) { return get(() -> function.apply(input)); } /** * Converts the given {@link FailableBiConsumer} into a standard {@link BiConsumer}. * * @param <O1> the type of the first argument of the consumers * @param <O2> the type of the second argument of the consumers * @param consumer a failable {@code BiConsumer} * @return a standard {@code BiConsumer} * @since 3.10 */ public static <O1, O2> BiConsumer<O1, O2> asBiConsumer(final FailableBiConsumer<O1, O2, ?> consumer) { return (input1, input2) -> accept(consumer, input1, input2); } /** * Converts the given {@link FailableBiFunction} into a standard {@link BiFunction}. * * @param <O1> the type of the first 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 function a {@code FailableBiFunction} * @return a standard {@code BiFunction} * @since 3.10 */ public static <O1, O2, O> BiFunction<O1, O2, O> asBiFunction(final FailableBiFunction<O1, O2, O, ?> function) { return (input1, input2) -> apply(function, input1, input2); } /** * Converts the given {@link FailableBiPredicate} into a standard {@link BiPredicate}. * * @param <O1> the type of the first argument used by the predicates * @param <O2> the type of the second argument used by the predicates * @param predicate a {@code FailableBiPredicate} * @return a standard {@code BiPredicate} * @since 3.10 */ public static <O1, O2> BiPredicate<O1, O2> asBiPredicate(final FailableBiPredicate<O1, O2, ?> predicate) { return (input1, input2) -> test(predicate, input1, input2); } /** * Converts the given {@link FailableCallable} into a standard {@link Callable}. * * @param <O> the type used by the callables * @param callable a {@code FailableCallable} * @return a standard {@code Callable} * @since 3.10 */ public static <O> Callable<O> asCallable(final FailableCallable<O, ?> callable) { return () -> call(callable); } /** * Converts the given {@link FailableConsumer} into a standard {@link Consumer}. * * @param <I> the type used by the consumers * @param consumer a {@code FailableConsumer} * @return a standard {@code Consumer} * @since 3.10 */ public static <I> Consumer<I> asConsumer(final FailableConsumer<I, ?> consumer) { return input -> accept(consumer, input); } /** * Converts the given {@link FailableFunction} into a standard {@link Function}. * * @param <I> the type of the input of the functions * @param <O> the type of the output of the functions * @param function a {code FailableFunction} * @return a standard {@code Function} * @since 3.10 */ public static <I, O> Function<I, O> asFunction(final FailableFunction<I, O, ?> function) { return input -> apply(function, input); } /** * Converts the given {@link FailablePredicate} into a standard {@link Predicate}. * * @param <I> the type used by the predicates * @param predicate a {@code FailablePredicate} * @return a standard {@code Predicate} * @since 3.10 */ public static <I> Predicate<I> asPredicate(final FailablePredicate<I, ?> predicate) { return input -> test(predicate, input); } /** * Converts the given {@link FailableRunnable} into a standard {@link Runnable}. * * @param runnable a {@code FailableRunnable} * @return a standard {@code Runnable} * @since 3.10 */ public static Runnable asRunnable(final FailableRunnable<?> runnable) { return () -> run(runnable); } /** * Converts the given {@link FailableSupplier} into a standard {@link Supplier}. * * @param <O> the type supplied by the suppliers * @param supplier a {@code FailableSupplier} * @return a standard {@code Supplier} * @since 3.10 */ public static <O> Supplier<O> asSupplier(final FailableSupplier<O, ?> supplier) { return () -> get(supplier); } /** * Calls a callable and rethrows any exception as a {@link RuntimeException}. * * @param callable the callable to call * @param <O> the return type of the callable * @param <T> the type of checked exception the callable may throw * @return the value returned from the callable */ public static <O, T extends Throwable> O call(final FailableCallable<O, T> callable) { return get(callable::call); } /** * Invokes a supplier, and returns the result. * * @param supplier The supplier to invoke. * @param <O> The suppliers output type. * @param <T> The type of checked exception, which the supplier can throw. * @return The object, which has been created by the supplier * @since 3.10 */ public static <O, T extends Throwable> O get(final FailableSupplier<O, T> supplier) { try { return supplier.get(); } catch (final Throwable t) { throw rethrow(t); } } /** * Invokes a boolean supplier, and returns the result. * * @param supplier The boolean supplier to invoke. * @param <T> The type of checked exception, which the supplier can throw. * @return The boolean, which has been created by the supplier */ private static <T extends Throwable> boolean getAsBoolean(final FailableBooleanSupplier<T> supplier) { try { return supplier.getAsBoolean(); } catch (final Throwable t) { throw rethrow(t); } } /** * <p> * Rethrows a {@link Throwable} as an unchecked exception. If the argument is already unchecked, namely a * {@code RuntimeException} or {@code Error} then the argument will be rethrown without modification. If the * exception is {@code IOException} then it will be wrapped into a {@code UncheckedIOException}. In every other * cases the exception will be wrapped into a {@code * UndeclaredThrowableException} * </p> * * <p> * Note that there is a declared return type for this method, even though it never returns. The reason for that is * to support the usual pattern: * </p> * * <pre> * throw rethrow(myUncheckedException);</pre> * * <p> * instead of just calling the method. This pattern may help the Java compiler to recognize that at that point an * exception will be thrown and the code flow analysis will not demand otherwise mandatory commands that could * follow the method call, like a {@code return} statement from a value returning method. * </p> * * @param throwable The throwable to rethrow ossibly wrapped into an unchecked exception * @return Never returns anything, this method never terminates normally. */ public static RuntimeException rethrow(final Throwable throwable) { Objects.requireNonNull(throwable, "throwable"); if (throwable instanceof RuntimeException) { throw (RuntimeException) throwable; } else if (throwable instanceof Error) { throw (Error) throwable; } else if (throwable instanceof IOException) { throw new UncheckedIOException((IOException) throwable); } else { throw new UndeclaredThrowableException(throwable); } } /** * Runs a runnable and rethrows any exception as a {@link RuntimeException}. * * @param runnable The runnable to run * @param <T> the type of checked exception the runnable may throw */ public static <T extends Throwable> void run(final FailableRunnable<T> runnable) { try { runnable.run(); } catch (final Throwable t) { throw rethrow(t); } } /** * Converts the given collection into a {@link FailableStream}. The {@link FailableStream} consists of the * collections elements. Shortcut for * * <pre> * Functions.stream(collection.stream());</pre> * * @param collection The collection, which is being converted into a {@link FailableStream}. * @param <O> The collections element type. (In turn, the result streams element type.) * @return The created {@link FailableStream}. * @since 3.10 */ public static <O> FailableStream<O> stream(final Collection<O> collection) { return new FailableStream<>(collection.stream()); } /** * Converts the given stream into a {@link FailableStream}. The {@link FailableStream} consists of the same * elements, than the input stream. However, failable lambdas, like {@link FailablePredicate}, * {@link FailableFunction}, and {@link FailableConsumer} may be applied, rather than {@link Predicate}, * {@link Function}, {@link Consumer}, etc. * * @param stream The stream, which is being converted into a {@link FailableStream}. * @param <O> The streams element type. * @return The created {@link FailableStream}. * @since 3.10 */ public static <O> FailableStream<O> stream(final Stream<O> stream) { return new FailableStream<>(stream); } /** * Tests a predicate and rethrows any exception as a {@link RuntimeException}. * * @param predicate the predicate to test * @param object1 the first input to test by {@code predicate} * @param object2 the second input to test by {@code predicate} * @param <O1> the type of the first argument the predicate tests * @param <O2> the type of the second argument the predicate tests * @param <T> the type of checked exception the predicate may throw * @return the boolean value returned by the predicate */ public static <O1, O2, T extends Throwable> boolean test(final FailableBiPredicate<O1, O2, T> predicate, final O1 object1, final O2 object2) { return getAsBoolean(() -> predicate.test(object1, object2)); } /** * Tests a predicate and rethrows any exception as a {@link RuntimeException}. * * @param predicate the predicate to test * @param object the input to test by {@code predicate} * @param <O> the type of argument the predicate tests * @param <T> the type of checked exception the predicate may throw * @return the boolean value returned by the predicate */ public static <O, T extends Throwable> boolean test(final FailablePredicate<O, T> predicate, final O object) { return getAsBoolean(() -> predicate.test(object)); } /** * A simple try-with-resources implementation, that can be used, if your objects do not implement the * {@link AutoCloseable} interface. The method executes the {@code action}. The method guarantees, that <em>all</em> * the {@code resources} are being executed, in the given order, afterwards, and regardless of success, or failure. * If either the original action, or any of the resource action fails, then the <em>first</em> failure (AKA * {@link Throwable} is rethrown. Example use: * * <pre> * {@code * final FileInputStream fis = new FileInputStream("my.file"); * Functions.tryWithResources(useInputStream(fis), null, () -> fis.close()); * }</pre> * * @param action The action to execute. This object <em>will</em> always be invoked. * @param errorHandler An optional error handler, which will be invoked finally, if any error occurred. The error * handler will receive the first error, AKA {@link Throwable}. * @param resources The resource actions to execute. <em>All</em> resource actions will be invoked, in the given * order. A resource action is an instance of {@link FailableRunnable}, which will be executed. * @see #tryWithResources(FailableRunnable, FailableRunnable...) */ @SafeVarargs public static void tryWithResources(final FailableRunnable<? extends Throwable> action, final FailableConsumer<Throwable, ? extends Throwable> errorHandler, final FailableRunnable<? extends Throwable>... resources) { final FailableConsumer<Throwable, ? extends Throwable> actualErrorHandler; if (errorHandler == null) { actualErrorHandler = Functions::rethrow; } else { actualErrorHandler = errorHandler; } if (resources != null) { for (final FailableRunnable<? extends Throwable> failableRunnable : resources) { Objects.requireNonNull(failableRunnable, "runnable"); } } Throwable th = null; try { action.run(); } catch (final Throwable t) { th = t; } if (resources != null) { for (final FailableRunnable<?> runnable : resources) { try { runnable.run(); } catch (final Throwable t) { if (th == null) { th = t; } } } } if (th != null) { try { actualErrorHandler.accept(th); } catch (final Throwable t) { throw rethrow(t); } } } /** * A simple try-with-resources implementation, that can be used, if your objects do not implement the * {@link AutoCloseable} interface. The method executes the {@code action}. The method guarantees, that <em>all</em> * the {@code resources} are being executed, in the given order, afterwards, and regardless of success, or failure. * If either the original action, or any of the resource action fails, then the <em>first</em> failure (AKA * {@link Throwable} is rethrown. Example use: * * <pre> * {@code * final FileInputStream fis = new FileInputStream("my.file"); * Functions.tryWithResources(useInputStream(fis), () -> fis.close()); * }</pre> * * @param action The action to execute. This object <em>will</em> always be invoked. * @param resources The resource actions to execute. <em>All</em> resource actions will be invoked, in the given * order. A resource action is an instance of {@link FailableRunnable}, which will be executed. * @see #tryWithResources(FailableRunnable, FailableConsumer, FailableRunnable...) */ @SafeVarargs public static void tryWithResources(final FailableRunnable<? extends Throwable> action, final FailableRunnable<? extends Throwable>... resources) { tryWithResources(action, null, resources); } }
⏎ org/apache/commons/lang3/Functions.java
Or download all of them as a single archive file:
File name: commons-lang3-3.12.0-sources.jar File size: 651724 bytes Release date: 2020-01-22 Download
⇒ Download and Install commons-lang3-3.8.1-bin.zip
⇐ Download Apache Commons Lang v3 Source Package
2022-10-19, 156922👍, 3💬
Popular Posts:
Java Architecture for XML Binding (JAXB) is a Java API that allows Java developers to map Java class...
What Is jaxb-api-2.1.6.jar? Java Architecture for XML Binding (JAXB) is a Java API that allows Java ...
What Is jms.jar? I heard it's related to JMS (Java Message Service) 1.1? The if you have an jms.jar ...
How to merge two JAR files with "jar" commands? I am tired of specifying multiple JAR files in the c...
kernel.jar is a component in iText Java library to provide low-level functionalities. iText Java lib...