根据不同类型实施谓词链接 [英] Implement predicate chaining based on different types

问题描述

我正在寻找将谓词链接起来并将其测试在一起的功能.

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

想法

我们有谓词(或其他条件)的条件:

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)

我有模特

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

订购

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 ...
    }

经理

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

结果，我需要类似的东西 短期OrderAcceptanceSpecification OAS

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)

欢迎任何建议/改进.

我找到了类似的解决方案

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());
    }
}

进行测试

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"));

    }

}

推荐答案

如方法签名所建议，您只能链接相同类型的谓词.除非您的类共享超类，否则没有解决方法.

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)

这篇关于根据不同类型实施谓词链接的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！