public interface

Predicate<T>

 androidx.core.util.Predicate<T>

Gradle dependencies

compile group: 'androidx.core', name: 'core', version: '1.15.0-alpha02'

  • groupId: androidx.core
  • artifactId: core
  • version: 1.15.0-alpha02

Artifact androidx.core:core:1.15.0-alpha02 it located at Google repository (https://maven.google.com/)

Androidx artifact mapping:

androidx.core:core com.android.support:support-compat

Overview

Compat version of java.util.function.Predicate

Summary

Methods
public Predicate<java.lang.Object>and(Predicate<java.lang.Object> other)

Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another.

public static Predicate<java.lang.Object>isEqual(java.lang.Object targetRef)

Returns a predicate that tests if two arguments are equal according to equals.

public Predicate<java.lang.Object>negate()

Returns a predicate that represents the logical negation of this predicate.

public static Predicate<java.lang.Object>not(Predicate<java.lang.Object> target)

Returns a predicate that is the negation of the supplied predicate.

public Predicate<java.lang.Object>or(Predicate<java.lang.Object> other)

Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another.

public booleantest(java.lang.Object t)

Evaluates this predicate on the given argument.

Methods

public boolean test(java.lang.Object t)

Evaluates this predicate on the given argument.

Parameters:

t: the input argument

Returns:

true if the input argument matches the predicate, otherwise false

public Predicate<java.lang.Object> and(Predicate<java.lang.Object> other)

Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another. When evaluating the composed predicate, if this predicate is false, then the other predicate is not evaluated.

Any exceptions thrown during evaluation of either predicate are relayed to the caller; if evaluation of this predicate throws an exception, the other predicate will not be evaluated.

Parameters:

other: a predicate that will be logically-ANDed with this predicate

Returns:

a composed predicate that represents the short-circuiting logical AND of this predicate and the other predicate

public Predicate<java.lang.Object> negate()

Returns a predicate that represents the logical negation of this predicate.

Returns:

a predicate that represents the logical negation of this predicate

public Predicate<java.lang.Object> or(Predicate<java.lang.Object> other)

Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another. When evaluating the composed predicate, if this predicate is true, then the other predicate is not evaluated.

Any exceptions thrown during evaluation of either predicate are relayed to the caller; if evaluation of this predicate throws an exception, the other predicate will not be evaluated.

Parameters:

other: a predicate that will be logically-ORed with this predicate

Returns:

a composed predicate that represents the short-circuiting logical OR of this predicate and the other predicate

public static Predicate<java.lang.Object> isEqual(java.lang.Object targetRef)

Returns a predicate that tests if two arguments are equal according to equals.

Parameters:

targetRef: the object reference with which to compare for equality, which may be null

Returns:

a predicate that tests if two arguments are equal according to equals

public static Predicate<java.lang.Object> not(Predicate<java.lang.Object> target)

Returns a predicate that is the negation of the supplied predicate. This is accomplished by returning result of the calling target.negate().

Parameters:

target: predicate to negate

Returns:

a predicate that negates the results of the supplied predicate

Source

/*
 * Copyright 2019 The Android Open Source Project
 *
 * 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 androidx.core.util;

import android.annotation.SuppressLint;

import java.util.Objects;

/**
 * Compat version of {@link java.util.function.Predicate}
 *
 * @param <T> the type of the input to the operation
 */
@SuppressLint("UnknownNullness")
@SuppressWarnings("MissingNullability")
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    /**
     * Returns a composed predicate 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 are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ANDed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * AND of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    @SuppressLint("MissingNullability")
    default Predicate<T> and(@SuppressLint("MissingNullability") Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     * Returns a predicate that represents the logical negation of this
     * predicate.
     *
     * @return a predicate that represents the logical negation of this
     * predicate
     */
    @SuppressLint("MissingNullability")
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * Returns a composed predicate 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 are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ORed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * OR of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    @SuppressLint("MissingNullability")
    default Predicate<T> or(@SuppressLint("MissingNullability") Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * Returns a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}.
     *
     * @param <T>       the type of arguments to the predicate
     * @param targetRef the object reference with which to compare for equality,
     *                  which may be {@code null}
     * @return a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}
     */
    @SuppressLint("MissingNullability")
    static <T> Predicate<T> isEqual(@SuppressLint("MissingNullability") Object targetRef) {
        return (null == targetRef)
                ? object -> Objects.isNull(object)
                : object -> targetRef.equals(object);
    }

    /**
     * Returns a predicate that is the negation of the supplied predicate.
     * This is accomplished by returning result of the calling
     * {@code target.negate()}.
     *
     * @param <T>    the type of arguments to the specified predicate
     * @param target predicate to negate
     * @return a predicate that negates the results of the supplied
     * predicate
     * @throws NullPointerException if target is null
     */
    @SuppressWarnings("unchecked")
    @SuppressLint("MissingNullability")
    static <T> Predicate<T> not(@SuppressLint("MissingNullability") Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>) target.negate();
    }
}