Example usage for java.util.function IntPredicate test

List of usage examples for java.util.function IntPredicate test

Introduction

In this page you can find the example usage for java.util.function IntPredicate test.

Prototype

boolean test(int value);

Source Link

Document

Evaluates this predicate on the given argument.

Usage

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiIntToIntFunction.java

/**
 * Returns a composed {@link ObjBiIntPredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code boolean}.
 *
 * @param after The predicate to apply after this function is applied
 * @return A composed {@code ObjBiIntPredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate 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}./*  w  w  w .j  a  v  a2  s  .co  m*/
 */
@Nonnull
default ObjBiIntPredicate<T> andThenToBoolean(@Nonnull final IntPredicate after) {
    Objects.requireNonNull(after);
    return (t, value1, value2) -> after.test(applyAsInt(t, value1, value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiBooleanToIntFunction.java

/**
 * Returns a composed {@link IntBinaryOperator2} that first applies the {@code before} predicates to
 * its input, and then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code int} input,
 * before this primitive function is executed.
 *
 * @param before1 The first predicate to apply before this function is applied
 * @param before2 The second predicate to apply before this function is applied
 * @return A composed {@code IntBinaryOperator2} that first applies the {@code before} predicates to its input, and
 * then applies this function 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}./*ww  w  .j a  va 2s.  c  o m*/
 */
@Nonnull
default IntBinaryOperator2 composeFromInt(@Nonnull final IntPredicate before1,
        @Nonnull final IntPredicate before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> applyAsInt(before1.test(value1), before2.test(value2));
}

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiByteToIntFunction.java

/**
 * Returns a composed {@link ObjBiBytePredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code boolean}.
 *
 * @param after The predicate to apply after this function is applied
 * @return A composed {@code ObjBiBytePredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate 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}./*from  w  w  w .j  ava  2s .c  om*/
 */
@Nonnull
default ObjBiBytePredicate<T> andThenToBoolean(@Nonnull final IntPredicate after) {
    Objects.requireNonNull(after);
    return (t, value1, value2) -> after.test(applyAsInt(t, value1, value2));
}

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiCharToIntFunction.java

/**
 * Returns a composed {@link ObjBiCharPredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code boolean}.
 *
 * @param after The predicate to apply after this function is applied
 * @return A composed {@code ObjBiCharPredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate 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}./*from  w ww  .  j  ava 2 s.  c  o  m*/
 */
@Nonnull
default ObjBiCharPredicate<T> andThenToBoolean(@Nonnull final IntPredicate after) {
    Objects.requireNonNull(after);
    return (t, value1, value2) -> after.test(applyAsInt(t, value1, value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiBooleanToByteFunction.java

/**
 * Returns a composed {@link BiIntToByteFunction} that first applies the {@code before} predicates to
 * its input, and then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code int} input,
 * before this primitive function is executed.
 *
 * @param before1 The first predicate to apply before this function is applied
 * @param before2 The second predicate to apply before this function is applied
 * @return A composed {@code BiIntToByteFunction} that first applies the {@code before} predicates to its input, and
 * then applies this function 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}.//from  ww w . j  ava2 s .c o  m
 */
@Nonnull
default BiIntToByteFunction composeFromInt(@Nonnull final IntPredicate before1,
        @Nonnull final IntPredicate before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> applyAsByte(before1.test(value1), before2.test(value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiBooleanToCharFunction.java

/**
 * Returns a composed {@link BiIntToCharFunction} that first applies the {@code before} predicates to
 * its input, and then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code int} input,
 * before this primitive function is executed.
 *
 * @param before1 The first predicate to apply before this function is applied
 * @param before2 The second predicate to apply before this function is applied
 * @return A composed {@code BiIntToCharFunction} that first applies the {@code before} predicates to its input, and
 * then applies this function 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}.//from  w w  w .ja va 2 s  . c  o m
 */
@Nonnull
default BiIntToCharFunction composeFromInt(@Nonnull final IntPredicate before1,
        @Nonnull final IntPredicate before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> applyAsChar(before1.test(value1), before2.test(value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiBooleanToLongFunction.java

/**
 * Returns a composed {@link BiIntToLongFunction} that first applies the {@code before} predicates to
 * its input, and then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code int} input,
 * before this primitive function is executed.
 *
 * @param before1 The first predicate to apply before this function is applied
 * @param before2 The second predicate to apply before this function is applied
 * @return A composed {@code BiIntToLongFunction} that first applies the {@code before} predicates to its input, and
 * then applies this function 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}./*from  www.ja v  a2 s . c  o  m*/
 */
@Nonnull
default BiIntToLongFunction composeFromInt(@Nonnull final IntPredicate before1,
        @Nonnull final IntPredicate before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> applyAsLong(before1.test(value1), before2.test(value2));
}

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiLongToIntFunction.java

/**
 * Returns a composed {@link ObjBiLongPredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code boolean}.
 *
 * @param after The predicate to apply after this function is applied
 * @return A composed {@code ObjBiLongPredicate} that first applies this function to its input, and then applies the
 * {@code after} predicate 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}.//from w w  w  .  jav a 2 s.c  o m
 */
@Nonnull
default ObjBiLongPredicate<T> andThenToBoolean(@Nonnull final IntPredicate after) {
    Objects.requireNonNull(after);
    return (t, value1, value2) -> after.test(applyAsInt(t, value1, value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiBooleanToFloatFunction.java

/**
 * Returns a composed {@link BiIntToFloatFunction} that first applies the {@code before} predicates to
 * its input, and then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code int} input,
 * before this primitive function is executed.
 *
 * @param before1 The first predicate to apply before this function is applied
 * @param before2 The second predicate to apply before this function is applied
 * @return A composed {@code BiIntToFloatFunction} that first applies the {@code before} predicates to its input,
 * and then applies this function 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}.//ww w  .  j av a2 s . c o m
 */
@Nonnull
default BiIntToFloatFunction composeFromInt(@Nonnull final IntPredicate before1,
        @Nonnull final IntPredicate before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> applyAsFloat(before1.test(value1), before2.test(value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiBooleanToShortFunction.java

/**
 * Returns a composed {@link BiIntToShortFunction} that first applies the {@code before} predicates to
 * its input, and then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code int} input,
 * before this primitive function is executed.
 *
 * @param before1 The first predicate to apply before this function is applied
 * @param before2 The second predicate to apply before this function is applied
 * @return A composed {@code BiIntToShortFunction} that first applies the {@code before} predicates to its input,
 * and then applies this function 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}./*  ww  w  .  j  a v a  2 s  .c o m*/
 */
@Nonnull
default BiIntToShortFunction composeFromInt(@Nonnull final IntPredicate before1,
        @Nonnull final IntPredicate before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> applyAsShort(before1.test(value1), before2.test(value2));
}