package org.drools.rule;
/*
* Copyright 2005 JBoss Inc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.drools.WorkingMemory;
import org.drools.base.EnabledBoolean;
import org.drools.base.SalienceInteger;
import org.drools.io.Resource;
import org.drools.spi.AgendaGroup;
import org.drools.spi.CompiledInvoker;
import org.drools.spi.Consequence;
import org.drools.spi.Duration;
import org.drools.spi.Enabled;
import org.drools.spi.Salience;
import org.drools.spi.Tuple;
import org.drools.spi.Wireable;
/**
* A <code>Rule</code> contains a set of <code>Test</code>s and a
* <code>Consequence</code>.
* <p>
* The <code>Test</code>s describe the circumstances that representrepresent
* a match for this rule. The <code>Consequence</code> gets fired when the
* Conditions match.
*
* @author <a href="mailto:bob@eng.werken.com"> bob mcwhirter </a>
* @author <a href="mailto:simon@redhillconsulting.com.au"> Simon Harris </a>
* @author <a href="mailto:mproctor@codehaus.org"> mark proctor </a>
*/
public class Rule
implements
Externalizable,
Wireable,
Dialectable,
org.drools.definition.rule.Rule {
/**
*
*/
private static final long serialVersionUID = 400L;
/** */
// ------------------------------------------------------------
// Instance members
// ------------------------------------------------------------
/** The parent pkg */
private String pkg;
/** Name of the rule. */
private String name;
/** Parent Rule Name, optional */
private Rule parent;
/** Salience value. */
private Salience salience;
/** The Rule is dirty after patterns have been added */
private boolean dirty;
private Map declarations;
private Declaration[] declarationArray;
private GroupElement lhsRoot;
private String dialect;
private String agendaGroup;
private Map<String,String> metaAttributes;
/** Consequence. */
private Consequence consequence;
/** Truthness duration. */
private Duration duration;
/** Load order in Package */
private long loadOrder;
/** Is recursion of this rule allowed */
private boolean noLoop;
/** makes the rule's much the current focus */
private boolean autoFocus;
private String activationGroup;
private String ruleFlowGroup;
private boolean lockOnActive;
private boolean hasLogicalDependency;
/** indicates that the rule is semantically correct. */
private boolean semanticallyValid;
private Calendar dateEffective;
private Calendar dateExpires;
private Enabled enabled;
private Resource resource;
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(pkg);
out.writeObject(name);
out.writeObject(parent);
out.writeObject(salience);
out.writeBoolean(dirty);
out.writeObject(declarations);
out.writeObject(declarationArray);
out.writeObject(lhsRoot);
out.writeObject(dialect);
out.writeObject(agendaGroup);
out.writeObject(metaAttributes);
if ( this.consequence instanceof CompiledInvoker ) {
out.writeObject( null );
} else {
out.writeObject(this.consequence);
}
out.writeObject(duration);
out.writeLong(loadOrder);
out.writeBoolean(noLoop);
out.writeBoolean(autoFocus);
out.writeObject(activationGroup);
out.writeObject(ruleFlowGroup);
out.writeBoolean(lockOnActive);
out.writeBoolean(hasLogicalDependency);
out.writeBoolean(semanticallyValid);
out.writeObject(dateEffective);
out.writeObject(dateExpires);
out.writeObject(enabled);
out.writeObject( resource );
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
pkg = (String)in.readObject();
name = (String)in.readObject();
parent = (Rule)in.readObject();
salience = (Salience)in.readObject();
dirty = in.readBoolean();
declarations = (Map)in.readObject();
declarationArray = (Declaration[])in.readObject();
lhsRoot = (GroupElement)in.readObject();
dialect = (String)in.readObject();
agendaGroup = (String)in.readObject();
metaAttributes = (Map<String,String>)in.readObject();
consequence = (Consequence)in.readObject();
duration = (Duration)in.readObject();
loadOrder = in.readLong();
noLoop = in.readBoolean();
autoFocus = in.readBoolean();
activationGroup = (String) in.readObject();
ruleFlowGroup = (String) in.readObject();
lockOnActive = in.readBoolean();
hasLogicalDependency = in.readBoolean();
semanticallyValid = in.readBoolean();
dateEffective = (Calendar) in.readObject();
dateExpires = (Calendar) in.readObject();
enabled = (Enabled) in.readObject();
resource = ( Resource ) in.readObject();
}
// ------------------------------------------------------------
// Constructors
// ------------------------------------------------------------
public Rule() {
}
/**
* Construct a
* <code>Rule<code> with the given name for the specified pkg parent
*
* @param name
* The name of this rule.
*/
public Rule(final String name,
final String pkg,
final String agendaGroup) {
this.name = name;
this.pkg = pkg;
this.agendaGroup = agendaGroup;
this.lhsRoot = GroupElementFactory.newAndInstance();
this.semanticallyValid = true;
this.enabled = EnabledBoolean.ENABLED_TRUE;
this.salience = SalienceInteger.DEFAULT_SALIENCE;
this.metaAttributes = new HashMap<String,String>();
}
/**
* Construct a
* <code>Rule<code> with the given name for the specified pkg parent
*
* @param name
* The name of this rule.
*/
public Rule(final String name,
final String agendaGroup) {
this( name,
null,
agendaGroup );
}
public Rule(final String name) {
this( name,
null,
AgendaGroup.MAIN );
}
public Resource getResource() {
return resource;
}
public void setResource(Resource resource) {
this.resource = resource;
}
public String getDialect() {
return dialect;
}
public void setDialect(String dialect) {
this.dialect = dialect;
}
/**
* Set the truthness duration. This causes a delay before the firing of the
* <code>Consequence</code> if the rule is still true at the end of the
* duration.
*
* <p>
* This is merely a convenience method for calling
* {@link #setDuration(Duration)}with a <code>FixedDuration</code>.
* </p>
*
* @see #setDuration(Duration)
* @see FixedDuration
*
* @param seconds -
* The number of seconds the rule must hold true in order to
* fire.
*/
public void setDuration(final long ms) {
this.duration = new FixedDuration( ms );
}
/**
* Set the truthness duration object. This causes a delay before the firing
* of the <code>Consequence</code> if the rule is still true at the end of
* the duration.
*
* @param duration
* The truth duration object.
*/
public void setDuration(final Duration duration) {
this.duration = duration;
}
/**
* Retrieve the truthness duration object.
*
* @return The truthness duration object.
*/
public Duration getDuration() {
return this.duration;
}
/**
* Determine if this rule is internally consistent and valid.
* This will include checks to make sure the rules semantic components (actions and predicates)
* are valid.
*
* No exception is thrown.
* <p>
* A <code>Rule</code> must include at least one parameter declaration and
* one condition.
* </p>
*
* @return <code>true</code> if this rule is valid, else
* <code>false</code>.
*/
public boolean isValid() {
//if ( this.patterns.size() == 0 ) {
// return false;
//}
if ( this.consequence == null || !isSemanticallyValid() ) {
return false;
}
return true;
}
public String getPackage() {
return this.pkg;
}
public void setPackage(String pkg) {
this.pkg = pkg;
}
public String getPackageName() {
return this.pkg;
}
/**
* Retrieve the name of this rule.
*
* @return The name of this rule.
*/
public String getName() {
return this.name;
}
/**
* Retrieve the <code>Rule</code> salience.
*
* @return The salience.
*/
public Salience getSalience() {
return this.salience;
}
/**
* Set the <code>Rule<code> salience.
*
* @param salience The salience.
*/
public void setSalience(final Salience salience) {
this.salience = salience;
}
public String getAgendaGroup() {
if ( this.agendaGroup == null || this.agendaGroup.equals( "" ) ) {
return AgendaGroup.MAIN;
}
return this.agendaGroup;
}
public void setAgendaGroup(final String agendaGroup) {
this.agendaGroup = agendaGroup;
}
public boolean isNoLoop() {
return this.noLoop;
}
/**
* This returns true is the rule is effective.
* If the rule is not effective, it cannot activate.
*
* This uses the dateEffective, dateExpires and enabled flag to decide this.
*/
public boolean isEffective(TimeMachine tm, Tuple tuple, WorkingMemory workingMemory) {
if ( !this.enabled.getValue( tuple, this, workingMemory ) ) {
return false;
}
if ( this.dateEffective == null && this.dateExpires == null ) {
return true;
} else {
final Calendar now = tm.getNow();
if ( this.dateEffective != null && this.dateExpires != null ) {
return (now.after( this.dateEffective ) && now.before( this.dateExpires ));
} else if ( this.dateEffective != null ) {
return (now.after( this.dateEffective ));
} else {
return (now.before( this.dateExpires ));
}
}
}
public void setNoLoop(final boolean noLoop) {
this.noLoop = noLoop;
}
public boolean getAutoFocus() {
return this.autoFocus;
}
public void setAutoFocus(final boolean autoFocus) {
this.autoFocus = autoFocus;
}
public String getActivationGroup() {
return this.activationGroup;
}
public void setActivationGroup(final String activationGroup) {
this.activationGroup = activationGroup;
}
public String getRuleFlowGroup() {
return this.ruleFlowGroup;
}
public void setRuleFlowGroup(final String ruleFlowGroup) {
this.ruleFlowGroup = ruleFlowGroup;
}
/**
* Retrieve a parameter <code>Declaration</code> by identifier.
*
* @param identifier
* The identifier.
*
* @return The declaration or <code>null</code> if no declaration matches
* the <code>identifier</code>.
*/
public Declaration getDeclaration(final String identifier) {
if ( this.dirty || (this.declarations == null) ) {
this.declarations = this.lhsRoot.getOuterDeclarations();
this.declarationArray = (Declaration[]) this.declarations.values().toArray( new Declaration[this.declarations.values().size()] );
this.dirty = false;
}
return (Declaration) this.declarations.get( identifier );
}
/**
* This field is updated at runtime, when the first logical assertion is done. I'm currently not too happy about having this determine at runtime
* but its currently easier than trying to do this at compile time, although eventually this should be changed
* @return
*/
public boolean hasLogicalDependency() {
return this.hasLogicalDependency;
}
public void setHasLogicalDependency(boolean hasLogicalDependency) {
this.hasLogicalDependency = hasLogicalDependency;
}
public boolean isLockOnActive() {
return this.lockOnActive;
}
public void setLockOnActive(final boolean lockOnActive) {
this.lockOnActive = lockOnActive;
}
/**
* Retrieve the set of all <i>root fact object </i> parameter
* <code>Declarations</code>.
*
* @return The Set of <code>Declarations</code> in order which specify the
* <i>root fact objects</i>.
*/
public Declaration[] getDeclarations() {
if ( this.dirty || (this.declarationArray == null) ) {
this.declarations = this.lhsRoot.getOuterDeclarations();
this.declarationArray = (Declaration[]) this.declarations.values().toArray( new Declaration[this.declarations.values().size()] );
this.dirty = false;
}
return this.declarationArray;
}
/**
* Add a pattern to the rule. All patterns are searched for bindings which are then added to the rule
* as declarations
*
* @param condition
* The <code>Test</code> to add.
* @throws InvalidRuleException
*/
public void addPattern(final RuleConditionElement element) {
this.dirty = true;
this.lhsRoot.addChild( element );
}
/**
* Retrieve the <code>List</code> of <code>Conditions</code> for this
* rule.
*
* @return The <code>List</code> of <code>Conditions</code>.
*/
public GroupElement getLhs() {
return this.lhsRoot;
}
public void setLhs(final GroupElement lhsRoot) {
this.dirty = true;
this.lhsRoot = lhsRoot;
}
private GroupElement getExtendedLhs(Rule rule, GroupElement fromChild){
//combine rules LHS with Parent "Extends"
final GroupElement lhs = (GroupElement) rule.lhsRoot.clone();
//use the children passed from prior child rules, and combine with current LHS (at the end)
if(null != fromChild){
//Have GroupElement from a child rule, so combine it
lhs.getChildren().addAll(fromChild.getChildren());
}
//move recursively up the tree
if(rule.parent != null){
return getExtendedLhs(rule.parent, lhs);
}
//at the top of the tree, return combined LHS
//TODO Merge LHS for performace
return lhs;
}
/**
* Uses the LogicTransformer to process the Rule patters - if no ORs are
* used this will return an array of a single AND element. If there are Ors
* it will return an And element for each possible logic branch. The
* processing uses as a clone of the Rule's patterns, so they are not
* changed.
*
* @return
* @throws InvalidPatternException
*/
public GroupElement[] getTransformedLhs() throws InvalidPatternException {
//Moved to getExtendedLhs --final GroupElement cloned = (GroupElement) this.lhsRoot.clone();
return LogicTransformer.getInstance().transform( getExtendedLhs(this, null) );
}
public int getSpecifity() {
return getSpecifity( this.lhsRoot );
}
private int getSpecifity(final GroupElement ce) {
int specificity = 0;
for ( final Iterator it = ce.getChildren().iterator(); it.hasNext(); ) {
final Object object = it.next();
if ( object instanceof Pattern ) {
specificity += getSpecifity( (Pattern) object );
} else if ( object instanceof GroupElement ) {
specificity += getSpecifity( (GroupElement) object );
}
}
return specificity;
}
private int getSpecifity(final Pattern pattern) {
int specificity = 0;
for ( final Iterator it = pattern.getConstraints().iterator(); it.hasNext(); ) {
if ( !(it.next() instanceof Declaration) ) {
specificity++;
}
}
return specificity;
}
public void wire(Object object) {
if ( object instanceof Salience ) {
setSalience( (Salience) object );
} else if( object instanceof Enabled ) {
setEnabled(( Enabled) object);
} else {
setConsequence( (Consequence) object );
}
}
/**
* Set the <code>Consequence</code> that is associated with the successful
* match of this rule.
*
* @param consequence
* The <code>Consequence</code> to attach to this
* <code>Rule</code>.
*/
public void setConsequence(final Consequence consequence) {
this.consequence = consequence;
}
/**
* Retrieve the <code>Consequence</code> associated with this
* <code>Rule</code>.
*
* @return The <code>Consequence</code>.
*/
public Consequence getConsequence() {
return this.consequence;
}
public long getLoadOrder() {
return this.loadOrder;
}
public void setLoadOrder(final long loadOrder) {
this.loadOrder = loadOrder;
}
public String toString() {
return "[Rule name=" + this.name + ", agendaGroup=" + this.agendaGroup + ", salience=" + this.salience + ", no-loop=" + this.noLoop + "]";
}
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = PRIME * result + ((name == null) ? 0 : name.hashCode());
result = PRIME * result + ((pkg == null) ? 0 : pkg.hashCode());
return result;
}
public boolean equals(Object obj) {
if ( this == obj ) return true;
if ( obj == null || getClass() != obj.getClass() ) return false;
final Rule other = (Rule) obj;
if ( name == null ) {
if ( other.name != null ) return false;
} else if ( !name.equals( other.name ) ) return false;
if ( pkg == null ) {
if ( other.pkg != null ) return false;
} else if ( !pkg.equals( other.pkg ) ) return false;
return true;
}
public void setSemanticallyValid(final boolean valid) {
this.semanticallyValid = valid;
}
/**
* This will return if the semantic actions or predicates in the rules
* are valid.
* This is provided so that lists of rules can be provided even if their semantic actions
* do not "compile" etc.
*/
public boolean isSemanticallyValid() {
return this.semanticallyValid;
}
/**
* Sets the date from which this rule takes effect (can include time to the millisecond).
* @param effectiveDate
*/
public void setDateEffective(final Calendar effectiveDate) {
this.dateEffective = effectiveDate;
}
/**
* Sets the date after which the rule will no longer apply (can include time to the millisecond).
* @param expiresDate
*/
public void setDateExpires(final Calendar expiresDate) {
this.dateExpires = expiresDate;
}
public Calendar getDateEffective() {
return this.dateEffective;
}
public Calendar getDateExpires() {
return this.dateExpires;
}
/**
* A rule is enabled by default. This can explicitly disable it in which case it will never activate.
*/
public void setEnabled(final Enabled b) {
this.enabled = b;
}
public boolean isEnabled( Tuple tuple, WorkingMemory workingMemory ) {
return this.enabled.getValue( tuple, this, workingMemory );
}
public void setMetaAttributes(Map<String,String> metaAttributes) {
this.metaAttributes = metaAttributes;
}
public Map<String,String> getMetaAttributes() {
return metaAttributes;
}
public String getMetaAttribute(final String identifier) {
return (String) this.metaAttributes.get( identifier );
}
public void setParent(Rule parent) {
this.parent = parent;
}
public Rule getParent() {
return parent;
}
}