logicfactorysupport.java

来自「Mandarax是一个规则引擎的纯Java实现。它支持多类型的事实和基于反映的规」· Java 代码 · 共 879 行 · 第 1/3 页

     * @param conclusion the concusion of the rule
     * @deprecated use Prerequisite instead of Fact to build rules
     */
    public Rule rule(Fact prerequisite, Fact conclusion) {
        Vector body = new Vector ();
        body.add (fact2prereq(prerequisite));
        return lfactory.createRule (body, conclusion);
    }

    /**
     * Create a rule with two prerequisites.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param conclusion the concusion of the rule
     * @deprecated use Prerequisite instead of Fact to build rules
     */
    public Rule rule(Fact prerequisite1, Fact prerequisite2,Fact conclusion) {
        Vector body = new Vector ();
        body.add (fact2prereq(prerequisite1));
        body.add (fact2prereq(prerequisite2));
        return lfactory.createRule (body, conclusion);
    }

    /**
     * Create a rule with three prerequisites.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param prerequisite3 a prerequisite
     * @param conclusion the concusion of the rule
     * @deprecated use Prerequisite instead of Fact to build rules
     */
    public Rule rule(Fact prerequisite1, Fact prerequisite2,Fact prerequisite3, Fact conclusion) {
        Vector body = new Vector ();
        body.add (fact2prereq(prerequisite1));
        body.add (fact2prereq(prerequisite2));
        body.add (fact2prereq(prerequisite3));
        return lfactory.createRule (body, conclusion);
    }

    /**
     * Create a rule with four prerequisites.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param prerequisite3 a prerequisite
     * @param prerequisite4 a prerequisite
     * @param conclusion the concusion of the rule
     * @deprecated use Prerequisite instead of Fact to build rules
     */
    public Rule rule(Fact prerequisite1, Fact prerequisite2,Fact prerequisite3, Fact prerequisite4,Fact conclusion) {
        Vector body = new Vector ();
        body.add (fact2prereq(prerequisite1));
        body.add (fact2prereq(prerequisite2));
        body.add (fact2prereq(prerequisite3));
        body.add (fact2prereq(prerequisite4));
        return lfactory.createRule (body, conclusion);
    }


    /**
     * Create a rule with two prerequisites.
     * The prerequisites are connected by OR.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param conclusion the concusion of the rule
     */
    public Rule orRule(Prerequisite prerequisite1, Prerequisite prerequisite2,Fact conclusion) {
        Vector body = new Vector ();
        body.add (prerequisite1);
        body.add (prerequisite2);
        return lfactory.createRule (body, conclusion, true);
    }

    /**
     * Create a rule with three prerequisites.
     * The prerequisites are connected by OR.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param prerequisite3 a prerequisite
     * @param conclusion the concusion of the rule
     */
    public Rule orRule(Prerequisite prerequisite1, Prerequisite prerequisite2,Prerequisite prerequisite3, Fact conclusion) {
        Vector body = new Vector ();
        body.add (prerequisite1);
        body.add (prerequisite2);
        body.add (prerequisite3);
        return lfactory.createRule (body, conclusion, true);
    }

    /**
     * Create a rule with four prerequisites.
     * The prerequisites are connected by OR.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param prerequisite3 a prerequisite
     * @param prerequisite4 a prerequisite
     * @param conclusion the concusion of the rule
     */
    public Rule orRule(Prerequisite prerequisite1, Prerequisite prerequisite2,Prerequisite prerequisite3, Prerequisite prerequisite4,Fact conclusion) {
        Vector body = new Vector ();
        body.add (prerequisite1);
        body.add (prerequisite2);
        body.add (prerequisite3);
        body.add (prerequisite4);
        return lfactory.createRule (body, conclusion, true);
    }

    /**
     * Create a rule with one prerequisite.
     * @return the rule created
     * @param prerequisite a prerequisite
     * @param conclusion the concusion of the rule
     */
    public Rule rule(Prerequisite prerequisite, Fact conclusion) {
        Vector body = new Vector ();
        body.add (prerequisite);
        return lfactory.createRule (body, conclusion);
    }

    /**
     * Create a rule with two prerequisites.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param conclusion the concusion of the rule
     */
    public Rule rule(Prerequisite prerequisite1, Prerequisite prerequisite2,Fact conclusion) {
        Vector body = new Vector ();
        body.add (prerequisite1);
        body.add (prerequisite2);
        return lfactory.createRule (body, conclusion);
    }

    /**
     * Create a rule with three prerequisites.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param prerequisite3 a prerequisite
     * @param conclusion the concusion of the rule
     */
    public Rule rule(Prerequisite prerequisite1, Prerequisite prerequisite2,Prerequisite prerequisite3, Fact conclusion) {
        Vector body = new Vector ();
        body.add (prerequisite1);
        body.add (prerequisite2);
        body.add (prerequisite3);
        return lfactory.createRule (body, conclusion);
    }

    /**
     * Create a rule with four prerequisites.
     * @return the rule created
     * @param prerequisite1 a prerequisite
     * @param prerequisite2 a prerequisite
     * @param prerequisite3 a prerequisite
     * @param prerequisite4 a prerequisite
     * @param conclusion the concusion of the rule
     */
    public Rule rule(Prerequisite prerequisite1, Prerequisite prerequisite2,Prerequisite prerequisite3, Prerequisite prerequisite4,Fact conclusion) {
        Vector body = new Vector ();
        body.add (prerequisite1);
        body.add (prerequisite2);
        body.add (prerequisite3);
        body.add (prerequisite4);
        return lfactory.createRule (body, conclusion);
    }
    
    
    /**
     * Convenient method to interprete objects as terms.
     * The following rules apply:
     * <ol>
     * <li> if the object is a term, keep it as it is
     * <li> if the object is an instance of clazz, create a constant term wrapping the object
     * <li> if the object is a string (an the previous does not apply), create a variable using the object as a name
     * <li> otherwise throw an illegal argument exception;
     * </ol>
     * @return a term
     * @param obj the object to be interpreted as a term
     * @param clazz the type of the term
     */
    private Term toTerm(Object obj, Class clazz) {
        if(obj == null) {
            throw new IllegalArgumentException (
                "Cannot build term from null");
        }

        if(obj instanceof Term) {
            return(Term) obj;
        }
		// remark: this was a bug in 1.6 : if (clazz==obj.getClass())
        if(clazz.isAssignableFrom(obj.getClass())) {
            return lfactory.createConstantTerm (obj);
        }

        if(obj instanceof String) {
            return lfactory.createVariableTerm ((String) obj, clazz);
        }

        throw new IllegalArgumentException ("Cannot build term from " + obj);
    }

    /**
     * Convenient method to create a variable.
     * @return a term
     * @param name a var name
     * @param clazz a type
     */
    public Term variable(String name, Class clazz) {
        return lfactory.createVariableTerm (name, clazz);
    }

    /**
     * Convenient method to create a string type variable.
     * @return a term
     * @param name a var name
     */
    public Term variable(String name) {
        return variable (name, String.class);
    }
    
    /**
     * Create a query with one fact.
     * @return the query created
     * @param fact a fact
     * @param name the name of the query
     */
    public Query query(Fact fact,String name) {
    	Fact[] facts = {fact};
    	return query(facts,name);
    }
    
    /**
     * Create a query with two facts.
     * @return the query created
     * @param fact1 a fact
     * @param fact2 a fact
     * @param name the name of the query
     */
    public Query query(Fact fact1,Fact fact2,String name) {
    	Fact[] facts = {fact1,fact2};
    	return query(facts,name);
    }
    
    /**
     * Create a query with three facts.
     * @return the query created
     * @param fact1 a fact
     * @param fact2 a fact
     * @param fact3 a fact
     * @param name the name of the query
     */
    public Query query(Fact fact1,Fact fact2,Fact fact3,String name) {
    	Fact[] facts = {fact1,fact2,fact3};
    	return query(facts,name);
    }
    
    /**
     * Create a query with N facts.
     * @return the query created
     * @param fact1 a fact
     * @param fact2 a fact
     * @param name the name of the query
     */
    public Query query(Fact[] facts,String name) {
    	return lfactory.createQuery(facts,name);
    }            
    
    /** 
     * Convert a fact to a prerequisite.
     * @param fact a fact
     * @return a prerequisite
     */ 
    public Prerequisite fact2prereq(Fact fact) {
    	Predicate p = fact.getPredicate();
    	Term[] terms = fact.getTerms();
    	return this.prereq(p,terms);
    }
    /**
     * Create a prerequiste using the cut predicate.
     * @return a prerequisite
     */
    public Prerequisite cut() {
    	return lfactory.createCut();
    }
    
}