com.github.dakusui.valid8j_pcond.forms.Predicates Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of valid8j-pcond Show documentation
Overhead-less DbC library
The newest version!
package com.github.dakusui.valid8j_pcond.forms;

import com.github.dakusui.valid8j_pcond.core.printable.PrintablePredicateFactory;
import com.github.dakusui.valid8j_pcond.core.printable.PrintablePredicateFactory.Leaf;
import com.github.dakusui.valid8j_pcond.core.printable.PrintablePredicateFactory.ParameterizedLeafFactory;
import com.github.dakusui.valid8j_pcond.core.refl.MethodQuery;
import com.github.dakusui.valid8j_pcond.core.refl.Parameter;
import com.github.dakusui.valid8j_pcond.internals.InternalChecks;

import java.util.Collection;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

import static com.github.dakusui.valid8j_pcond.core.refl.ReflUtils.invokeMethod;
import static com.github.dakusui.valid8j_pcond.forms.Printables.function;
import static com.github.dakusui.valid8j_pcond.forms.Printables.predicate;
import static com.github.dakusui.valid8j_pcond.internals.InternalUtils.formatObject;
import static java.lang.String.format;
import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
import static java.util.Objects.requireNonNull;

/**
 * An entry point for acquiring predicate objects.
 * Predicates retrieved by methods in this class are all "printable".
 */
public class Predicates {
    private Predicates() {
    }

    public static  Predicate alwaysTrue() {
        return Leaf.ALWAYS_TRUE.instance();
    }

    public static Predicate isTrue() {
        return Leaf.IS_TRUE.instance();
    }

    public static Predicate isFalse() {
        return Leaf.IS_FALSE.instance();
    }

    public static  Predicate isNull() {
        return Leaf.IS_NULL.instance();
    }

    public static  Predicate isNotNull() {
        return Leaf.IS_NOT_NULL.instance();
    }

