Implement predicate chaining based on different types

Question

I'm searching for an ability to chain Predicates and test them together.

Thoughts

We have conditions for predicates(or else) :

 1. P<T>, P<R>, P<S>
 2. P<T>.and(P<T>) => P<T> as result P<T>.test(t1, t2)
 3. P<T>.and(P<R>) => P<T,R> as result P<T,R>.test(t,r)
 4. P<T>.and(P<R>.or(P<S>)) => P<T,R,S> as result P<T,R,S>.test(t,r,s)

I have the models

class User {
            private String name;
            private boolean isActive;
            public User(String name, boolean isActive) {
                this.name = name;
                this.isActive = isActive;
            }
            //getters only...
        }

Order

public class Order {
        private long createdAt;
        private User user;
        private Manager manager;
        private boolean isApproved;
    
        public Order(User user, Manager manager, long createdAt, boolean isApproved) {
            this.user = user;
            this.manager = manager;
            this.createdAt = createdAt;
            this.isApproved = isApproved;
        }
        // getters only ...
    }

Manager

class Manager {
        private ManagerCompetency competency;
        private String name;
        public Manager(String name, ManagerCompetency competency) {
            this.name = name;
            this.competency = competency;
        }
        //getters only...
    }

As result, I need something like for short OrderAcceptanceSpecification OAS

Boolean result = OAS.isUserCanCreateOrder()
                 .and(OAS.isOrderApproved())
                 .and(OAS.isOrderExpiredAfter(3600)).negate()
                 .and(
                     OAS.isOrderApproverCompetentAs(Competencies.HIGH)
                     .or(OAS.isOrderApproverCompetentAs(Competencies.MIDDLE)
                 ).test(Order, Manager, User)

Any suggestions/improvements are welcome.

I have found a similar solution

public class ChainedPredicate<T> {

    private T t;

    private Predicate<T> predicate;

    public ChainedPredicate(T t, Predicate<T> predicate) {
        Objects.requireNonNull(t);
        Objects.requireNonNull(predicate);
        this.t = t;
        this.predicate = predicate;
    }

    private ChainedPredicate(Predicate<T> predicate) {
        Objects.requireNonNull(predicate);
        this.predicate = predicate;
    }

    public Predicate<T> toPredicate() {
        return t -> test();
    }

    public boolean test() {
        return predicate.test(t);
    }

    public ChainedPredicate<T> and(ChainedPredicate<?> other) {
        Objects.requireNonNull(other);
        return new ChainedPredicate<T>(t -> test() && other.test());
    }

    public ChainedPredicate<T> or(ChainedPredicate<?> other) {
        Objects.requireNonNull(other);
        return new ChainedPredicate<T>(t -> test() || other.test());
    }

    public ChainedPredicate<T> negate() {
        return new ChainedPredicate<T>(toPredicate().negate());
    }
}

Perform testing

public class TestChainedPredicate {

    public static void main(String[] args) {

        Predicate<Boolean> tp1 = x -> 1 >0;
        Predicate<String> fp1 = x -> 1 <0;
        Predicate<Integer> fp2 = x -> 1 <0;

        ChainedPredicate<Boolean> p = new ChainedPredicate<Boolean>(true, tp1); //true
        ChainedPredicate<String> p1 = new ChainedPredicate<String>("123", fp1); // false
        ChainedPredicate<Integer> p2 = new ChainedPredicate<Integer>(100, fp2); // false

        boolean result = p.and(p1.or(p2)).test(); // false
        System.out.println(result + " expected : " + false + " : " + ((result==false) ? "OK" : "ERROR") );

        result = p.or(p1.or(p2)).test();
        System.out.println(result + " expected : " + true + " : " + ((result==true) ? "OK" : "ERROR"));

        result = p1.or(p.and(p2)).test();
        System.out.println(result + " expected : " + false + " : " + ((result==false) ? "OK" : "ERROR"));

        result = p1.or(p.or(p2)).test(); // false
        System.out.println(result + " expected : " + true + " : " + ((result==true) ? "OK" : "ERROR"));

        result = p1.or(p.or(p2)).negate().test(); // false
        System.out.println(result + " expected : " + false + " : " + ((result==false) ? "OK" : "ERROR"));

    }

}

Answer 1

It looks like you are over-complicating things. Your OrderAcceptanceSpecification could just contain two methods:

 static class OrderAcceptanceSpecification {

    static Predicate<Order> isOrderApproved() {
        return Order::isApproved;
    }

    static Predicate<Order> isOrderExpiredAfter(int seconds) {
        return o -> System.nanoTime() - o.createdAt() > seconds;
    }
}

Assuming you have a class that looks like this:

 class Order {
    private final Manager manager;
    private final User user;
    ....

The Predicate that you need could be written like this:

Predicate<Order> predicate = OrderAcceptanceSpecification.isOrderApproved()
            .and(x -> x.getUser().isActive())
            .and(OrderAcceptanceSpecification.isOrderExpiredAfter(3600).negate())
            .and(x -> x.getManager().getCompetency().equals(ManagerCompetency.HIGH)
                    || x.getManager().getCompetency().equals(ManagerCompetency.MIDDLE));

I find the || cleaner than casting the lambda expression to a Predicate and chaining or.

Answer 2

As the method signatures suggest, you can only chain predicates of the same type. There is no workaround for this, unless your classes share the superclass.

Predicate<T> and(Predicate<? super T> other)

Predicate<T> or(Predicate<? super T> other)