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; }