/// <summary> /// Add a new ObjectTypeNode. The implementation will check to see /// if the node already exists. It will only Add the node if it /// doesn't already exist in the network. /// </summary> /// <param name="node">The node.</param> public virtual void addObjectTypeNode(ObjectTypeNode node) { if (!inputNodes.ContainsKey(node.Deftemplate)) { inputNodes.Put(node.Deftemplate, node); } }
/// <summary> implementation will Remove the template from the HashMap /// and it will Remove the ObjectTypeNode from the network. /// </summary> public virtual void removeTemplate(ITemplate temp, Rete engine, IWorkingMemory mem) { deftemplates.Remove(temp.Name); if (temp.ClassName != null) { deftemplates.Remove(temp.ClassName); } ObjectTypeNode otn = mem.RuleCompiler.getObjectTypeNode(temp); mem.RuleCompiler.removeObjectTypeNode(otn); }
public virtual void clear() { lock (this) { IEnumerator itr = inputNodes.Values.GetEnumerator(); while (itr.MoveNext()) { ObjectTypeNode otn = (ObjectTypeNode)itr.Current; otn.clearSuccessors(); } inputNodes.Clear(); } }
public void testOneSlot() { Defclass dc = new Defclass(typeof (TestBean2)); Deftemplate dtemp = dc.createDeftemplate("testBean2"); TestBean2 bean = new TestBean2(); Slot[] slts = dtemp.AllSlots; ObjectTypeNode otn = new ObjectTypeNode(1, dtemp); AlphaNode an = new AlphaNode(1); slts[0].Value = ConversionUtils.convert(110); an.Operator = Constants.EQUAL; an.Slot = (slts[0]); Console.WriteLine("node::" + an.ToString()); Assert.IsNotNull(an.ToString(), "Should have a value."); }
/// <summary> /// Method will Get the deftemplate's parent and do a lookup /// </summary> /// <param name="fact">The fact.</param> /// <param name="template">The template.</param> /// <param name="engine">The engine.</param> /// <param name="mem">The mem.</param> public virtual void retractObjectParent(IFact fact, ITemplate template, Rete engine, IWorkingMemory mem) { lock (this) { ObjectTypeNode otn = (ObjectTypeNode)inputNodes.Get(template); if (otn != null) { otn.retractFact(fact, engine, mem); } if (template.Parent != null) { retractObjectParent(fact, template.Parent, engine, mem); } } }
/// <summary> /// method will find the first LeftInputAdapter node for the /// ObjectTypeNode. There should only be one that is a direct /// successor. /// </summary> /// <param name="otn">The otn.</param> /// <returns></returns> public virtual LIANode findLIANode(ObjectTypeNode otn) { LIANode node = null; if (otn.SuccessorNodes != null && otn.SuccessorNodes.Length > 0) { Object[] nodes = (Object[])otn.SuccessorNodes; for (int idx = 0; idx < nodes.Length; idx++) { if (nodes[idx] is LIANode) { node = (LIANode)nodes[idx]; break; } } } return(node); }
protected internal virtual void removeAlphaNodes(IList nodes, ObjectTypeNode otn) { BaseNode prev = otn; for (int idx = 0; idx < nodes.Count; idx++) { BaseNode node = (BaseNode)nodes[idx]; if (node.useCount > 1) { node.decrementUseCount(); } else { prev.removeNode(node); } prev = node; } }
/// <summary> /// assertObject begins the pattern matching /// </summary> /// <param name="fact">The fact.</param> /// <param name="engine">The engine.</param> /// <param name="mem">The mem.</param> public virtual void assertObject(IFact fact, Rete engine, IWorkingMemory mem) { lock (this) { // we assume Rete has already checked to see if the object // has been added to the working memory, so we just assert. // we need to lookup the defclass and deftemplate to assert // the object to the network ObjectTypeNode otn = (ObjectTypeNode)inputNodes.Get(fact.Deftemplate); if (otn != null) { otn.assertFact(fact, engine, mem); } if (fact.Deftemplate.Parent != null) { assertObjectParent(fact, fact.Deftemplate.Parent, engine, mem); } } }
/// <summary> The implementation will use either the defclass or the /// template name for the key. The templates are stored in /// a HashMap. /// </summary> public virtual void addTemplate(ITemplate temp, Rete engine, IWorkingMemory mem) { if (!deftemplates.ContainsKey(temp.Name)) { // we have to set the template's module if (temp.ClassName != null) { deftemplates.Put(temp.Name, temp); deftemplates.Put(temp.ClassName, temp); templateCount++; } else { deftemplates.Put(temp.Name, temp); templateCount++; } ObjectTypeNode otn = new ObjectTypeNode(engine.nextNodeId(), temp); mem.RuleCompiler.addObjectTypeNode(otn); } }
/// <summary> implementation uses the deftemplate for the HashMap key and the /// node for the value. If the node already exists in the HashMap, /// or the key already exists, the compiler will not Add it to the /// network. /// </summary> public virtual void addObjectTypeNode(ObjectTypeNode node) { if (!inputnodes.ContainsKey(node.Deftemplate)) { inputnodes.Put(node.Deftemplate, node); } // if it is the objectTypeNode for InitialFact, we go ahead and create // the Left Input Adapter node for it if (node.Deftemplate is InitialFact) { try { IFLIANode lian = new IFLIANode(engine.nextNodeId()); node.addSuccessorNode(lian, engine, engine.workingMem); } catch (AssertException e) { } } }
public void testTwoSlots() { Defclass dc = new Defclass(typeof (TestBean2)); Deftemplate dtemp = dc.createDeftemplate("testBean2"); TestBean2 bean = new TestBean2(); Slot[] slts = dtemp.AllSlots; ObjectTypeNode otn = new ObjectTypeNode(1, dtemp); AlphaNode an1 = new AlphaNode(1); AlphaNode an2 = new AlphaNode(1); slts[0].Value = ("testString"); slts[1].Value = (ConversionUtils.convert(999)); an1.Slot = (slts[0]); an1.Operator = (Constants.EQUAL); Console.WriteLine("node::" + an1.toPPString()); Assert.IsNotNull(an1.toPPString()); an2.Slot = (slts[1]); an2.Operator = (Constants.GREATER); Console.WriteLine("node::" + an2.toPPString()); Assert.IsNotNull(an2.toPPString()); }
/// <summary> Remove a rule from this module /// </summary> public virtual void removeRule(Rule.IRule rl, Rete engine, IWorkingMemory mem) { rules.Remove(rl.Name); // we should iterate over the nodes of the rule and Remove // them if they are not shared ICondition[] cnds = rl.Conditions; // first Remove the alpha nodes for (int idx = 0; idx < cnds.Length; idx++) { ICondition cnd = cnds[idx]; if (cnd is ObjectCondition) { ObjectCondition oc = (ObjectCondition)cnd; String templ = oc.TemplateName; Deftemplate temp = (Deftemplate)deftemplates.Get(templ); ObjectTypeNode otn = mem.RuleCompiler.getObjectTypeNode(temp); removeAlphaNodes(oc.Nodes, otn); } } // now Remove the betaNodes, since the engine currently // doesn't share the betaNodes, we can just Remove it IList bjl = rl.Joins; for (int idx = 0; idx < bjl.Count; idx++) { BaseJoin bjoin = (BaseJoin)bjl[idx]; ICondition cnd = cnds[idx + 1]; if (cnd is ObjectCondition) { ObjectCondition oc = (ObjectCondition)cnd; String templ = oc.TemplateName; Deftemplate temp = (Deftemplate)deftemplates.Get(templ); ObjectTypeNode otn = mem.RuleCompiler.getObjectTypeNode(temp); otn.removeNode(bjoin); } } }
/// <summary> The implementation will use either the defclass or the /// template name for the key. The templates are stored in /// a HashMap. /// </summary> public virtual void addTemplate(ITemplate temp, Rete engine, IWorkingMemory mem) { if (!deftemplates.ContainsKey(temp.Name)) { // we have to set the template's module if (temp.ClassName != null) { deftemplates.Put(temp.Name, temp); deftemplates.Put(temp.ClassName, temp); templateCount++; } else { deftemplates.Put(temp.Name, temp); templateCount++; } ObjectTypeNode otn = new ObjectTypeNode(engine.nextNodeId(), temp); mem.RuleCompiler.addObjectTypeNode(otn); } }
protected internal virtual void removeAlphaNodes(IList nodes, ObjectTypeNode otn) { BaseNode prev = otn; for (int idx = 0; idx < nodes.Count; idx++) { BaseNode node = (BaseNode) nodes[idx]; if (node.useCount > 1) { node.decrementUseCount(); } else { prev.removeNode(node); } prev = node; } }
/// <summary> Method will Remove the ObjectTypeNode and call Clear on it. /// </summary> public virtual void removeObjectTypeNode(ObjectTypeNode node) { inputnodes.Remove(node.Deftemplate); node.clear(memory); node.clearSuccessors(); }
/// <summary> The current implementation just removes the ObjectTypeNode /// and doesn't prevent the removal. The method should be called /// with care, since removing the ObjectTypeNode can have serious /// negative effects. This would generally occur when an undeftemplate /// occurs. /// </summary> public virtual void removeObjectTypeNode(ObjectTypeNode node) { inputNodes.Remove(node.Deftemplate); }
/// <summary> Method will Remove the ObjectTypeNode and call Clear on it. /// </summary> public virtual void removeObjectTypeNode(ObjectTypeNode node) { inputnodes.Remove(node.Deftemplate); node.clear(memory); node.clearSuccessors(); }
/// <summary> /// method will find the first LeftInputAdapter node for the /// ObjectTypeNode. There should only be one that is a direct /// successor. /// </summary> /// <param name="otn">The otn.</param> /// <returns></returns> public virtual LIANode findLIANode(ObjectTypeNode otn) { LIANode node = null; if (otn.SuccessorNodes != null && otn.SuccessorNodes.Length > 0) { Object[] nodes = (Object[]) otn.SuccessorNodes; for (int idx = 0; idx < nodes.Length; idx++) { if (nodes[idx] is LIANode) { node = (LIANode) nodes[idx]; break; } } } return node; }
/// <summary> implementation uses the deftemplate for the HashMap key and the /// node for the value. If the node already exists in the HashMap, /// or the key already exists, the compiler will not Add it to the /// network. /// </summary> public virtual void addObjectTypeNode(ObjectTypeNode node) { if (!inputnodes.ContainsKey(node.Deftemplate)) { inputnodes.Put(node.Deftemplate, node); } // if it is the objectTypeNode for InitialFact, we go ahead and create // the Left Input Adapter node for it if (node.Deftemplate is InitialFact) { try { IFLIANode lian = new IFLIANode(engine.nextNodeId()); node.addSuccessorNode(lian, engine, engine.workingMem); } catch (AssertException e) { } } }