private void AddSubRule(AbstractRuleNode subRule)
{
m_SubRules.Add(subRule);
}
/// <summary> This method processes the XML Document.
/// <P>
/// This is a recursive alg. So be careful if editing it!!!!!!!
/// </P>
/// </summary>
/// <param name="aNode">The Node to process
/// </param>
/// <param name="aSetId">The set to process</param>
/// <param name="aObj">A bland object for anything
/// </param>
/// <returns> True if successful, False otherwise
///
/// </returns>
private object ProcessXML(AbstractRuleNode aNode, object aObj)
{
if ((aNode == null) || (!running)) return null;
//string nodeName = aNode.LocalName;
//DispatchLog("Element Node: " + nodeName, LogEventImpl.DEBUG);
/*
A lot of this code is the same but it is broken up for
scalability reasons...
*/
switch (aNode.GetNodeType())
{
case AbstractRuleNode.NodeType.BusinessRules:
{
BusinessRulesNode brn = aNode as BusinessRulesNode;
foreach (AbstractRuleNode subNode in brn.SubRules)
ProcessXML(subNode, aObj);
}
break;
case AbstractRuleNode.NodeType.Compare:
{
Hashtable map = new Hashtable();
DoRecursion(aNode as RuleWithSubRules, map);
aObj = ProcessCompareNode(aNode as CompareNode, map);
map = null;
}
break;
case AbstractRuleNode.NodeType.Condition:
{
aObj = ProcessConditionNode(aNode as ConditionNode, aObj);
}
break;
case AbstractRuleNode.NodeType.Do:
{
DoRecursion(aNode as RuleWithSubRules, aObj);
}
break;
case AbstractRuleNode.NodeType.Else:
{
DoRecursion(aNode as RuleWithSubRules, aObj);
}
break;
case AbstractRuleNode.NodeType.ForEach:
{
ForeachNode fen = aNode as ForeachNode;
string resultToAssert = fen.ResultToAssert;
string objectToEnumerate = fen.ObjectToEnumerate;
IEnumerable enumerable = (IEnumerable)ruleContext.GetObject(objectToEnumerate);
if (enumerable != null)
foreach (object parser in enumerable)
{
ruleContext.SetObject(resultToAssert, parser);
DoRecursion(aNode as RuleWithSubRules, aObj);
}
}
break;
case AbstractRuleNode.NodeType.If:
case AbstractRuleNode.NodeType.ElseIf:
case AbstractRuleNode.NodeType.While:
{
DecisionNode dn = aNode as DecisionNode;
bool exitWhile = false;
do
{
bool firstChild = true;
foreach (AbstractRuleNode subNode in dn.SubRules)
{
if (firstChild) aObj = null;
// Thanks Sihong & Bernhard
aObj = ProcessXML(subNode, aObj);
// Only the first child node is considered as test
// the rest are executed blindely
if ((firstChild) && (aObj is System.Boolean))
{
bool passed = ((System.Boolean)aObj);
if ((!passed) || (!running))
{
exitWhile = true;
break;
}
}
firstChild = false;
}
} while ((aNode.GetNodeType() == AbstractRuleNode.NodeType.While) && (!exitWhile));
}
break;
case AbstractRuleNode.NodeType.InvokeSet:
{
ProcessInvokeSetNode(aNode as InvokeSetNode);
}
break;
case AbstractRuleNode.NodeType.Log:
{
ProcessLogNode(aNode as LogNode);
}
break;
case AbstractRuleNode.NodeType.Logic:
{
LogicNode ln = aNode as LogicNode;
foreach (AbstractRuleNode subNode in ln.SubRules)
{
aObj = ProcessXML(subNode, aObj);
if (aObj is System.Boolean)
{
bool passed = ((System.Boolean)aObj);
if ((passed) || (!running))
break;
}
}
}
break;
case AbstractRuleNode.NodeType.Parameter:
{
if (aObj is Hashtable)
ProcessParameterNode(aNode as ParameterNode, (Hashtable)aObj);
}
break;
case AbstractRuleNode.NodeType.Retract:
{
RetractNode rn = aNode as RetractNode;
string idToRetract = rn.Id;
if (ruleContext.ResultsMap.ContainsKey(idToRetract))
ruleContext.ResultsMap.Remove(idToRetract);
}
break;
case AbstractRuleNode.NodeType.Rule:
{
RuleNode rn = aNode as RuleNode;
Hashtable map = new Hashtable();
DoRecursion(rn, map);
ProcessRuleNode(rn, map);
map = null;
}
break;
case AbstractRuleNode.NodeType.Set:
{
// If I reach a SET node, it has been pre-filtered at document level
// therefore I process it blindely
DoRecursion(aNode as SetNode, aObj);
}
break;
}
return aObj;
}
