//Source file: H:\\temp\\generated\\modTransf\\rules\\core\\CoreSelectRule.java
package modTransf.rules.core;
import modTransf.engine.Rule;
import modTransf.engine.Arguments;
import modTransf.engine.ParameterDescriptor;
import modTransf.engine.RuleContext;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import modTransf.engine.TransformationException;
import modTransf.engine.EngineLifeCycle;
import modTransf.engine.Member;
import modTransf.engine.EngineException;
import java.util.Collections;
/**
* A rule representing a set of rules.
* The execute() method execute the first rule whose isAllowed() return true.
* The getParameterDescriptors return descriptors matching the first registered
* rule descriptor size and direction. The other properties are skipped.
* The registered rule should have the same number of parameters, and the same
* directions.
*/
public class CoreSelectRule implements Rule, EngineLifeCycle, Member
{
/**
* The registered rules.
*/
protected List rules = new ArrayList();
protected List paramDescriptors;
/**
* Name of this rule.
*/
protected String ruleName;
/**
* Constructor.
*/
public CoreSelectRule()
{
}
/**
* Get the registered rules as a List.
*
* @return the current value of the rules property
*/
public List getRules()
{
return rules;
}
/**
* Register a rule to this ruleSet.
* @param rule
*/
public void addRule(Rule rule)
{
rules.add( rule);
}
/**
* Get this ruleName.
* @return String
*/
public String getRuleName()
{
return ruleName;
}
/**
* setMemberName
*
* @param name String
*/
public void setRuleName(String name)
{
this.ruleName = name;
}
/**
* Is this rule allowed ?
* Return true if one of the registered rule is allowed. Rule are evaluated
* in the registration order. Stop at the first rule returning true.
* @param args
* @param context
* @return boolean
*/
public boolean isAllowed(Arguments args, RuleContext context)
throws TransformationException
{
Iterator iter = rules.iterator();
while( iter.hasNext() )
{
Rule rule = (Rule)iter.next();
context.enterLocalContext();
boolean res = false;
try
{
res = rule.isAllowed(args, context);
System.out.println( rule.getRuleName() + ".isAllowed()-->" + res);
if(res )
return true;
}
catch(TransformationException ex)
{
ex.fillInStackTrace(this, args, "rule" );
throw ex;
}
finally
{
context.exitLocalContext();
}
}
// nothing found, return false
return false;
}
/**
* Try to execute one of the registered rule.
* Rule are evaluated in the registration order. Stop as soon as one rule
* is executed.
* Return true if one of the rule is executed, false otherwise.
* @param args
* @param context
* @return boolean
*/
public boolean execute(Arguments args, RuleContext context)
throws TransformationException
{
Iterator iter = rules.iterator();
while( iter.hasNext() )
{
Rule rule = (Rule)iter.next();
context.enterLocalContext();
boolean res = false;
try
{
res = rule.execute(args, context);
//System.out.println( rule.getRuleName() + ".execute()-->" + res);
if(res )
return true;
}
catch(TransformationException ex)
{
ex.fillInStackTrace(this, args, "rule" );
throw ex;
}
finally
{
context.exitLocalContext();
}
}
// nothing found.
return false;
}
/**
* @return ParameterDescriptor
*/
public List getParameterDescriptors()
{
// if( paramDescriptors == null )
// { // The startEngine() method as not yet been called.
// // This happen when a rule check for a call arguments.
// // return the first registered rule descriptors.
// if(rules.size() == 0)
// { // The error will be thrown later by startEngine()
// System.out.println("no rule found");
// return Collections.EMPTY_LIST;
// }
// return ((Rule)rules.get(0)).getParameterDescriptors();
// }
return paramDescriptors;
}
/**
* engineFinish
*
* @param context RuleContext
*/
public void engineFinish(RuleContext context)
{
}
/**
* engineStart
*
* @param context RuleContext
*/
public void engineStart(RuleContext context)
throws EngineException
{
if( rules.size() == 0 )
throw new EngineException("CoreSelectRule - At least one rule must be registered.");
cloneDescriptors( context );
}
private void cloneDescriptors( RuleContext context )
{
// Check if the initialization is already done.
if( paramDescriptors != null )
return;
paramDescriptors = new ArrayList();
Iterator iter = ((Rule)rules.get(0)).getParameterDescriptors().iterator();
while(iter.hasNext() )
{
paramDescriptors.add( new SimpleDescriptor((ParameterDescriptor)iter.next(), context) );
}
}
/**
* getMemberName
*
* @return String
*/
public String getMemberName()
{
return getRuleName();
}
/**
* setMemberName
*
* @param name String
*/
public void setMemberName(String name)
{
setRuleName( name );
}
/**
* An implementation cloning the first rule descriptors
*/
public class SimpleDescriptor implements ParameterDescriptor
{
private boolean isIn;
private boolean isOut;
public SimpleDescriptor( ParameterDescriptor desc, RuleContext context )
{
isIn = desc.isIn(context);
isOut = desc.isOut(context);
}
/**
* isIn
*
* @param context RuleContext
* @return boolean
*/
public boolean isIn(RuleContext context)
{
return isIn;
}
/**
* isOut
*
* @param context RuleContext
* @return boolean
*/
public boolean isOut(RuleContext context)
{
return isOut;
}
}
}