ch.maxant.rules

Class Rule

java.lang.Object

ch.maxant.rules.Rule

All Implemented Interfaces:

Comparable<Rule>

Direct Known Subclasses:

SubRule

public class Rule
extends Object
implements Comparable<Rule>

An Engine contains a list of rules. The engine can then be asked to provide the outcome of the Action associated with the best matching rule (see Engine.executeBestAction(String, Object, java.util.Collection)), or to provide a list of matching rules (see Engine.getMatchingRules(String, Object)). Each rule is "evaluated" by using the expression supplied in the constructor Rule(String, String, String, int, String). The expression must be valid expression language. During evaludation, the input object passed to the engine is mapped to the name "input", which can be used in the rules. For example, consider the following rule:

input.person1.name == "ant" && input.person1.gender == "male"

Note how the rule evaluates to "true" or "false". For any rule to be a candidate to have an associated IAction executed, it must evaluate to "true". The rule in the example above requires an input object which conforms to the bean specification, and which is composed of an object named "person1", which has attributes"name" and "gender". If an input object is supplied to the engine such that this rule evaluates to true, then it is a candidate to have its action run, either by the engine, when Engine.executeBestAction(String, Object, java.util.Collection) is called, or by the application, when Engine.getMatchingRules(String, Object) returns the rule and the application decides to run the action.

Rules belong to namespaces, so that a single engine can be used to evaluate rules from different components within an application. within a namespace, all rules must have unique names (this is checked when adding rules to an engine). The reason is that rules can be composed of SubRules and when they are composed in that manner, rules refer to subrules by their names.

A rule has a priority too. In certain cases, where the application only requires the best rule to be used, the priority helps the application decide which rule to run when there is more than one match.

The description in a rule is imply to aid in rule management.

Typically rules are customisable at runtime using some kind of administration UI. While this framework does not provide an out of the box framework, it has been designed such that the rules could be created from a persistent store. It is entirely conceivable that an application would load rules from a database and execute existing actions based on the rules. Only when a new action is required, would an application need to be upgraded and redeployed.

For more info on rules, see http://mvel.codehaus.org/Language+Guide+for+2.0.

See Also:

SubRule

Constructor Summary

Constructors

Constructor and Description
Rule(String name, String expression, String outcome, int priority, String namespace) See Rule(String, String, String, int, String, String), just without a description.
Rule(String name, String expression, String outcome, int priority, String namespace, String description)

Method Summary

Modifier and Type	Method and Description
int	compareTo(Rule r)
boolean	equals(Object obj)
String	getDescription()
String	getExpression()
String	getFullyQualifiedName()
String	getName()
String	getNamespace()
String	getOutcome()
int	getPriority()
int	hashCode()
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

Rule

public Rule(String name,
            String expression,
            String outcome,
            int priority,
            String namespace,
            String description)

Parameters:

name - The name of the rule. Should be unique within the namespace (tested when adding rules to the Engine).

expression - the rule expressed in expression language. all variables must come from the bean called "input". The rule MUST evaluate to "true" if it is to be a candidate for execution.

outcome - The name of an action to run, if this rule is the winner.

priority - The priority, used in determining which rule to run, if many evaluate true. The higher the value, the higher the priority.

namespace - A namespace, used for filtering rules. The engine is passed a regular expression which is compared to this value. Only matches are evaluated.

description - A description to help manage rules.

Rule

public Rule(String name,
            String expression,
            String outcome,
            int priority,
            String namespace)

See Rule(String, String, String, int, String, String), just without a description.

Method Detail

compareTo

public int compareTo(Rule r)

Specified by:

compareTo in interface Comparable<Rule>

getFullyQualifiedName

public String getFullyQualifiedName()

Returns:

the namespace concatenated with the name, separated by a '.'

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

toString

public String toString()

Overrides:

toString in class Object

getName

public String getName()

getExpression

public String getExpression()

getOutcome

public String getOutcome()

getPriority

public int getPriority()

getNamespace

public String getNamespace()

getDescription

public String getDescription()