/// <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();
}
public virtual void clear()
{
IEnumerator amitr = alphaMemories.Values.GetEnumerator();
while (amitr.MoveNext())
{
IAlphaMemory am = (IAlphaMemory)amitr.Current;
am.clear();
}
alphaMemories.Clear();
// aggressivley Clear the memories
IEnumerator blitr = betaLeftMemories.Values.GetEnumerator();
while (blitr.MoveNext())
{
Object bval = blitr.Current;
if (bval is IGenericMap <Object, Object> )
{
IGenericMap <Object, Object> lmem = (IGenericMap <Object, Object>)bval;
// now iterate over the betamemories
IEnumerator bmitr = lmem.Keys.GetEnumerator();
while (bmitr.MoveNext())
{
Index indx = (Index)bmitr.Current;
indx.clear();
}
lmem.Clear();
}
}
betaLeftMemories.Clear();
IEnumerator britr = betaRightMemories.Values.GetEnumerator();
while (britr.MoveNext())
{
Object val = britr.Current;
if (val is HashedAlphaMemoryImpl)
{
((HashedAlphaMemoryImpl)val).clear();
}
else if (val is TemporalHashedAlphaMem)
{
((TemporalHashedAlphaMem)val).clear();
}
else
{
IGenericMap <IFact, IFact> mem = (IGenericMap <IFact, IFact>)val;
mem.Clear();
}
}
betaRightMemories.Clear();
terminalMemories.Clear();
root.clear();
focusStack.Clear();
//contexts.Clear();
agenda.clear();
main.clear();
currentModule.clear();
addModule(main);
}
/// <summary>
/// The terminal nodes doesn't have a memory, so the method
/// does nothing.
/// </summary>
/// <param name="mem"></param>
public override void clear(IWorkingMemory mem)
{
IGenericMap <Object, Object> tmem = (IGenericMap <Object, Object>)mem.getTerminalMemory(this);
if (tmem != null)
{
tmem.Clear();
}
}
/// <summary>
/// Subclasses need to implement Clear and make sure all
/// memories are cleared properly.
/// </summary>
/// <param name="mem">The mem.</param>
public virtual void clear(IWorkingMemory mem)
{
IGenericMap <Object, Object> leftmem = (IGenericMap <Object, Object>)mem.getBetaLeftMemory(this);
leftmem.Clear();
HashedAlphaMemoryImpl rightmem = (HashedAlphaMemoryImpl)mem.getBetaRightMemory(this);
rightmem.clear();
}
/// <summary> Clear the memory.
/// </summary>
public virtual void clear()
{
IEnumerator itr = memory.Values.GetEnumerator();
while (itr.MoveNext())
{
((IGenericMap <Object, Object>)itr.Current).Clear();
}
memory.Clear();
}
/// <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();
}
public virtual void clear()
{
lock (this)
{
IEnumerator itr = inputNodes.Values.GetEnumerator();
while (itr.MoveNext())
{
ObjectTypeNode otn = (ObjectTypeNode)itr.Current;
otn.clearSuccessors();
}
inputNodes.Clear();
}
}
/// <summary> When Clear is called, the module needs to Clear all the internal lists
/// for rules and activations. The handle to Rete should not be nulled.
/// </summary>
public virtual void clear()
{
activations.clear();
IEnumerator itr = rules.Values.GetEnumerator();
while (itr.MoveNext())
{
Defrule rl = (Defrule)itr.Current;
rl.clear();
}
rules.Clear();
deftemplates.Clear();
}
/// <summary> Clear the memory.
/// </summary>
public virtual void clear()
{
foreach (IGenericMap <Object, Object> val in memory.Values)
{
val.Clear();
}
memory.Clear();
//IEnumerator itr = memory.Values.GetEnumerator();
//while (itr.MoveNext())
//{
// ((Map)itr.Current()).Clear();
//}
//memory.Clear();
}
/// <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> 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> method to Clear the successors. method doesn't iterate over
/// the succesors and Clear them individually.
/// </summary>
public virtual void clearSuccessors()
{
IEnumerator itr = successor2.GetEnumerator();
while (itr.MoveNext())
{
BaseNode n = (BaseNode)itr.Current;
n.removeAllSuccessors();
}
itr = entries.Values.GetEnumerator();
while (itr.MoveNext())
{
BaseNode n = (BaseNode)itr.Current;
n.removeAllSuccessors();
}
for (int idx = 0; idx < successorNodes.Length; idx++)
{
successorNodes[idx].removeAllSuccessors();
}
successor2.Clear();
successorNodes = new BaseNode[0];
entries.Clear();
}
/// <summary> Clear the memory.
/// </summary>
public virtual void clear()
{
memory.Clear();
}
/// <summary> Clear will Clear the memory
/// </summary>
public virtual void clear()
{
matches.Clear();
index = null;
}