    public static  Predicate isEqualTo(T value) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.IS_EQUAL_TO, singletonList(value));
    }

    public static  Predicate isSameReferenceAs(T value) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.OBJECT_IS_SAME_AS, singletonList(value));
    }

    @SuppressWarnings({"unchecked", "RedundantClassCall"})
    public static  Function, Predicate> isInstanceOf() {
        return Function.class.cast(Def.IS_INSTANCE_OF$2);
    }

    public static  Predicate isInstanceOf(Class value) {
        return applyOnceExpectingPredicate(requireNonNull(value), isInstanceOf());
    }

    private static  Predicate applyOnceExpectingPredicate(T value, Function> p) {
        return predicate(() -> format("%s[%s]", p, formatObject(value)), p.apply(value));
    }

    public static > Predicate gt(T value) {
        return greaterThan(value);
    }

    public static > Predicate greaterThan(T value) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.GREATER_THAN, singletonList(value));
    }

    public static > Predicate ge(T value) {
        return greaterThanOrEqualTo(value);
    }

    public static > Predicate greaterThanOrEqualTo(T value) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.GREATER_THAN_OR_EQUAL_TO, singletonList(value));
    }

    public static > Predicate lt(T value) {
        return lessThan(value);
    }

    public static > Predicate lessThan(T value) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.LESS_THAN, singletonList(value));
    }

    public static > Predicate le(T value) {
        return lessThanOrEqualTo(value);
    }

    public static > Predicate lessThanOrEqualTo(T value) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.LESS_THAN_OR_EQUAL_TO, singletonList(value));
    }

    public static > Predicate eq(T value) {
        return equalTo(value);
    }

    public static > Predicate equalTo(T value) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.EQUAL_TO, singletonList(value));
    }

    public static Predicate matchesRegex(String regex) {
        requireNonNull(regex);
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.MATCHES_REGEX, singletonList(regex));
    }

    public static Predicate containsString(String string) {
        requireNonNull(string);
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.CONTAINS_STRING, singletonList(string));
    }

    public static Predicate startsWith(String string) {
        requireNonNull(string);
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.STARTS_WITH, singletonList(string));
    }

    public static Predicate endsWith(String string) {
        requireNonNull(string);
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.ENDS_WITH, singletonList(string));
    }

    public static Predicate equalsIgnoreCase(String string) {
        requireNonNull(string);
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.EQUALS_IGNORE_CASE, singletonList(string));
    }

    public static Predicate isEmptyString() {
        return Leaf.IS_EMPTY_STRING.instance();
    }

    public static Predicate isNullOrEmptyString() {
        return Leaf.IS_NULL_OR_EMPTY_STRING.instance();
    }

    public static  Predicate> contains(Object entry) {
        return ParameterizedLeafFactory.create(ParameterizedLeafFactory.CONTAINS, singletonList(entry));
    }

    public static Predicate isEmptyArray() {
        return Leaf.IS_EMPTY_ARRAY.instance();
    }

    public static Predicate> isEmpty() {
        return Leaf.IS_EMPTY_COLLECTION.instance();
    }

    public static  Predicate> allMatch(Predicate predicate) {
        requireNonNull(predicate);
        return PrintablePredicateFactory.allMatch(predicate);
    }

    public static  Predicate> noneMatch(Predicate predicate) {
        requireNonNull(predicate);
        return PrintablePredicateFactory.noneMatch(predicate);
    }

    public static  Predicate> anyMatch(Predicate predicate) {
        requireNonNull(predicate);
        return PrintablePredicateFactory.anyMatch(predicate);
    }

    @SafeVarargs
    public static  Predicate and(Predicate... predicates) {
        return PrintablePredicateFactory.and(asList(predicates));
    }

    @SafeVarargs
    public static  Predicate or(Predicate... predicates) {
        return PrintablePredicateFactory.or(asList(predicates));
    }

    @SafeVarargs
    public static  Predicate allOf(Predicate... predicates) {
        return PrintablePredicateFactory.allOf(asList(predicates));
    }

    @SafeVarargs
    public static  Predicate anyOf(Predicate... predicates) {
        return PrintablePredicateFactory.anyOf(asList(predicates));
    }

    public static  Predicate not(Predicate cond) {
        return PrintablePredicateFactory.not(cond);
    }

    public static  PrintablePredicateFactory.TransformingPredicate.Factory transform(String funcName, Function func) {
        return transform(function(funcName, func));
    }

    public static  PrintablePredicateFactory.TransformingPredicate.Factory transform(Function function) {
        return PrintablePredicateFactory.transform(function);
    }

    /**
     * // @formatter:off
   * Returns a {@link Predicate} created from a method specified by a {@code methodQuery}.
   * If the {@code methodQuery} matches none or more than one methods, a {@code RuntimeException} will be thrown.
   *
   * The suffix {@code p} stands for "predicate" following the custom in LISP culture
   * and it is necessary to avoid collision with {@link Functions#call(MethodQuery)} method.
   *
   * // @formatter:on
     *
     * @param methodQuery A query object that specifies a method to be invoked by the returned predicate.
     * @param          the type of the input to the returned predicate
     * @return Created predicate.
     * @see Functions#classMethod(Class, String, Object[])
     * @see Functions#instanceMethod(Object, String, Object[])
     * @see Functions#parameter()
     */
    @SuppressWarnings("ConstantConditions")
    public static  Predicate callp(MethodQuery methodQuery) {
        return predicate(
                methodQuery.describe(),
                t -> InternalChecks.ensureValue(
                        invokeMethod(methodQuery.bindActualArguments((o) -> o instanceof Parameter, o -> t)),
                        v -> v instanceof Boolean,
                        v -> format("Method matched with '%s' must return a boolean value but it gave: '%s'.", methodQuery.describe(), v)));
    }

    /**
     * // @formatter:off
   * Returns a predicate that calls a method which matches the given {@code methodName}
   * and {@code args} on the object given as input to it.
   *
   * Note that method look up is done when the predicate is applied.
   * This means this method does not throw any exception by itself and in case
   * you give wrong {@code methodName} or {@code arguments}, an exception will be
   * thrown when the returned function is applied.
   * // @formatter:on
     *
     * @param methodName The method name
     * @param arguments  Arguments passed to the method.
     * @param         The type of input to the returned predicate
     * @return A predicate that invokes the method matching the {@code methodName} and {@code args}
     * @see Functions#parameter()
     */
    public static  Predicate callp(String methodName, Object... arguments) {
        return callp(Functions.instanceMethod(Functions.parameter(), methodName, arguments));
    }

    enum Def {
        ;

        public static final Function, Predicate> IS_INSTANCE_OF$2 = function(() -> "isInstanceOf", (Class c) -> c::isInstance);
    }

}