/// <summary> The current implementation will try to find the memory for the node. /// If it doesn't find it, it will create a new one. /// </summary> public virtual Object getAlphaMemory(Object key) { Object m = alphaMemories.Get(key); if (m == null) { String mname = "alphamem" + ((BaseNode)key).nodeID; m = new AlphaMemoryImpl(mname); alphaMemories.Put(key, m); } return(m); }
/// <summary> the current implementation will try to find the memory for the node. /// If it doesn't find it, it will create a new Left memory, which is /// HashMap. /// </summary> public virtual IGenericMap <object, object> getBetaLeftMemory(Object key) { IGenericMap <object, object> m = betaLeftMemories.Get(key); if (m == null) { // it should create a new memory // and return it. String mname = "blmem" + ((BaseNode)key).nodeID; m = CollectionFactory.newBetaMemoryMap(mname); betaLeftMemories.Put(key, m); } return(m); }
public virtual void assertFact(IFact fact) { Deffact f = (Deffact)fact; if (!containsFact(f)) { deffactMap.Put(fact.equalityIndex(), f); f.setFactId = engine; if (profileAssert_Renamed_Field) { assertFactWProfile(f); } else { if (watchFact_Renamed_Field) { engine.writeMessage("==> " + fact.toFactString() + Constants.LINEBREAK, "t"); } root.assertObject(f, engine, this); } } else { f.resetID((Deffact)deffactMap.Get(fact.equalityIndex())); } }
/// <summary> Clear will Clear the lists /// </summary> public override void clear(IWorkingMemory mem) { IGenericMap <Object, Object> leftmem = mem.getBetaLeftMemory(this); IGenericMap <Object, Object> rightmem = (IGenericMap <Object, Object>)mem.getBetaRightMemory(this); // first we iterate over the list for each fact // and Clear it. foreach (object item in leftmem.Keys) { ((IBetaMemory)leftmem.Get(item)).clear(); } /* * IEnumerator itr = leftmem.Keys.GetEnumerator(); * // first we iterate over the list for each fact * // and Clear it. * while (itr.MoveNext()) * { * IBetaMemory bmem = (IBetaMemory) leftmem.Get(itr.Current); * bmem.clear(); * } */ // now that we've cleared the list for each fact, we // can Clear the Creshendo.rete.util.Map. leftmem.Clear(); rightmem.Clear(); }
/// <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); } } }
public virtual Object getTerminalMemory(Object key) { Object m = terminalMemories.Get(key); if (m == null) { m = CollectionFactory.newTerminalMap(); terminalMemories.Put(key, m); } return(m); }
/// <summary> Clear will Clear all the modules and Remove all activations /// </summary> public virtual void clear() { IEnumerator itr = modules.Keys.GetEnumerator(); while (itr.MoveNext()) { Object key = itr.Current; IModule mod = (IModule)modules.Get(key); mod.clear(); } modules.Clear(); }
/// <summary> the current implementation will try to find the memory for the node. /// If it doesn't find it, it checks the node type and creates the /// appropriate AlphaMemory for the node. Since right memories are /// hashed, it creates the appropriate type of Hashed memory. /// </summary> public virtual Object getBetaRightMemory(Object key) { Object val = betaRightMemories.Get(key); if (val != null) { return(val); } else { if (key is HashedEqBNode || key is HashedEqNJoin || key is ExistJoin) { String mname = "hnode" + ((BaseNode)key).nodeID; HashedAlphaMemoryImpl alpha = new HashedAlphaMemoryImpl(mname); betaRightMemories.Put(key, alpha); return(alpha); } else if (key is HashedNotEqBNode || key is HashedNotEqNJoin || key is ExistNeqJoin) { String mname = "hneq" + ((BaseNode)key).nodeID; HashedNeqAlphaMemory alpha = new HashedNeqAlphaMemory(mname); betaRightMemories.Put(key, alpha); return(alpha); } else if (key is TemporalEqNode) { String mname = "hnode" + ((BaseNode)key).nodeID; TemporalHashedAlphaMem alpha = new TemporalHashedAlphaMem(mname); betaRightMemories.Put(key, alpha); return(alpha); } else { String mname = "brmem" + ((BaseNode)key).nodeID; IGenericMap <IFact, IFact> right = CollectionFactory.newAlphaMemoryMap(mname); betaRightMemories.Put(key, right); return(right); } } }
/// <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); } } }
/* (non-Javadoc) * @see woolfel.engine.rete.EngineEventListener#eventOccurred(woolfel.engine.rete.EngineEvent) */ #region EngineEventListener Members public virtual void eventOccurred(EngineEvent event_Renamed) { if (event_Renamed.EventType == EngineEvent.ASSERT_EVENT) { asserts.Add(event_Renamed); } else if (event_Renamed.EventType == EngineEvent.ASSERT_PROFILE_EVENT) { asserts.Add(event_Renamed); profiles.Add(event_Renamed); } else if (event_Renamed.EventType == EngineEvent.ASSERT_RETRACT_EVENT) { asserts.Add(event_Renamed); retracts.Add(event_Renamed); } else if (event_Renamed.EventType == EngineEvent.ASSERT_RETRACT_PROFILE_EVENT) { asserts.Add(event_Renamed); profiles.Add(event_Renamed); retracts.Add(event_Renamed); } else if (event_Renamed.EventType == EngineEvent.PROFILE_EVENT) { profiles.Add(event_Renamed); } else if (event_Renamed.EventType == EngineEvent.RETRACT_EVENT) { retracts.Add(event_Renamed); } Object val = nodeFilter.Get(event_Renamed.SourceNode); if (val != null) { ((List <Object>)val).Add(event_Renamed); } }
/// <summary> Clear will Clear the lists /// </summary> public override void clear(IWorkingMemory mem) { IGenericMap <Object, Object> leftmem = (IGenericMap <Object, Object>)mem.getBetaLeftMemory(this); HashedNeqAlphaMemory rightmem = (HashedNeqAlphaMemory)mem.getBetaRightMemory(this); IEnumerator itr = leftmem.Keys.GetEnumerator(); // first we iterate over the list for each fact // and Clear it. while (itr.MoveNext()) { IBetaMemory bmem = (IBetaMemory)leftmem.Get(itr.Current); bmem.clear(); } // now that we've cleared the list for each fact, we // can Clear the Creshendo.rete.util.Map. leftmem.Clear(); rightmem.clear(); }
/// <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> return the value associated with the binding /// </summary> public virtual Object getBindingValue(string key) { Object val = bindValues.Get(key); if (val == null) { Binding bd = (Binding)bindings[key]; if (bd != null) { IFact left = triggerFacts[bd.LeftRow]; if (bd.IsObjectVar) { val = left; } else { val = left.getSlotValue(bd.LeftIndex); } } } return(val); }
/// <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> implementation looks up the rule in the HashMap /// </summary> public virtual Rule.IRule findRule(String name) { return((Rule.IRule)rules.Get(name)); }
public virtual bool isPartialMatch(NotEqHashIndex index, IFact fact) { IGenericMap <Object, Object> match = (IGenericMap <Object, Object>)memory.Get(index); if (match != null) { IGenericMap <Object, Object> submatch = (IGenericMap <Object, Object>)match.Get(index.SubIndex); if (submatch != null) { return(submatch.ContainsKey(fact)); } else { return(false); } } else { return(false); } }
public virtual IModule findModule(String name) { return((IModule)modules.Get(name)); }
/// <summary> Remove a partial match from the memory /// </summary> public virtual int removePartialMatch(NotEqHashIndex index, IFact fact) { IGenericMap <Object, Object> match = (IGenericMap <Object, Object>)memory.Get(index); if (match != null) { IGenericMap <Object, Object> submatch = (IGenericMap <Object, Object>)match.Get(index.SubIndex); submatch.Remove(fact); if (submatch.Count == 0) { match.Remove(index.SubIndex); } counter--; return(submatch.Count); } return(-1); }
protected internal virtual void printBetaNodes(BaseJoin bjoin, bool detailed, int betaTotal) { if (bjoin is HashedEqBNode || bjoin is HashedEqNJoin) { IGenericMap <Object, Object> bm = (IGenericMap <Object, Object>)betaLeftMemories.Get(bjoin); // we iterate over the keys in the HashMap IEnumerator bitr = bm.Keys.GetEnumerator(); while (bitr.MoveNext()) { Index indx = (Index)bm.Get(bitr.Current); if (detailed) { engine.writeMessage(bjoin.toPPString(), Constants.DEFAULT_OUTPUT); HashedAlphaMemoryImpl rightmem = (HashedAlphaMemoryImpl)getBetaRightMemory(bjoin); EqHashIndex eqinx = new EqHashIndex(NodeUtils.getLeftValues(bjoin.binds, indx.Facts)); // Add to the total count betaTotal += rightmem.count(eqinx); engine.writeMessage(" count=" + betaTotal + " - " + indx.toPPString() + ": ", Constants.DEFAULT_OUTPUT); IEnumerator ritr = rightmem.iterator(eqinx); if (ritr != null) { StringBuilder buf = new StringBuilder(); while (ritr.MoveNext()) { buf.Append(((IFact)ritr.Current).FactId + ","); } engine.writeMessage(buf.ToString(), Constants.DEFAULT_OUTPUT); } engine.writeMessage(Constants.LINEBREAK, Constants.DEFAULT_OUTPUT); } } } else if (bjoin is HashedNotEqNJoin || bjoin is HashedNotEqBNode) { IGenericMap <Object, Object> bm = (IGenericMap <Object, Object>)betaLeftMemories.Get(bjoin); // we iterate over the keys in the HashMap IEnumerator bitr = bm.Keys.GetEnumerator(); while (bitr.MoveNext()) { Index indx = (Index)bm.Get(bitr.Current); if (detailed) { engine.writeMessage(bjoin.toPPString(), Constants.DEFAULT_OUTPUT); HashedNeqAlphaMemory rightmem = (HashedNeqAlphaMemory)getBetaRightMemory(bjoin); EqHashIndex eqinx = new EqHashIndex(NodeUtils.getLeftValues(bjoin.binds, indx.Facts)); // Add to the total count betaTotal += rightmem.count(eqinx); engine.writeMessage(" count=" + betaTotal + " - " + indx.toPPString() + ": ", Constants.DEFAULT_OUTPUT); IEnumerator ritr = rightmem.iterator(eqinx); if (ritr != null) { StringBuilder buf = new StringBuilder(); while (ritr.MoveNext()) { buf.Append(((IFact)ritr.Current).FactId + ","); } engine.writeMessage(buf.ToString(), Constants.DEFAULT_OUTPUT); } engine.writeMessage(Constants.LINEBREAK, Constants.DEFAULT_OUTPUT); } } } else if (bjoin is ExistJoin) { ExistJoin henj = (ExistJoin)bjoin; IGenericMap <Object, Object> bm = (IGenericMap <Object, Object>)betaLeftMemories.Get(henj); // we iterate over the keys in the HashMap IEnumerator bitr = bm.Keys.GetEnumerator(); while (bitr.MoveNext()) { Index indx = (Index)bm.Get(bitr.Current); if (detailed) { engine.writeMessage(bjoin.toPPString(), Constants.DEFAULT_OUTPUT); HashedAlphaMemoryImpl rightmem = (HashedAlphaMemoryImpl)getBetaRightMemory(henj); EqHashIndex eqinx = new EqHashIndex(NodeUtils.getLeftValues(henj.binds, indx.Facts)); // Add to the total count betaTotal += rightmem.count(eqinx); engine.writeMessage(" count=" + betaTotal + " - " + indx.toPPString() + ": ", Constants.DEFAULT_OUTPUT); IEnumerator ritr = rightmem.iterator(eqinx); if (ritr != null) { StringBuilder buf = new StringBuilder(); while (ritr.MoveNext()) { buf.Append(((IFact)ritr.Current).FactId + ","); } engine.writeMessage(buf.ToString(), Constants.DEFAULT_OUTPUT); } engine.writeMessage(Constants.LINEBREAK, Constants.DEFAULT_OUTPUT); } } } else if (bjoin is NotJoin) { NotJoin nj = (NotJoin)bjoin; IGenericMap <Object, Object> bm = (IGenericMap <Object, Object>)getBetaLeftMemory(bjoin); IEnumerator bitr = bm.Keys.GetEnumerator(); while (bitr.MoveNext()) { Index indx = (Index)bitr.Current; IBetaMemory bmem = (IBetaMemory)bm.Get(indx); engine.writeMessage(bmem.toPPString()); } } else if (bjoin is TemporalEqNode) { TemporalEqNode ten = (TemporalEqNode)bjoin; } else { IGenericMap <Object, Object> bm = (IGenericMap <Object, Object>)betaLeftMemories.Get(bjoin); // we iterate over the keys in the HashMap IEnumerator bitr = bm.Keys.GetEnumerator(); while (bitr.MoveNext()) { Index indx = (Index)bm.Get(bitr.Current); Object rightmem = betaRightMemories.Get(bjoin); if (detailed) { if (rightmem is HashedAlphaMemoryImpl) { HashedAlphaMemoryImpl hami = (HashedAlphaMemoryImpl)rightmem; engine.writeMessage(bjoin.toPPString() + " count=" + hami.size() + " - " + indx.toPPString() + Constants.LINEBREAK); } else { IGenericMap <Object, Object> rmap = (IGenericMap <Object, Object>)rightmem; engine.writeMessage(bjoin.toPPString() + " count=" + rmap.Count + " - " + indx.toPPString() + Constants.LINEBREAK); } } if (rightmem is HashedAlphaMemoryImpl) { betaTotal += ((HashedAlphaMemoryImpl)rightmem).size(); } else { betaTotal += ((IGenericMap <IFact, IFact>)rightmem).Count; } } } }
/// <summary> return an List with all the facts /// </summary> /// <returns> /// /// </returns> public override Object[] iterateAll() { Object[] facts = new Object[counter]; IEnumerator itr = memory.Keys.GetEnumerator(); int idx = 0; while (itr.MoveNext()) { IGenericMap <Object, Object> matches = (IGenericMap <Object, Object>)memory.Get(itr.Current); IEnumerator itr2 = matches.Keys.GetEnumerator(); while (itr2.MoveNext()) { IGenericMap <Object, Object> submatch = (IGenericMap <Object, Object>)matches.Get(itr2.Current); IEnumerator itr3 = submatch.Values.GetEnumerator(); while (itr3.MoveNext()) { facts[idx] = itr3.Current; idx++; } } } Object[] trim = new Object[idx]; Array.Copy(facts, 0, trim, 0, idx); facts = null; return(trim); }
/// <summary> Return the number of memories of all hash buckets /// </summary> public override int size() { IEnumerator itr = memory.Keys.GetEnumerator(); int count = 0; while (itr.MoveNext()) { IGenericMap <Object, Object> matches = (IGenericMap <Object, Object>)memory.Get(itr.Current); IEnumerator itr2 = matches.Keys.GetEnumerator(); while (itr2.MoveNext()) { EqHashIndex ehi = (EqHashIndex)itr2.Current; IGenericMap <Object, Object> submatch = (IGenericMap <Object, Object>)matches.Get(ehi); count += submatch.Count; } } return(count); }
/// <summary> Here is a description of the compilation algorithm. /// 1. iterate over the conditional elements /// i. generate the alpha nodes /// a. literal constraints generate alpha node /// b. predicate constaints that compare against a literal generate alpha node /// ii. calculate the bindings /// a. each binding has a rowId /// b. NOT and EXIST CE do not increment the rowId /// 2. iterate over the conditional elements /// i. generate the beta nodes /// ii. attach the Left Input adapater nodes /// iii. attach the join nodes to the alpha nodes /// 3. create the terminal node and attach to the last /// join node. /// /// This means the rule compiler takes a 2 pass approach to /// compiling rules. At the start of the method, it sets 3 /// attributes to null: prevCE, prevJoinNode, joinNode. /// Those attributes are used by the compile join methods, /// so it's important to set it to null at the start. If /// we don't the Current rule won't compile correctly. /// </summary> public virtual bool addRule(Rule.IRule rule) { rule.resolveTemplates(engine); if (!validate || (validate && tval.analyze(rule) == Analysis_Fields.VALIDATION_PASSED)) { // we have to set the attributes to null, before we start compiling a rule. // we've set the attributes to null, so we can compile now!! if (rule.Conditions != null && rule.Conditions.Length > 0) { // we check the name of the rule to see if it is for a specific // module. if it is, we have to Add it to that module Module = rule; try { ICondition[] conds = rule.Conditions; // first we create the constraints, before creating the Conditional // elements which include joins // we use a counter and only increment it to make sure the // row index of the bindings are accurate. this makes it simpler // for the rule compiler and compileJoins is cleaner and does // less work. int counter = 0; for (int idx = 0; idx < conds.Length; idx++) { ICondition con = conds[idx]; // compile object conditions //implement in the ObjectConditionCompiler.compile or ExistConditionCompiler.compile con.getCompiler(this).compile(con, counter, rule, rule.RememberMatch); if ((con is ObjectCondition) && (!((ObjectCondition)con).Negated)) { counter++; } } // now we compile the joins compileJoins(rule); BaseNode last = rule.LastNode; TerminalNode tnode = createTerminalNode(rule); attachTerminalNode(last, tnode); // compile the actions compileActions(rule, rule.Actions); // now we pass the bindings to the rule, so that actiosn can // resolve the bindings // now we Add the rule to the module currentMod.addRule(rule); CompileMessageEventArgs ce = new CompileMessageEventArgs(rule, EventType.ADD_RULE_EVENT); ce.Rule = rule; notifyListener(ce); return(true); } catch (AssertException e) { CompileMessageEventArgs ce = new CompileMessageEventArgs(rule, EventType.INVALID_RULE); ce.Message = Messages.getString("RuleCompiler.assert.error"); //$NON-NLS-1$ notifyListener(ce); TraceLogger.Instance.Debug(e); return(false); } } else if (rule.Conditions.Length == 0) { Module = rule; // the rule has no LHS, this means it only has actions BaseNode last = (BaseNode)inputnodes.Get(engine.initFact); TerminalNode tnode = createTerminalNode(rule); compileActions(rule, rule.Actions); attachTerminalNode(last, tnode); // now we Add the rule to the module currentMod.addRule(rule); CompileMessageEventArgs ce = new CompileMessageEventArgs(rule, EventType.ADD_RULE_EVENT); ce.Rule = rule; notifyListener(ce); return(true); } return(false); } else { // we need to print out a message saying the rule was not valid ISummary error = tval.Errors; engine.writeMessage("Rule " + rule.Name + " was not added. ", Constants.DEFAULT_OUTPUT); //$NON-NLS-1$ //$NON-NLS-2$ engine.writeMessage(error.Message, Constants.DEFAULT_OUTPUT); ISummary warn = tval.Warnings; engine.writeMessage(warn.Message, Constants.DEFAULT_OUTPUT); return(false); } }
/// <summary> Return an GetEnumerator of the values /// </summary> public virtual Object[] iterator(NotEqHashIndex index) { IGenericMap <Object, Object> matches = (IGenericMap <Object, Object>)memory.Get(index); Object[] list = new Object[counter]; Object[] trim = null; int idz = 0; if (matches != null) { IEnumerator itr = matches.Keys.GetEnumerator(); while (itr.MoveNext()) { Object key = itr.Current; // if the key doesn't match the subindex, we // Add it to the list. If it matches, we exclude // it. if (!index.SubIndex.Equals(key)) { IGenericMap <Object, Object> submatch = (IGenericMap <Object, Object>)matches.Get(key); IEnumerator itr2 = submatch.Keys.GetEnumerator(); while (itr2.MoveNext()) { list[idz] = itr2.Current; idz++; } } trim = new Object[idz]; Array.Copy(list, 0, trim, 0, idz); } list = null; return(trim); } else { return(null); } }
/// <summary> /// Return the write method using slot name for the key /// </summary> /// <param name="name">The name.</param> /// <returns></returns> public virtual MethodInfo getWriteMethod(String name) { return(((PropertyInfo)methods.Get(name)).GetSetMethod()); }
/// <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> The current implementation calls HashMap.Get(key). if the key /// and value aren't in the HashMap, it returns null. /// </summary> /// <param name="">name /// </param> /// <returns> /// /// </returns> public virtual Object getValue(String name) { return(variables.Get(name)); }
/// <summary> Clear the memory. /// </summary> public override void clear() { IEnumerator itr = memory.Keys.GetEnumerator(); while (itr.MoveNext()) { object key = itr.Current; IGenericMap <Object, Object> matches = (IGenericMap <Object, Object>)memory.Get(key); IEnumerator itr2 = matches.Keys.GetEnumerator(); while (itr2.MoveNext()) { Object subkey = itr2.Current; IGenericMap <Object, Object> submatch = (IGenericMap <Object, Object>)matches.Get(subkey); submatch.Clear(); } matches.Clear(); } memory.Clear(); }
/// <summary> /// if there are zero matches for the NotEqHashIndex2, the method /// return true. If there are matches, the method returns false. /// False means there's 1 or more matches /// </summary> /// <param name="index">The index.</param> /// <returns></returns> public virtual bool zeroMatch(NotEqHashIndex index) { IGenericMap <Object, Object> matches = (IGenericMap <Object, Object>)memory.Get(index); int idz = 0; if (matches != null) { IEnumerator itr = matches.Keys.GetEnumerator(); while (itr.MoveNext()) { Object key = itr.Current; // if the key doesn't match the subindex, Add it to the // counter. if (!index.SubIndex.Equals(key)) { IGenericMap <Object, Object> submatch = (IGenericMap <Object, Object>)matches.Get(key); idz += submatch.Count; } if (idz > 0) { break; } } return(false); } else { return(true); } }