Java tutorial
/* * Copyright (c) 2016 Gridtec. All rights reserved. * * Licensed 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 at.gridtec.lambda4j.predicate.tri; import at.gridtec.lambda4j.Lambda; import at.gridtec.lambda4j.consumer.ThrowableBooleanConsumer; import at.gridtec.lambda4j.consumer.tri.ThrowableTriLongConsumer; import at.gridtec.lambda4j.core.exception.ThrownByFunctionalInterfaceException; import at.gridtec.lambda4j.core.util.ThrowableUtils; import at.gridtec.lambda4j.function.ThrowableBooleanFunction; import at.gridtec.lambda4j.function.ThrowableFunction; import at.gridtec.lambda4j.function.conversion.ThrowableBooleanToByteFunction; import at.gridtec.lambda4j.function.conversion.ThrowableBooleanToCharFunction; import at.gridtec.lambda4j.function.conversion.ThrowableBooleanToDoubleFunction; import at.gridtec.lambda4j.function.conversion.ThrowableBooleanToFloatFunction; import at.gridtec.lambda4j.function.conversion.ThrowableBooleanToIntFunction; import at.gridtec.lambda4j.function.conversion.ThrowableBooleanToLongFunction; import at.gridtec.lambda4j.function.conversion.ThrowableBooleanToShortFunction; import at.gridtec.lambda4j.function.conversion.ThrowableByteToLongFunction; import at.gridtec.lambda4j.function.conversion.ThrowableCharToLongFunction; import at.gridtec.lambda4j.function.conversion.ThrowableDoubleToLongFunction; import at.gridtec.lambda4j.function.conversion.ThrowableFloatToLongFunction; import at.gridtec.lambda4j.function.conversion.ThrowableIntToLongFunction; import at.gridtec.lambda4j.function.conversion.ThrowableShortToLongFunction; import at.gridtec.lambda4j.function.to.ThrowableToLongFunction; import at.gridtec.lambda4j.function.tri.ThrowableTriLongFunction; import at.gridtec.lambda4j.function.tri.conversion.ThrowableTriLongToByteFunction; import at.gridtec.lambda4j.function.tri.conversion.ThrowableTriLongToCharFunction; import at.gridtec.lambda4j.function.tri.conversion.ThrowableTriLongToDoubleFunction; import at.gridtec.lambda4j.function.tri.conversion.ThrowableTriLongToFloatFunction; import at.gridtec.lambda4j.function.tri.conversion.ThrowableTriLongToIntFunction; import at.gridtec.lambda4j.function.tri.conversion.ThrowableTriLongToShortFunction; import at.gridtec.lambda4j.operator.ternary.ThrowableBooleanTernaryOperator; import at.gridtec.lambda4j.operator.ternary.ThrowableLongTernaryOperator; import at.gridtec.lambda4j.operator.unary.ThrowableBooleanUnaryOperator; import at.gridtec.lambda4j.operator.unary.ThrowableLongUnaryOperator; import at.gridtec.lambda4j.predicate.ThrowableLongPredicate; import at.gridtec.lambda4j.predicate.bi.ThrowableBiLongPredicate; import org.apache.commons.lang3.tuple.Triple; import javax.annotation.Nonnegative; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.util.Map; import java.util.Objects; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; /** * Represents an predicate (boolean-valued function) of three {@code long}-valued input arguments which is able to throw * any {@link Throwable}. This is a primitive specialization of {@link ThrowableTriPredicate}. * <p> * This is a {@link FunctionalInterface} whose functional method is {@link #testThrows(long, long, long)}. * * @param <X> The type of the throwable to be thrown by this predicate * @see ThrowableTriPredicate */ @SuppressWarnings("unused") @FunctionalInterface public interface ThrowableTriLongPredicate<X extends Throwable> extends Lambda { /** * Constructs a {@link ThrowableTriLongPredicate} based on a lambda expression or a method reference. Thereby the * given lambda expression or method reference is returned on an as-is basis to implicitly transform it to the * desired type. With this method, it is possible to ensure that correct type is used from lambda expression or * method reference. * * @param <X> The type of the throwable to be thrown by this predicate * @param expression A lambda expression or (typically) a method reference, e.g. {@code this::method} * @return A {@code ThrowableTriLongPredicate} from given lambda expression or method reference. * @implNote This implementation allows the given argument to be {@code null}, but only if {@code null} given, * {@code null} will be returned. * @see <a href="https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax">Lambda * Expression</a> * @see <a href="https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html">Method Reference</a> */ static <X extends Throwable> ThrowableTriLongPredicate<X> of( @Nullable final ThrowableTriLongPredicate<X> expression) { return expression; } /** * Calls the given {@link ThrowableTriLongPredicate} with the given arguments and returns its result. * * @param <X> The type of the throwable to be thrown by this predicate * @param predicate The predicate to be called * @param value1 The first argument to the predicate * @param value2 The second argument to the predicate * @param value3 The third argument to the predicate * @return The result from the given {@code ThrowableTriLongPredicate}. * @throws NullPointerException If given argument is {@code null} * @throws X Any throwable from this predicates action */ static <X extends Throwable> boolean call(@Nonnull final ThrowableTriLongPredicate<? extends X> predicate, long value1, long value2, long value3) throws X { Objects.requireNonNull(predicate); return predicate.testThrows(value1, value2, value3); } /** * Creates a {@link ThrowableTriLongPredicate} which uses the {@code first} parameter of this one as argument for * the given {@link ThrowableLongPredicate}. * * @param <X> The type of the throwable to be thrown by this predicate * @param predicate The predicate which accepts the {@code first} parameter of this one * @return Creates a {@code ThrowableTriLongPredicate} which uses the {@code first} parameter of this one as * argument for the given {@code ThrowableLongPredicate}. * @throws NullPointerException If given argument is {@code null} */ @Nonnull static <X extends Throwable> ThrowableTriLongPredicate<X> onlyFirst( @Nonnull final ThrowableLongPredicate<? extends X> predicate) { Objects.requireNonNull(predicate); return (value1, value2, value3) -> predicate.testThrows(value1); } /** * Creates a {@link ThrowableTriLongPredicate} which uses the {@code second} parameter of this one as argument for * the given {@link ThrowableLongPredicate}. * * @param <X> The type of the throwable to be thrown by this predicate * @param predicate The predicate which accepts the {@code second} parameter of this one * @return Creates a {@code ThrowableTriLongPredicate} which uses the {@code second} parameter of this one as * argument for the given {@code ThrowableLongPredicate}. * @throws NullPointerException If given argument is {@code null} */ @Nonnull static <X extends Throwable> ThrowableTriLongPredicate<X> onlySecond( @Nonnull final ThrowableLongPredicate<? extends X> predicate) { Objects.requireNonNull(predicate); return (value1, value2, value3) -> predicate.testThrows(value2); } /** * Creates a {@link ThrowableTriLongPredicate} which uses the {@code third} parameter of this one as argument for * the given {@link ThrowableLongPredicate}. * * @param <X> The type of the throwable to be thrown by this predicate * @param predicate The predicate which accepts the {@code third} parameter of this one * @return Creates a {@code ThrowableTriLongPredicate} which uses the {@code third} parameter of this one as * argument for the given {@code ThrowableLongPredicate}. * @throws NullPointerException If given argument is {@code null} */ @Nonnull static <X extends Throwable> ThrowableTriLongPredicate<X> onlyThird( @Nonnull final ThrowableLongPredicate<? extends X> predicate) { Objects.requireNonNull(predicate); return (value1, value2, value3) -> predicate.testThrows(value3); } /** * Creates a {@link ThrowableTriLongPredicate} which always returns a given value. * * @param <X> The type of the throwable to be thrown by this predicate * @param ret The return value for the constant * @return A {@code ThrowableTriLongPredicate} which always returns a given value. */ @Nonnull static <X extends Throwable> ThrowableTriLongPredicate<X> constant(boolean ret) { return (value1, value2, value3) -> ret; } /** * Returns a {@link ThrowableTriLongPredicate} that always returns {@code true}. * * @param <X> The type of the throwable to be thrown by this predicate * @return A {@link ThrowableTriLongPredicate} that always returns {@code true}. * @see #alwaysFalse() */ @Nonnull static <X extends Throwable> ThrowableTriLongPredicate<X> alwaysTrue() { return (value1, value2, value3) -> true; } /** * Returns a {@link ThrowableTriLongPredicate} that always returns {@code false}. * * @param <X> The type of the throwable to be thrown by this predicate * @return A {@link ThrowableTriLongPredicate} that always returns {@code false}. * @see #alwaysTrue() */ @Nonnull static <X extends Throwable> ThrowableTriLongPredicate<X> alwaysFalse() { return (value1, value2, value3) -> false; } /** * Returns a {@link ThrowableTriLongPredicate} that tests if the given arguments are <b>equal</b> to the ones of * this predicate. * * @param <X> The type of the throwable to be thrown by this predicate * @param target1 The first reference with which to compare for equality, which may be {@code null} * @param target2 The second reference with which to compare for equality, which may be {@code null} * @param target3 The third reference with which to compare for equality, which may be {@code null} * @return A {@code ThrowableTriLongPredicate} that tests if the given arguments are <b>equal</b> to the ones of * this predicate. * @implNote This implementation checks equality according to {@link Objects#equals(Object)} operation for {@link * Object} references and {@code value == target} operation for primitive values. */ @Nonnull static <X extends Throwable> ThrowableTriLongPredicate<X> isEqual(long target1, long target2, long target3) { return (value1, value2, value3) -> (value1 == target1) && (value2 == target2) && (value3 == target3); } /** * Applies this predicate to the given arguments. * * @param value1 The first argument to the predicate * @param value2 The second argument to the predicate * @param value3 The third argument to the predicate * @return The return value from the predicate, which is its result. * @throws X Any throwable from this predicates action */ boolean testThrows(long value1, long value2, long value3) throws X; /** * Applies this predicate partially to some arguments of this one, producing a {@link ThrowableBiLongPredicate} as * result. * * @param value1 The first argument to this predicate used to partially apply this function * @return A {@code ThrowableBiLongPredicate} that represents this predicate partially applied the some arguments. */ @Nonnull default ThrowableBiLongPredicate<X> ptestThrows(long value1) { return (value2, value3) -> this.testThrows(value1, value2, value3); } /** * Applies this predicate partially to some arguments of this one, producing a {@link ThrowableLongPredicate} as * result. * * @param value1 The first argument to this predicate used to partially apply this function * @param value2 The second argument to this predicate used to partially apply this function * @return A {@code ThrowableLongPredicate} that represents this predicate partially applied the some arguments. */ @Nonnull default ThrowableLongPredicate<X> ptestThrows(long value1, long value2) { return (value3) -> this.testThrows(value1, value2, value3); } /** * Returns the number of arguments for this predicate. * * @return The number of arguments for this predicate. * @implSpec The default implementation always returns {@code 3}. */ @Nonnegative default int arity() { return 3; } /** * Returns a composed {@link ThrowableTriPredicate} that first applies the {@code before} functions to its input, * and then applies this predicate to the result. * * @param <A> The type of the argument to the first given function, and of composed predicate * @param <B> The type of the argument to the second given function, and of composed predicate * @param <C> The type of the argument to the third given function, and of composed predicate * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableTriPredicate} that first applies the {@code before} functions to its input, * and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is able to handle every type. */ @Nonnull default <A, B, C> ThrowableTriPredicate<A, B, C, X> compose( @Nonnull final ThrowableToLongFunction<? super A, ? extends X> before1, @Nonnull final ThrowableToLongFunction<? super B, ? extends X> before2, @Nonnull final ThrowableToLongFunction<? super C, ? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (a, b, c) -> testThrows(before1.applyAsLongThrows(a), before2.applyAsLongThrows(b), before3.applyAsLongThrows(c)); } /** * Returns a composed {@link ThrowableBooleanTernaryOperator} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. This method is just convenience, to provide the ability to * execute an operation which accepts {@code boolean} input, before this primitive predicate is executed. * * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableBooleanTernaryOperator} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * boolean}. */ @Nonnull default ThrowableBooleanTernaryOperator<X> composeFromBoolean( @Nonnull final ThrowableBooleanToLongFunction<? extends X> before1, @Nonnull final ThrowableBooleanToLongFunction<? extends X> before2, @Nonnull final ThrowableBooleanToLongFunction<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriBytePredicate} that first applies the {@code before} functions to * its input, and then applies this predicate to the result. * This method is just convenience, to provide the ability to execute an operation which accepts {@code byte} input, * before this primitive predicate is executed. * * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableTriBytePredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * byte}. */ @Nonnull default ThrowableTriBytePredicate<X> composeFromByte( @Nonnull final ThrowableByteToLongFunction<? extends X> before1, @Nonnull final ThrowableByteToLongFunction<? extends X> before2, @Nonnull final ThrowableByteToLongFunction<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriCharPredicate} that first applies the {@code before} functions to * its input, and then applies this predicate to the result. * This method is just convenience, to provide the ability to execute an operation which accepts {@code char} input, * before this primitive predicate is executed. * * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableTriCharPredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * char}. */ @Nonnull default ThrowableTriCharPredicate<X> composeFromChar( @Nonnull final ThrowableCharToLongFunction<? extends X> before1, @Nonnull final ThrowableCharToLongFunction<? extends X> before2, @Nonnull final ThrowableCharToLongFunction<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriDoublePredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. This method is just convenience, to provide the ability to * execute an operation which accepts {@code double} input, before this primitive predicate is executed. * * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableTriDoublePredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * double}. */ @Nonnull default ThrowableTriDoublePredicate<X> composeFromDouble( @Nonnull final ThrowableDoubleToLongFunction<? extends X> before1, @Nonnull final ThrowableDoubleToLongFunction<? extends X> before2, @Nonnull final ThrowableDoubleToLongFunction<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriFloatPredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. This method is just convenience, to provide the ability to * execute an operation which accepts {@code float} input, before this primitive predicate is executed. * * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableTriFloatPredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * float}. */ @Nonnull default ThrowableTriFloatPredicate<X> composeFromFloat( @Nonnull final ThrowableFloatToLongFunction<? extends X> before1, @Nonnull final ThrowableFloatToLongFunction<? extends X> before2, @Nonnull final ThrowableFloatToLongFunction<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriIntPredicate} that first applies the {@code before} functions to * its input, and then applies this predicate to the result. * This method is just convenience, to provide the ability to execute an operation which accepts {@code int} input, * before this primitive predicate is executed. * * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableTriIntPredicate} that first applies the {@code before} functions to its input, * and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * int}. */ @Nonnull default ThrowableTriIntPredicate<X> composeFromInt( @Nonnull final ThrowableIntToLongFunction<? extends X> before1, @Nonnull final ThrowableIntToLongFunction<? extends X> before2, @Nonnull final ThrowableIntToLongFunction<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriLongPredicate} that first applies the {@code before} operators to * its input, and then applies this predicate to the result. * This method is just convenience, to provide the ability to execute an operation which accepts {@code long} input, * before this primitive predicate is executed. * * @param before1 The first operator to apply before this predicate is applied * @param before2 The second operator to apply before this predicate is applied * @param before3 The third operator to apply before this predicate is applied * @return A composed {@code ThrowableTriLongPredicate} that first applies the {@code before} operators to its * input, and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * long}. */ @Nonnull default ThrowableTriLongPredicate<X> composeFromLong( @Nonnull final ThrowableLongUnaryOperator<? extends X> before1, @Nonnull final ThrowableLongUnaryOperator<? extends X> before2, @Nonnull final ThrowableLongUnaryOperator<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriShortPredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. This method is just convenience, to provide the ability to * execute an operation which accepts {@code short} input, before this primitive predicate is executed. * * @param before1 The first function to apply before this predicate is applied * @param before2 The second function to apply before this predicate is applied * @param before3 The third function to apply before this predicate is applied * @return A composed {@code ThrowableTriShortPredicate} that first applies the {@code before} functions to its * input, and then applies this predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * short}. */ @Nonnull default ThrowableTriShortPredicate<X> composeFromShort( @Nonnull final ThrowableShortToLongFunction<? extends X> before1, @Nonnull final ThrowableShortToLongFunction<? extends X> before2, @Nonnull final ThrowableShortToLongFunction<? extends X> before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> testThrows(before1.applyAsLongThrows(value1), before2.applyAsLongThrows(value2), before3.applyAsLongThrows(value3)); } /** * Returns a composed {@link ThrowableTriLongFunction} that first applies this predicate to its input, and then * applies the {@code after} function to the result. * * @param <S> The type of return value from the {@code after} function, and of the composed function * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableTriLongFunction} that first applies this predicate to its input, and then * applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is able to return every type. */ @Nonnull default <S> ThrowableTriLongFunction<S, X> andThen( @Nonnull final ThrowableBooleanFunction<? extends S, ? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongPredicate} that first applies this predicate to its input, and then * applies the {@code after} operator to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code boolean}. * * @param after The operator to apply after this predicate is applied * @return A composed {@code ThrowableTriLongPredicate} that first applies this predicate to its input, and then * applies the {@code after} operator to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * boolean}. */ @Nonnull default ThrowableTriLongPredicate<X> andThenToBoolean( @Nonnull final ThrowableBooleanUnaryOperator<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsBooleanThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongToByteFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code byte}. * * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableTriLongToByteFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * byte}. */ @Nonnull default ThrowableTriLongToByteFunction<X> andThenToByte( @Nonnull final ThrowableBooleanToByteFunction<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsByteThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongToCharFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code char}. * * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableTriLongToCharFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * char}. */ @Nonnull default ThrowableTriLongToCharFunction<X> andThenToChar( @Nonnull final ThrowableBooleanToCharFunction<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsCharThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongToDoubleFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code double}. * * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableTriLongToDoubleFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * double}. */ @Nonnull default ThrowableTriLongToDoubleFunction<X> andThenToDouble( @Nonnull final ThrowableBooleanToDoubleFunction<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsDoubleThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongToFloatFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code float}. * * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableTriLongToFloatFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * float}. */ @Nonnull default ThrowableTriLongToFloatFunction<X> andThenToFloat( @Nonnull final ThrowableBooleanToFloatFunction<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsFloatThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongToIntFunction} that first applies this predicate to its input, and then * applies the {@code after} function to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code int}. * * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableTriLongToIntFunction} that first applies this predicate to its input, and then * applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * int}. */ @Nonnull default ThrowableTriLongToIntFunction<X> andThenToInt( @Nonnull final ThrowableBooleanToIntFunction<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsIntThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableLongTernaryOperator} that first applies this predicate to its input, and then * applies the {@code after} function to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code long}. * * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableLongTernaryOperator} that first applies this predicate to its input, and then * applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * long}. */ @Nonnull default ThrowableLongTernaryOperator<X> andThenToLong( @Nonnull final ThrowableBooleanToLongFunction<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsLongThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongToShortFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. This method is just convenience, to provide the ability to * transform this primitive predicate to an operation returning {@code short}. * * @param after The function to apply after this predicate is applied * @return A composed {@code ThrowableTriLongToShortFunction} that first applies this predicate to its input, and * then applies the {@code after} function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * short}. */ @Nonnull default ThrowableTriLongToShortFunction<X> andThenToShort( @Nonnull final ThrowableBooleanToShortFunction<? extends X> after) { Objects.requireNonNull(after); return (value1, value2, value3) -> after.applyAsShortThrows(testThrows(value1, value2, value3)); } /** * Returns a composed {@link ThrowableTriLongConsumer} that fist applies this predicate to its input, and then * consumes the result using the given {@link ThrowableBooleanConsumer}. * * @param consumer The operation which consumes the result from this operation * @return A composed {@code ThrowableTriLongConsumer} that first applies this predicate to its input, and then * consumes the result using the given {@code ThrowableBooleanConsumer}. * @throws NullPointerException If given argument is {@code null} */ @Nonnull default ThrowableTriLongConsumer<X> consume(@Nonnull final ThrowableBooleanConsumer<? extends X> consumer) { Objects.requireNonNull(consumer); return (value1, value2, value3) -> consumer.acceptThrows(testThrows(value1, value2, value3)); } /** * Returns a {@link ThrowableTriLongPredicate} that represents the logical negation of this one. * * @return A {@code ThrowableTriLongPredicate} that represents the logical negation of this one. */ @Nonnull default ThrowableTriLongPredicate<X> negate() { return (value1, value2, value3) -> !testThrows(value1, value2, value3); } /** * Returns a composed {@link ThrowableTriLongPredicate} that represents a short-circuiting logical AND of this * predicate and another. When evaluating the composed predicate, if this predicate is {@code false}, then the * {@code other} predicate is not evaluated. * <p> * Any exceptions thrown during evaluation of either predicate is relayed to the caller; if evaluation of this * {@code ThrowableTriLongPredicate} throws an exception, the {@code other} predicate will not be evaluated. * * @param other A {@code ThrowableTriLongPredicate} that will be logically-ANDed with this one * @return A composed {@code ThrowableTriLongPredicate} that represents the short-circuiting logical AND of this * predicate and the {@code other} predicate. * @throws NullPointerException If given argument is {@code null} * @see #or(ThrowableTriLongPredicate) * @see #xor(ThrowableTriLongPredicate) */ @Nonnull default ThrowableTriLongPredicate<X> and(@Nonnull final ThrowableTriLongPredicate<? extends X> other) { Objects.requireNonNull(other); return (value1, value2, value3) -> testThrows(value1, value2, value3) && other.testThrows(value1, value2, value3); } /** * Returns a composed {@link ThrowableTriLongPredicate} that represents a short-circuiting logical OR of this * predicate and another. When evaluating the composed predicate, if this predicate is {@code true}, then the {@code * other} predicate is not evaluated. * <p> * Any exceptions thrown during evaluation of either predicate is relayed to the caller; if evaluation of this * {@code ThrowableTriLongPredicate} throws an exception, the {@code other} predicate will not be evaluated. * * @param other A {@code ThrowableTriLongPredicate} that will be logically-ORed with this one * @return A composed {@code ThrowableTriLongPredicate} that represents the short-circuiting logical OR of this * predicate and the {@code other} predicate. * @throws NullPointerException If given argument is {@code null} * @see #and(ThrowableTriLongPredicate) * @see #xor(ThrowableTriLongPredicate) */ @Nonnull default ThrowableTriLongPredicate<X> or(@Nonnull final ThrowableTriLongPredicate<? extends X> other) { Objects.requireNonNull(other); return (value1, value2, value3) -> testThrows(value1, value2, value3) || other.testThrows(value1, value2, value3); } /** * Returns a composed {@link ThrowableTriLongPredicate} that represents a short-circuiting logical XOR of this * predicate and another. Any exceptions thrown during evaluation of either predicate is relayed to the caller; if * evaluation of this {@code ThrowableTriLongPredicate} throws an exception, the {@code other} predicate will not be * evaluated. * * @param other A {@code ThrowableTriLongPredicate} that will be logically-XORed with this one * @return A composed {@code ThrowableTriLongPredicate} that represents the short-circuiting logical XOR of this * predicate and the {@code other} predicate. * @throws NullPointerException If given argument is {@code null} * @see #and(ThrowableTriLongPredicate) * @see #or(ThrowableTriLongPredicate) */ @Nonnull default ThrowableTriLongPredicate<X> xor(@Nonnull final ThrowableTriLongPredicate<? extends X> other) { Objects.requireNonNull(other); return (value1, value2, value3) -> testThrows(value1, value2, value3) ^ other.testThrows(value1, value2, value3); } /** * Returns a memoized (caching) version of this {@link ThrowableTriLongPredicate}. Whenever it is called, the * mapping between the input parameters and the return value is preserved in a cache, making subsequent calls * returning the memoized value instead of computing the return value again. * <p> * Unless the predicate and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ThrowableTriLongPredicate}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized predicate, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized predicate can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ThrowableTriLongPredicate<X> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<Long, Long, Long>, Boolean> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ThrowableTriLongPredicate<X> & Memoized) (value1, value2, value3) -> { final boolean returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(value1, value2, value3), ThrowableFunction .of(key -> testThrows(key.getLeft(), key.getMiddle(), key.getRight()))); } return returnValue; }; } } /** * Returns a composed {@link ThrowableTriPredicate} which represents this {@link ThrowableTriLongPredicate}. Thereby * the primitive input argument for this predicate is autoboxed. This method provides the possibility to use this * {@code ThrowableTriLongPredicate} with methods provided by the {@code JDK}. * * @return A composed {@code ThrowableTriPredicate} which represents this {@code ThrowableTriLongPredicate}. */ @Nonnull default ThrowableTriPredicate<Long, Long, Long, X> boxed() { return this::testThrows; } /** * Returns a composed {@link TriLongPredicate} that applies this predicate to its input and nests the thrown {@link * Throwable} from it. The {@code Throwable} is nested (wrapped) in a {@link ThrownByFunctionalInterfaceException}, * which is constructed from the thrown {@code Throwable}s message and the thrown {@code Throwable} itself. * * @return A composed {@link TriLongPredicate} that applies this predicate to its input and nests the thrown {@code * Throwable} from it. * @implNote If thrown {@code Throwable} is of type {@link Error} it is thrown as-is and thus not nested. * @see #nestWith(Function) * @see ThrownByFunctionalInterfaceException */ @Nonnull default TriLongPredicate nest() { return nestWith(throwable -> new ThrownByFunctionalInterfaceException(throwable.getMessage(), throwable)); } /** * Returns a composed {@link TriLongPredicate} that applies this predicate to its input and nests the thrown {@link * Throwable} from it using {@code mapper} operation. Thereby {@code mapper} may modify the thrown {@code * Throwable}, regarding its implementation, and returns it nested (wrapped) in a {@link RuntimeException}. * * @param mapper The operation to map the thrown {@code Throwable} to {@code RuntimeException} * @return A composed {@link TriLongPredicate} that applies this predicate to its input and nests the thrown {@code * Throwable} from it using {@code mapper} operation. * @throws NullPointerException If given argument is {@code null} * @implNote If thrown {@code Throwable} is of type {@link Error} it is thrown as-is and thus not nested. * @see #nest() */ @Nonnull default TriLongPredicate nestWith( @Nonnull final Function<? super Throwable, ? extends RuntimeException> mapper) { return recover(throwable -> { throw mapper.apply(throwable); }); } /** * Returns a composed {@link TriLongPredicate} that applies this predicate to its input and sneakily throws the * thrown {@link Throwable} from it, if it is not of type {@link RuntimeException} or {@link Error}. This means that * each throwable thrown from the returned composed predicate behaves exactly the same as an <em>unchecked</em> * throwable does. As a result, there is no need to handle the throwable of this predicate in the returned composed * predicate by either wrapping it in an <em>unchecked</em> throwable or to declare it in the {@code throws} clause, * as it would be done in a non sneaky throwing predicate. * <p> * What sneaky throwing simply does, is to fake out the compiler and thus it bypasses the principle of * <em>checked</em> throwables. On the JVM (class file) level, all throwables, checked or not, can be thrown * regardless of the {@code throws} clause of methods, which is why this works at all. * <p> * However, when using this method to get a sneaky throwing predicate variant of this throwable predicate, the * following advantages, disadvantages and limitations will apply: * <p> * If the calling-code is to handle the sneakily thrown throwable, it is required to add it to the {@code throws} * clause of the method that applies the returned composed predicate. The compiler will not force the declaration in * the {@code throws} clause anymore. * <p> * If the calling-code already handles the sneakily thrown throwable, the compiler requires it to be added to the * {@code throws} clause of the method that applies the returned composed predicate. If not added, the compiler will * error that the caught throwable is never thrown in the corresponding {@code try} block. * <p> * If the returned composed predicate is directly surrounded by a {@code try}-{@code catch} block to catch the * sneakily thrown throwable from it, the compiler will error that the caught throwable is never thrown in the * corresponding {@code try} block. * <p> * In any case, if the throwable is not added to the to the {@code throws} clause of the method that applies the * returned composed predicate, the calling-code won't be able to catch the throwable by name. It will bubble and * probably be caught in some {@code catch} statement, catching a base type such as {@code try { ... } * catch(RuntimeException e) { ... }} or {@code try { ... } catch(Exception e) { ... }}, but perhaps this is * intended. * <p> * When the called code never throws the specific throwable that it declares, it should obviously be omitted. For * example: {@code new String(byteArr, "UTF-8") throws UnsupportedEncodingException}, but {@code UTF-8} is * guaranteed by the Java specification to be always present. Here, the {@code throws} declaration is a nuisance and * any solution to silence it with minimal boilerplate is welcome. The throwable should therefore be omitted in the * {@code throws} clause of the method that applies the returned composed predicate. * <p> * With all that mentioned, the following example will demonstrate this methods correct use: * <pre>{@code * // when called with illegal value ClassNotFoundException is thrown * public Class<?> sneakyThrowingFunctionalInterface(final String className) throws ClassNotFoundException { * return ThrowableFunction.of(Class::forName) // create the correct throwable functional interface * .sneakyThrow() // create a non-throwable variant which is able to sneaky throw (this method) * .apply(className); // apply non-throwable variant -> may sneaky throw a throwable * } * * // call the the method which surround the sneaky throwing functional interface * public void callingMethod() { * try { * final Class<?> clazz = sneakyThrowingFunctionalInterface("some illegal class name"); * // ... do something with clazz ... * } catch(ClassNotFoundException e) { * // ... do something with e ... * } * } * }</pre> * In conclusion, this somewhat contentious ability should be used carefully, of course, with the advantages, * disadvantages and limitations described above kept in mind. * * @return A composed {@link TriLongPredicate} that applies this predicate to its input and sneakily throws the * thrown {@link Throwable} from it, unless it is of type {@link RuntimeException} or {@link Error}. * @implNote If thrown {@link Throwable} is of type {@link RuntimeException} or {@link Error}, it is thrown as-is * and thus not sneakily thrown. */ @Nonnull default TriLongPredicate sneakyThrow() { return (value1, value2, value3) -> { try { return this.testThrows(value1, value2, value3); } catch (RuntimeException | Error e) { throw e; } catch (Throwable throwable) { throw ThrowableUtils.sneakyThrow(throwable); } }; } /** * Returns a composed {@link TriLongPredicate} that first applies this predicate to its input, and then applies the * {@code recover} operation if a {@link Throwable} is thrown from this one. The {@code recover} operation is * represented by a curried operation which is called with throwable information and same arguments of this * predicate. * * @param recover The operation to apply if this predicate throws a {@code Throwable} * @return A composed {@link TriLongPredicate} that first applies this predicate to its input, and then applies the * {@code recover} operation if a {@code Throwable} is thrown from this one. * @throws NullPointerException If given argument or the returned enclosing predicate is {@code null} * @implSpec The implementation checks that the returned enclosing predicate from {@code recover} operation is not * {@code null}. If it is, then a {@link NullPointerException} with appropriate message is thrown. * @implNote If thrown {@code Throwable} is of type {@link Error}, it is thrown as-is and thus not passed to {@code * recover} operation. */ @Nonnull default TriLongPredicate recover( @Nonnull final Function<? super Throwable, ? extends TriLongPredicate> recover) { Objects.requireNonNull(recover); return (value1, value2, value3) -> { try { return this.testThrows(value1, value2, value3); } catch (Error e) { throw e; } catch (Throwable throwable) { final TriLongPredicate predicate = recover.apply(throwable); Objects.requireNonNull(predicate, () -> "recover returned null for " + throwable.getClass() + ": " + throwable.getMessage()); return predicate.test(value1, value2, value3); } }; } }