public virtual int addNewPartialMatch(IHashIndex index, IFact fact) { IGenericMap<object, object> matches = CollectionFactory.newMap(); matches.Put(fact, fact); memory.Put(index, matches); return 1; }
/// <summary> /// </summary> /// <param name="source">- the source should be either the workingMemory or Rete /// </param> /// <param name="typeCode">- event type /// </param> /// <param name="sourceNode">- the node which initiated the event /// /// </param> public EngineEvent(Object source, int typeCode, BaseNode sourceNode, IFact[] facts) { InitBlock(); this.typeCode = typeCode; this.sourceNode = sourceNode; this.facts = facts; }
/// <summary> addPartialMatch stores the fact with the factId as the /// key. /// </summary> public virtual int addPartialMatch(NotEqHashIndex index, IFact fact) { IGenericMap<Object, Object> matches = (IGenericMap<Object, Object>) memory.Get(index); int count = 0; if (matches == null) { count = addNewPartialMatch(index, fact); } else { IGenericMap<object, object> submatch = (IGenericMap<object, object>)matches.Get(index.SubIndex); if (submatch == null) { submatch = CollectionFactory.newHashMap(); submatch.Put(fact, fact); matches.Put(index.SubIndex, submatch); count = matches.Count; } else { submatch.Put(fact, fact); count = submatch.Count; } } counter++; return count; }
/// <summary> Assert from the right side is always going to be from an Alpha node. /// /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// /// </param> public override void assertRight(IFact rfact, Rete engine, IWorkingMemory mem) { // Get the memory for the node HashedNeqAlphaMemory rightmem = (HashedNeqAlphaMemory) mem.getBetaRightMemory(this); NotEqHashIndex inx = new NotEqHashIndex(NodeUtils.getRightBindValues(binds, rfact)); rightmem.addPartialMatch(inx, rfact); bool zm = rightmem.zeroMatch(inx); IGenericMap<Object, Object> leftmem = (IGenericMap<Object, Object>) mem.getBetaLeftMemory(this); IEnumerator itr = leftmem.Values.GetEnumerator(); while (itr.MoveNext()) { Index linx = (Index) itr.Current; if (evaluate(linx.Facts, rfact)) { if (!zm) { try { propogateRetract(linx, engine, mem); } catch (RetractException e) { throw new AssertException("NotJion - " + e.Message); } } } } }
public override void assertRight(IFact rfact, Rete engine, IWorkingMemory mem) { long time = LeftTime; TemporalHashedAlphaMem rightmem = (TemporalHashedAlphaMem) mem.getBetaRightMemory(this); EqHashIndex inx = new EqHashIndex(NodeUtils.getRightValues(binds, rfact)); rightmem.addPartialMatch(inx, rfact); // now that we've added the facts to the list, we // proceed with evaluating the fact IGenericMap<Object, Object> leftmem = (IGenericMap<Object, Object>) mem.getBetaLeftMemory(this); // since there may be key collisions, we iterate over the // values of the HashMap. If we used keySet to iterate, // we could encounter a ClassCastException in the case of // key collision. IEnumerator itr = leftmem.Values.GetEnumerator(); try { while (itr.MoveNext()) { Index linx = (Index) itr.Current; if (evaluate(linx.Facts, rfact, time)) { // now we propogate propogateAssert(linx.add(rfact), engine, mem); } else { propogateRetract(linx.add(rfact), engine, mem); } } } catch (RetractException e) { // we shouldn't Get a retract exception. if we do, it's a bug } }
public void Add(IFact fact, TElement element) { var nodePair = new NodePair(fact, element); _facts.AddLast(nodePair.FactNode); _elements.AddLast(nodePair.ElementNode); _nodeLookup[fact] = nodePair; }
/// <summary> Retract simply propogates it down the network /// </summary> public override void retractFact(IFact fact, Rete engine, IWorkingMemory mem) { IAlphaMemory alpha = (IAlphaMemory) mem.getAlphaMemory(this); if (alpha.removePartialMatch(fact) != null) { propogateRetract(fact, engine, mem); } }
/// <summary> /// Parses an XML Rule element /// </summary> /// <param name="a_rule">XML Rule element</param> /// <returns>Corresponding Rule object or null if parsing is unsuccessful</returns> protected Rule ParseRule(XElement a_rule) { // Variables pour le parsing string name; XElement premisesElement; List <XElement> factListElements = new List <XElement>(); XElement factElement; List <IFact> premises = new List <IFact>(); IFact conclusion; // Parsing de la balise <Rule> name = a_rule.Descendants("Name").FirstOrDefault().Value; if (name == null || name == string.Empty) { return(null); } premisesElement = a_rule.Descendants("Premises").FirstOrDefault(); if (premisesElement == null) { return(null); } factListElements = premisesElement.Descendants("Fact").ToList(); if (factListElements.Count == 0) { return(null); } factElement = a_rule.Descendants("Conclusion").FirstOrDefault().Descendants("Fact").FirstOrDefault(); if (factElement == null) { return(null); } // Si on arrive ici, la balise <Rule> est conforme (parsing des balises <Fact>) // Parsing des balises <Fact> foreach (XElement elementFact in factListElements) { IFact newFact = ParseFact(elementFact); if (newFact == null) { return(null); } premises.Add(newFact); } conclusion = ParseFact(factElement); if (conclusion == null) { return(null); } // Si on arrive ici, la balise <Rule> est conforme Rule newRule = new Rule(name, premises, conclusion); return(newRule); }
/// <summary> Get the values from the left side for nodes that do not have /// joins with != /// </summary> /// <param name="">facts /// </param> /// <returns> /// /// </returns> public static Object[] getLeftValues(Binding[] binds, IFact[] facts) { Object[] vals = new Object[binds.Length]; for (int idx = 0; idx < binds.Length; idx++) { vals[idx] = facts[binds[idx].LeftRow].getSlotValue(binds[idx].LeftIndex); } return vals; }
/* (non-Javadoc) * @see woolfel.engine.rete.BaseAlpha#assertFact(woolfel.engine.rete.Fact, woolfel.engine.Creshendo.Util.Rete.Rete, woolfel.engine.rete.WorkingMemory) */ public override void assertFact(IFact fact, Rete engine, IWorkingMemory mem) { if (evaluate(fact, engine)) { IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this); alpha.addPartialMatch(fact); propogateAssert(fact, engine, mem); } }
/// <summary> convienance method for getting the values based on the /// bindings /// </summary> /// <param name="">ft /// </param> /// <returns> /// /// </returns> public static BindValue[] getRightBindValues(Binding[] binds, IFact ft) { BindValue[] vals = new BindValue[binds.Length]; for (int idx = 0; idx < binds.Length; idx++) { vals[idx] = new BindValue(ft.getSlotValue(binds[idx].RightIndex), binds[idx].negated()); } return vals; }
public virtual int addNewPartialMatch(NotEqHashIndex index, IFact fact) { IGenericMap<object, object> matches = CollectionFactory.newHashMap(); IGenericMap<object, object> submatch = CollectionFactory.newHashMap(); submatch.Put(fact, fact); matches.Put(index.SubIndex, submatch); memory.Put(index, matches); return 1; }
/// <summary> convienance method for getting the values based on the /// bindings /// </summary> /// <param name="">ft /// </param> /// <returns> /// /// </returns> public static BindValue[] getRightBindValues(Binding[] binds, IFact ft) { BindValue[] vals = new BindValue[binds.Length]; for (int idx = 0; idx < binds.Length; idx++) { vals[idx] = new BindValue(ft.getSlotValue(binds[idx].RightIndex), binds[idx].negated()); } return(vals); }
/// <summary> Retract simply propogates it down the network /// </summary> public override void retractFact(IFact fact, Rete engine, IWorkingMemory mem) { IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this); if (alpha.removePartialMatch(fact) != null) { propogateRetract(fact, engine, mem); } }
/// <summary> convienance method for getting the values based on the bindings /// for nodes that do not have != /// </summary> /// <param name="">ft /// </param> /// <returns> /// /// </returns> public static Object[] getRightValues(Binding[] binds, IFact ft) { Object[] vals = new Object[binds.Length]; for (int idx = 0; idx < binds.Length; idx++) { vals[idx] = ft.getSlotValue(binds[idx].RightIndex); } return(vals); }
/// <summary> /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// /// </param> public override void assertFact(IFact fact, Rete engine, IWorkingMemory mem) { if (evaluate(fact)) { // if watch is on, we notify the engine. Rather than // create an event class here, we let Rete do that. propogateAssert(fact, engine, mem); } }
/// <summary> Get the values from the left side /// </summary> /// <param name="">facts /// </param> /// <returns> /// /// </returns> public static BindValue[] getLeftBindValues(Binding[] binds, IFact[] facts) { BindValue[] vals = new BindValue[binds.Length]; for (int idx = 0; idx < binds.Length; idx++) { vals[idx] = new BindValue(facts[binds[idx].LeftRow].getSlotValue(binds[idx].LeftIndex), binds[idx].negated()); } return vals; }
public void Modify(IFact fact, TElement element) { var nodePair = _nodeLookup[fact]; if (!ReferenceEquals(nodePair.ElementNode.Value, element)) { nodePair.ElementNode.Value = element; } }
public virtual int addNewPartialMatch(NotEqHashIndex index, IFact fact) { IGenericMap <object, object> matches = CollectionFactory.newHashMap(); IGenericMap <object, object> submatch = CollectionFactory.newHashMap(); submatch.Put(fact, fact); matches.Put(index.SubIndex, submatch); memory.Put(index, matches); return(1); }
public override int CompareSameFact(IFact <ChessGame> that) { SimpleFact fact = that as SimpleFact; if (PropertyName == fact.PropertyName) { return(this.Value.CompareTo(fact.Value)); } return(PropertyName.CompareTo(fact.PropertyName)); }
private void AddFactsSuggestionHighlighting( IHighlightingConsumer consumer, string message, IFact startElement, IFact endElement) { var highlighting = new HintRangeHighlighting<IFact>(startElement, endElement, message); IFile file = startElement.GetContainingFile(); if (file != null) { consumer.AddHighlighting(highlighting, file); } }
private void RaiseForBaseHandlers(IFact fact) { using (var scope = _lifetimeScope.BeginLifetimeScope()) { var handlers = (IEnumerable) scope.Resolve(typeof (IEnumerable<IHandle<IFact>>)); foreach (var handler in handlers) ((dynamic) handler).Handle((dynamic) fact); } }
private object[] GetKey(AggregationContext context, ITuple tuple, IFact fact) { var key = new object[_sortConditions.Length]; for (int i = 0; i < _sortConditions.Length; i++) { key[i] = _sortConditions[i].KeySelector.Invoke(context, tuple, fact); } return(key); }
private void AddFactsSuggestionHighlighting( IHighlightingConsumer consumer, string message, IFact startElement, IFact endElement) { var highlighting = new HintRangeHighlighting <IFact>(startElement, endElement, message); IFile file = startElement.GetContainingFile(); if (file != null) { consumer.AddHighlighting(highlighting, file); } }
/// <summary> Retract a fact from the node /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// /// </param> public override void retractFact(IFact fact, Rete engine, IWorkingMemory mem) { IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this); if (alpha.removePartialMatch(fact) != null) { // if watch is on, we notify the engine. Rather than // create an event class here, we let Rete do that. propogateRetract(fact, engine, mem); } }
public object Value(string name) { IFact f = Search(name); if (f == null) { return(null); } return(f.Value); }
public void RaiseFactRetracted(ISession session, IFact fact) { var handler = FactRetractedEvent; if (handler != null) { var @event = new WorkingMemoryEventArgs(fact); handler(session, @event); } _parent?.RaiseFactRetracted(session, fact); }
public override bool Implies(IFact <ChessGame> that) { if (that == null) { return(false); } OpeningFact fact = that as OpeningFact; return(Implies(fact)); }
public void testIndex() { Defclass dc = new Defclass(typeof(TestBean2)); Deftemplate dtemp = dc.createDeftemplate("testBean2"); TestBean2 bean = new TestBean2(); bean.Attr1 = ("testString"); bean.Attr2 = (1); short a3 = 3; bean.Attr3 = (a3); long a4 = 101; bean.Attr4 = (a4); float a5 = 10101; bean.Attr5 = (a5); double a6 = 101.101; bean.Attr6 = (a6); IFact fact = dtemp.createFact(bean, dc, 1); Assert.IsNotNull(fact); Console.WriteLine(fact.toFactString()); CompositeIndex ci = new CompositeIndex("attr1", Constants.EQUAL, fact.getSlotValue(0)); Assert.IsNotNull(ci); Console.WriteLine(ci.toPPString()); GenericHashMap <object, object> map = new GenericHashMap <object, object>(); map.Put(ci, bean); CompositeIndex ci2 = new CompositeIndex("attr1", Constants.EQUAL, fact.getSlotValue(0)); Assert.IsTrue(map.ContainsKey(ci2)); CompositeIndex ci3 = new CompositeIndex("attr1", Constants.NOTEQUAL, fact.getSlotValue(0)); Assert.IsFalse(map.ContainsKey(ci3)); CompositeIndex ci4 = new CompositeIndex("attr1", Constants.NILL, fact.getSlotValue(0)); Assert.IsFalse(map.ContainsKey(ci4)); CompositeIndex ci5 = new CompositeIndex("attr1", Constants.NOTNILL, fact.getSlotValue(0)); Assert.IsFalse(map.ContainsKey(ci5)); }
public void RaiseWithinUnitOfWork(IFact fact, IUnitOfWork unitOfWork) { var handlerType = typeof(IHandleDuringUnitOfWork<>).MakeGenericType(fact.GetType()); var handlersType = typeof(IEnumerable<>).MakeGenericType(handlerType); using (var scope = _lifetimeScope.BeginLifetimeScope()) { var handlers = (IEnumerable)scope.Resolve(handlersType, new Parameter[] { new TypedParameter(typeof(IUnitOfWork), unitOfWork) }); foreach (var handler in handlers) ((dynamic)handler).Handle((dynamic)fact); } }
/// <summary> the implementation will first check to see if the fact already matched. /// If it did, the fact stops and doesn't go any further. If it doesn't, /// it will attempt to evaluate it and Add the fact if it matches. /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// /// </param> public override void assertFact(IFact fact, Rete engine, IWorkingMemory mem) { if (evaluate(fact)) { IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this); alpha.addPartialMatch(fact); // if watch is on, we notify the engine. Rather than // create an event class here, we let Rete do that. propogateAssert(fact, engine, mem); } }
private AggregationResult RemoveElementOnly(IFact fact, TKey key, TElement element) { var group = _groups[key]; group.Remove(fact, element); if (group.Count == 0) { return(AggregationResult.Removed(group)); } return(AggregationResult.Modified(group, group, group.Facts)); }
public With_no_projection_facts() { correctFact = new MockSimpleFact("Correct!"); factA = new MockSimpleFact("A"); factB = new MockSimpleFact("B"); factAB = new MockSimpleFact("AB"); factC = new MockSimpleFact("C"); mockRuleGenerator = new MockRuleGenerator(); mockFilterer = new MockThresholdFilterer(); }
/// <summary> Method will evaluate a single slot from the left against the right. /// </summary> /// <param name="">left /// </param> /// <param name="">leftId /// </param> /// <param name="">right /// </param> /// <param name="">rightId /// </param> /// <returns> /// /// </returns> public virtual bool evaluate(IFact left, int leftId, IFact right, int rightId, int opr) { if (opr == Constants.NOTEQUAL) { return(Evaluate.evaluateNotEqual(left.getSlotValue(leftId), right.getSlotValue(rightId))); } else { return(Evaluate.evaluateEqual(left.getSlotValue(leftId), right.getSlotValue(rightId))); } }
public ILabel GetLabel(IPredicate predicate, IFact fact) { var key = LabelImpl.GetKey(predicate, fact); if (!_labels.ContainsKey(key)) { _labels.Add(key, new LabelImpl(predicate, fact)); } return(_labels[key]); }
public override bool Implies(IFact <string> that) { if (that == null) { return(false); } MockSimpleFact fact = that as MockSimpleFact; return(Implies(fact)); }
public void testAssertLeftOne() { // first create a rule engine instance Rete engine = new Rete(); NotJoin bn = new NotJoin(engine.nextNodeId()); Assert.IsNotNull(bn); // create a defclass Defclass dc = new Defclass(typeof(TestBean2)); // create deftemplate Deftemplate dtemp = dc.createDeftemplate("testBean2"); Assert.IsNotNull(dtemp); Binding[] binds = new Binding[1]; Binding b1 = new Binding(); b1.LeftIndex = (0); b1.IsObjectVar = (false); b1.LeftRow = (0); b1.RightIndex = (0); b1.VarName = ("var1"); binds[0] = b1; // set the binding bn.Bindings = (binds); TestBean2 bean = new TestBean2(); bean.Attr1 = ("random1"); bean.Attr2 = (101); short s = 10001; bean.Attr3 = (s); long l = 10101018; bean.Attr4 = (l); bean.Attr5 = (1010101); bean.Attr6 = (1001.1001); IFact f1 = dtemp.createFact(bean, dc, engine.nextFactId()); try { bn.assertLeft(new Index(new IFact[] { f1 }), engine, engine.WorkingMemory); IGenericMap <Object, Object> bmem = (IGenericMap <Object, Object>)engine.WorkingMemory.getBetaLeftMemory(bn); Assert.AreEqual(1, bmem.Count); } catch (AssertException e) { Console.WriteLine(e.Message); } engine.close(); }
/// <summary> Remove a partial match from the memory /// </summary> public virtual int removePartialMatch(IHashIndex index, IFact fact) { IGenericMap <Object, Object> list = (IGenericMap <Object, Object>)memory[index]; list.Remove(fact); if (list.Count == 0) { memory.Remove(index); } counter--; return(list.Count); }
public void AddFact(TKey key, IFact fact) { if (!_items.TryGetValue(key, out var list)) { list = new LinkedList <IFact>(); _items.Add(key, list); } var linkedListNode = list.AddLast(fact); _dataMap[fact] = new SortedFactData(key, linkedListNode); }
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed) { IList <object> facts = engine.AllFacts; Object[] sorted = FactUtils.sortFacts(facts); for (int idx = 0; idx < sorted.Length; idx++) { IFact ft = (IFact)sorted[idx]; engine.writeMessage(ft.toFactString() + Constants.LINEBREAK); } engine.writeMessage("for a total of " + sorted.Length + Constants.LINEBREAK, Constants.DEFAULT_OUTPUT); return(new DefaultReturnVector()); }
public virtual bool isPartialMatch(IHashIndex index, IFact fact) { IGenericMap <Object, Object> list = (IGenericMap <Object, Object>)memory[index]; if (list != null) { return(list.ContainsKey(fact)); } else { return(false); } }
/// <summary> find the matching fact in the array /// </summary> /// <param name="">temp /// </param> /// <param name="">facts /// </param> /// <returns> /// /// </returns> public static IFact findFact(Deftemplate temp, IFact[] facts) { IFact ft = null; for (int idx = 0; idx < facts.Length; idx++) { if (facts[idx].Deftemplate == temp) { ft = facts[idx]; } } return(ft); }
public object Invoke(ITuple tuple, IFact fact) { try { var factValue = fact.Value; var result = _compiledExpression.Delegate(factValue); return(result); } catch (Exception e) { throw new RuleExpressionEvaluationException("Failed to evaluate expression", _expression.ToString(), e); } }
public void Raise(IFact fact) { RaiseForBaseHandlers(fact); var handlerType = typeof (IHandle<>).MakeGenericType(fact.GetType()); var handlersType = typeof (IEnumerable<>).MakeGenericType(handlerType); using (var scope = _lifetimeScope.BeginLifetimeScope()) { var handlers = (IEnumerable) scope.Resolve(handlersType); foreach (var handler in handlers) ((dynamic) handler).Handle((dynamic) fact); } }
/// <summary> addPartialMatch stores the fact with the factId as the /// key. /// </summary> public virtual int addPartialMatch(IHashIndex index, IFact fact) { IGenericMap<Object, Object> matches = (IGenericMap<Object, Object>) memory.Get(index); int count = 0; if (matches == null) { count = addNewPartialMatch(index, fact); } else { matches.Put(fact, fact); count = matches.Count; } counter++; return count; }
/// <summary> Assert from the right side is always going to be from an /// Alpha node. /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// /// </param> public override void assertRight(IFact rfact, Rete engine, IWorkingMemory mem) { HashedNeqAlphaMemory rightmem = (HashedNeqAlphaMemory) mem.getBetaRightMemory(this); NotEqHashIndex inx = new NotEqHashIndex(NodeUtils.getRightBindValues(binds, rfact)); rightmem.addPartialMatch(inx, rfact); IGenericMap<Object, Object> leftmem = (IGenericMap<Object, Object>) mem.getBetaLeftMemory(this); IEnumerator itr = leftmem.Values.GetEnumerator(); int after = rightmem.count(inx); while (itr.MoveNext()) { Index linx = (Index) itr.Current; if (evaluate(linx.Facts, rfact)) { if (after == 1) { propogateAssert(linx, engine, mem); } } } }
/// <summary> /// Asserts the event. /// </summary> /// <param name="node">The node.</param> /// <param name="facts">The facts.</param> public virtual void assertEvent(BaseNode node, IFact[] facts) { if (debug) { if (node is TerminalNode) { Trace.WriteLine(((TerminalNode) node).Rule.Name + " fired"); } else { } } IEnumerator itr = listeners.GetEnumerator(); while (itr.MoveNext()) { EngineEventListener eel = (EngineEventListener) itr.Current; eel.eventOccurred(new EngineEvent(this, EngineEvent.ASSERT_EVENT, node, facts)); } }
/// <summary> Retract the fact to the succeeding nodes. ObjectTypeNode does not call /// assertEvent, since it's not that important and doesn't really /// help debugging. /// </summary> /// <param name="">fact /// </param> /// <param name="">engine /// /// </param> public override void retractFact(IFact fact, Rete engine, IWorkingMemory mem) { if (fact.Deftemplate == deftemplate) { ((IAlphaMemory) mem.getAlphaMemory(this)).removePartialMatch(fact); for (int idx = 0; idx < successorNodes.Length; idx++) { Object node = successorNodes[idx]; if (node is BaseAlpha) { ((BaseAlpha) node).retractFact(fact, engine, mem); } else if (node is BaseJoin) { ((BaseJoin) node).retractRight(fact, engine, mem); } } IEnumerator itr2 = successor2.GetEnumerator(); while (itr2.MoveNext()) { BaseNode node = (BaseNode) itr2.Current; if (node is BaseAlpha) { ((BaseAlpha) node).retractFact(fact, engine, mem); } else if (node is BaseJoin) { ((BaseJoin) node).retractRight(fact, engine, mem); } else if (node is TerminalNode) { Index inx = new Index(new IFact[] {fact}); ((TerminalNode) node).retractFacts(inx, engine, mem); } } } }
public virtual void assertSecondSuccessors(IFact fact, Rete engine, IWorkingMemory mem) { IEnumerator itr = successor2.GetEnumerator(); while (itr.MoveNext()) { BaseNode node = (BaseNode) itr.Current; if (node is BaseAlpha) { ((BaseAlpha) node).assertFact(fact, engine, mem); } else if (node is BaseJoin) { ((BaseJoin) node).assertRight(fact, engine, mem); } else if (node is TerminalNode) { Index inx = new Index(new IFact[] {fact}); ((TerminalNode) node).assertFacts(inx, engine, mem); } } }
/// <summary> Propogate the fact using the normal way of iterating over the /// successors and calling assert on AlphaNodes and assertRight on /// BetaNodes. /// </summary> /// <param name="">fact /// </param> /// <param name="">engine /// </param> /// <param name="">mem /// @throws AssertException /// /// </param> public virtual void assertAllSuccessors(IFact fact, Rete engine, IWorkingMemory mem) { for (int idx = 0; idx < successorNodes.Length; idx++) { Object node = successorNodes[idx]; if (node is BaseAlpha) { ((BaseAlpha) node).assertFact(fact, engine, mem); } else if (node is BaseJoin) { ((BaseJoin) node).assertRight(fact, engine, mem); } else if (node is TerminalNode) { Index inx = new Index(new IFact[] {fact}); ((TerminalNode) node).assertFacts(inx, engine, mem); } } assertSecondSuccessors(fact, engine, mem); }
/// <summary> assert using HashMap approach /// /// </summary> /// <param name="">fact /// </param> /// <param name="">engine /// </param> /// <param name="">mem /// /// </param> public virtual void assertFactWithMap(IFact fact, Rete engine, IWorkingMemory mem) { Slot[] slots = fact.Deftemplate.AllSlots; // iterate over the slots for (int idx = 0; idx < slots.Length; idx++) { // only if the slot's node count is greater than zero // do we go ahead and lookup in the HashMap if (slots[idx].NodeCount > 0) { // iterate over the operators for (int ops = 0; ops < operators.Length; ops++) { CompositeIndex comIndex = new CompositeIndex(slots[idx].Name, operators[ops], fact.getSlotValue(idx)); Object node = entries.Get(comIndex); if (node != null) { if (node is BaseAlpha) { ((BaseAlpha) node).assertFact(fact, engine, mem); } else if (node is BaseJoin) { ((BaseJoin) node).assertRight(fact, engine, mem); } else if (node is TerminalNode) { Index inx = new Index(new IFact[] {fact}); ((TerminalNode) node).assertFacts(inx, engine, mem); } } } } } assertSecondSuccessors(fact, engine, mem); }
/// <summary> assert the fact and propogate. ObjectTypeNode does not call /// assertEvent, since it's not that important and doesn't really /// help debugging. /// </summary> /// <param name="">fact /// </param> /// <param name="">engine /// /// </param> public override void assertFact(IFact fact, Rete engine, IWorkingMemory mem) { // ObjectTypeNode doesn't bother checking the deftemplate. ((IAlphaMemory) mem.getAlphaMemory(this)).addPartialMatch(fact); // if the number of succesor nodes is less than (slot count * opCount) if (gauranteeUnique && fact.Deftemplate.AllSlots.Length > 0 && successorNodes.Length > (fact.Deftemplate.AllSlots.Length*operators.Length)) { assertFactWithMap(fact, engine, mem); } else { assertAllSuccessors(fact, engine, mem); } }
/// <summary> evaluate will first compare the timestamp of the last fact in the fact /// array of the left and make sure the fact is still fresh. if it is not /// fresh, the method returns false. /// </summary> /// <param name="">leftlist /// </param> /// <param name="">right /// </param> /// <returns> /// /// </returns> public virtual bool evaluate(IFact[] leftlist, IFact right, long time) { bool eval = true; // first we compare the timestamp of the last fact in the // fact array. the last fact should be the fact with a // relative time window if (leftlist[leftlist.Length - 1].timeStamp() > time) { // we iterate over the binds and evaluate the facts for (int idx = 0; idx < binds.Length; idx++) { // we got the binding Binding bnd = binds[idx]; eval = bnd.evaluate(leftlist, right); if (!eval) { break; } } return eval; } else { return false; } }
/// <summary> Assert from the right side is always going to be from an Alpha node. /// /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// /// </param> public abstract override void assertRight(IFact rfact, Rete engine, IWorkingMemory mem);
/// <summary> evaluate will extra the values from each side and evaluate it /// </summary> /// <param name="">left /// </param> /// <param name="">right /// </param> /// <returns> /// /// </returns> public virtual bool evaluate(IFact[] left, IFact right) { if (left[leftrow] == right) { return false; } if (negated_Renamed_Field) { return Evaluate.evaluateNotEqual(left[leftrow].getSlotValue(leftIndex), right.getSlotValue(rightIndex)); } else { return Evaluate.evaluateEqual(left[leftrow].getSlotValue(leftIndex), right.getSlotValue(rightIndex)); } }
/// <summary> the implementation will first check to see if the fact already matched. /// If it did, the fact stops and doesn't go any further. If it doesn't, /// it will attempt to evaluate it and Add the fact if it matches. /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// /// </param> public override void assertFact(IFact fact, Rete engine, IWorkingMemory mem) { if (evaluate(fact)) { IAlphaMemory alpha = (IAlphaMemory) mem.getAlphaMemory(this); // we set the time of the last match alpha.addPartialMatch(fact); // if watch is on, we notify the engine. Rather than // create an event class here, we let Rete do that. propogateAssert(fact, engine, mem); } }
/// <summary> evaluate the node's value against the slot's value. The method /// uses Evaluate class to perform the evaluation /// </summary> /// <param name="">factInstance /// </param> /// <param name="">engine /// </param> /// <returns> /// /// </returns> public virtual bool evaluate(IFact factInstance) { bool not = slot.NotEqualList.Contains(factInstance.getSlotValue(slot.Id)); bool eq = slot.EqualList.Contains(factInstance.getSlotValue(slot.Id)); if (!not && eq) { return true; } else { return false; } }
/// <summary> /// Method will process the retractEvent, preferably with an event queue /// </summary> /// <param name="node">The node.</param> /// <param name="fact">The fact.</param> public virtual void assertEvent(BaseNode node, IFact fact) { if (debug) { Trace.WriteLine("\"assert at nodeid=" + node.nodeID + " - " + node.ToString().Replace("\"", "'") + ":: with fact -" + fact.toFactString().Replace("\"", "'") + "::\""); } IEnumerator itr = listeners.GetEnumerator(); while (itr.MoveNext()) { EngineEventListener eel = (EngineEventListener) itr.Current; eel.eventOccurred(new EngineEvent(this, EngineEvent.ASSERT_EVENT, node, new IFact[] {fact})); } }
/// <summary> retract right is a dummy, so it does nothing. /// </summary> public override void retractRight(IFact rfact, Rete engine, IWorkingMemory mem) { }
/// <summary> /// Retracts the event. /// </summary> /// <param name="node">The node.</param> /// <param name="facts">The facts.</param> public virtual void retractEvent(BaseNode node, IFact[] facts) { IEnumerator itr = listeners.GetEnumerator(); while (itr.MoveNext()) { EngineEventListener eel = (EngineEventListener) itr.Current; eel.eventOccurred(new EngineEvent(this, EngineEvent.ASSERT_EVENT, node, facts)); } }