/// <summary> Set the Current node in the sequence of 1-input nodes.
/// The Current node can be an AlphaNode or a LIANode.
/// </summary>
/// <param name="">node
///
/// </param>
public override void addSuccessorNode(BaseNode node, Rete engine, IWorkingMemory mem)
{
if (addNode(node))
{
// if there are matches, we propogate the facts to
// the new successor only
IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this);
if (alpha.size() > 0)
{
IEnumerator itr = alpha.GetEnumerator();
while (itr.MoveNext())
{
if (node is BaseAlpha)
{
BaseAlpha next = (BaseAlpha)node;
next.assertFact((IFact)itr.Current, engine, mem);
}
else if (node is BaseJoin)
{
BaseJoin next = (BaseJoin)node;
next.assertRight((IFact)itr.Current, engine, mem);
}
else if (node is TerminalNode)
{
TerminalNode next = (TerminalNode)node;
Index inx = new Index(new IFact[] { (IFact)itr.Current });
next.assertFacts(inx, engine, mem);
}
}
}
}
}
public void PropagateAssert(IExecutionContext context, Fact fact)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
memory.Facts.Add(fact);
_sinks.ForEach(s => s.PropagateAssert(context, fact));
}
public void PropagateRetract(IExecutionContext context, List <Fact> facts)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
var toRetract = new List <Fact>(facts.Count);
using (var counter = PerfCounter.Retract(context, this))
{
foreach (var fact in facts)
{
if (memory.Contains(fact))
{
toRetract.Add(fact);
}
}
counter.AddInputs(facts.Count);
counter.AddOutputs(toRetract.Count);
}
if (toRetract.Count > 0)
{
foreach (var sink in _sinks)
{
sink.PropagateRetract(context, toRetract);
}
using (var counter = PerfCounter.Retract(context, this))
{
memory.Remove(toRetract);
counter.SetCount(memory.FactCount);
}
}
}
/// <summary> the implementation just propogates the assert down the network
/// </summary>
public override void assertFact(IFact fact, Rete engine, IWorkingMemory mem)
{
IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this);
alpha.addPartialMatch(fact);
propogateAssert(fact, engine, mem);
}
/// <summary> Remove a successor node
/// </summary>
/// <param name="">node
/// </param>
/// <param name="">engine
/// </param>
/// <param name="">mem
/// @throws AssertException
///
/// </param>
public virtual void removeSuccessorNode(BaseNode node, Rete engine, IWorkingMemory mem)
{
if (removeNode(node))
{
// we retract the memories first, before removing the node
IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this);
if (alpha.size() > 0)
{
IEnumerator itr = alpha.GetEnumerator();
while (itr.MoveNext())
{
if (node is BaseAlpha)
{
BaseAlpha next = (BaseAlpha)node;
next.retractFact((IFact)itr.Current, engine, mem);
}
else if (node is BaseJoin)
{
BaseJoin next = (BaseJoin)node;
next.retractRight((IFact)itr.Current, engine, mem);
}
}
}
}
}
public void PropagateUpdate(IExecutionContext context, IList <Fact> facts)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
var toUpdate = new List <Fact>();
var toAssert = new List <Fact>();
foreach (var fact in facts)
{
if (memory.Contains(fact))
{
toUpdate.Add(fact);
}
else
{
toAssert.Add(fact);
}
}
if (toUpdate.Count > 0)
{
foreach (var sink in _sinks)
{
sink.PropagateUpdate(context, toUpdate);
}
}
if (toAssert.Count > 0)
{
PropagateAssert(context, toAssert);
}
}
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> Add a successor node
/// </summary>
public override void addSuccessorNode(BaseNode node, Rete engine, IWorkingMemory mem)
{
if (!containsNode(successorNodes, node) && !successor2.Contains(node))
{
if (node is BaseJoin || node is TerminalNode)
{
successor2.Add(node);
}
else
{
// we test to see if the operator is ==, nil, not nil
// if the node isn't BaseJoin, it should be BaseAlpha
BaseAlpha ba = (BaseAlpha)node;
if (ba.Operator == Constants.LESS || ba.Operator == Constants.GREATER || ba.Operator == Constants.LESSEQUAL || ba.Operator == Constants.GREATEREQUAL || ba.Operator == Constants.NOTEQUAL || ba.Operator == Constants.NOTNILL)
{
successor2.Add(node);
}
else
{
addNode(node);
}
}
if (gauranteeUnique && node is AlphaNode)
{
// now we use CompositeIndex instead of HashString
AlphaNode anode = (AlphaNode)node;
entries.Put(anode.HashIndex, node);
// we increment the node count for the slot
deftemplate.getSlot(anode.slot.Id).incrementNodeCount();
}
// if there are matches, we propogate the facts to
// the new successor only
IAlphaMemory alpha = (IAlphaMemory)mem.getAlphaMemory(this);
if (alpha.size() > 0)
{
IEnumerator itr = alpha.GetEnumerator();
while (itr.MoveNext())
{
IFact f = (IFact)itr.Current;
if (node is BaseAlpha)
{
BaseAlpha next = (BaseAlpha)node;
next.assertFact(f, engine, mem);
}
else if (node is BaseJoin)
{
BaseJoin next = (BaseJoin)node;
next.assertRight(f, engine, mem);
}
else if (node is TerminalNode)
{
TerminalNode t = (TerminalNode)node;
Index inx = new Index(new IFact[] { f });
t.assertFacts(inx, engine, mem);
}
}
}
}
}
/// <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> 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);
propogateAssert(fact, engine, mem);
}
}
public void PropagateAssert(IExecutionContext context, IList <Fact> facts)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
foreach (var sink in _sinks)
{
sink.PropagateAssert(context, facts);
}
memory.Add(facts);
}
public void PropagateRetract(IExecutionContext context, Fact fact)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
foreach (var sink in _sinks)
{
sink.PropagateRetract(context, fact);
}
memory.Remove(fact);
}
/// <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);
}
}
/// <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);
}
}
public void PropagateUpdate(IExecutionContext context, Fact fact)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
if (memory.Facts.Contains(fact))
{
_sinks.ForEach(s => s.PropagateUpdate(context, fact));
}
else
{
PropagateAssert(context, fact);
}
}
public void PropagateUpdate(IExecutionContext context, Fact fact)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
if (memory.Contains(fact))
{
foreach (var sink in _sinks)
{
sink.PropagateUpdate(context, fact);
}
}
else
{
PropagateAssert(context, fact);
}
}
public void PropagateAssert(IExecutionContext context, List <Fact> facts)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
foreach (var sink in _sinks)
{
sink.PropagateAssert(context, facts);
}
using (var counter = PerfCounter.Assert(context, this))
{
memory.Add(facts);
counter.AddItems(facts.Count);
counter.SetCount(memory.FactCount);
}
}
public virtual void printWorkingMemory(bool detailed, bool inputNodes)
{
engine.writeMessage("AlphaNode count " + alphaMemories.Count + Constants.LINEBREAK);
IEnumerator itr = alphaMemories.Keys.GetEnumerator();
int memTotal = 0;
while (itr.MoveNext())
{
BaseNode key = (BaseNode)itr.Current;
if (!(key is ObjectTypeNode) && !(key is LIANode))
{
IAlphaMemory am = (IAlphaMemory)alphaMemories.Get(key);
if (detailed)
{
engine.writeMessage(key.toPPString() + " count=" + am.size() + Constants.LINEBREAK);
}
memTotal += am.size();
}
else
{
if (inputNodes)
{
IAlphaMemory am = (IAlphaMemory)alphaMemories.Get(key);
engine.writeMessage(key.toPPString() + " count=" + am.size() + Constants.LINEBREAK);
}
}
}
engine.writeMessage("total AlphaMemories = " + memTotal + Constants.LINEBREAK);
// now write out the left beta memory
engine.writeMessage("BetaNode Count " + betaLeftMemories.Count + Constants.LINEBREAK);
int betaTotal = 0;
itr = betaLeftMemories.Keys.GetEnumerator();
while (itr.MoveNext())
{
BaseNode key = (BaseNode)itr.Current;
if (key is BaseJoin)
{
printBetaNodes((BaseJoin)key, detailed, betaTotal);
}
}
engine.writeMessage("total BetaMemories = " + betaTotal + Constants.LINEBREAK);
}
/// <summary>
/// Printout the memory for the given rule.
/// </summary>
/// <param name="rule">The rule.</param>
public virtual void printWorkingMemory(Rule.IRule rule)
{
engine.writeMessage("Memories for " + rule.Name);
ICondition[] conds = rule.Conditions;
int memTotal = 0;
for (int idx = 0; idx < conds.Length; idx++)
{
ICondition c = conds[idx];
IList l = c.Nodes;
IEnumerator itr = l.GetEnumerator();
while (itr.MoveNext())
{
BaseNode key = (BaseNode)itr.Current;
IAlphaMemory am = (IAlphaMemory)alphaMemories.Get(key);
engine.writeMessage(key.toPPString() + " count=" + am.size() + Constants.LINEBREAK);
memTotal += am.size();
}
}
}
public void PropagateRetract(IExecutionContext context, IList <Fact> facts)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
var toRetract = new List <Fact>(facts.Count);
foreach (var fact in facts)
{
if (memory.Contains(fact))
{
toRetract.Add(fact);
}
}
if (toRetract.Count > 0)
{
foreach (var sink in _sinks)
{
sink.PropagateRetract(context, toRetract);
}
memory.Remove(toRetract);
}
}
public IEnumerable <Fact> GetFacts(IExecutionContext context)
{
IAlphaMemory memory = context.WorkingMemory.GetNodeMemory(this);
return(memory.Facts);
}
/// <summary> Clear the memory. for now the method does not
/// Remove all the successor nodes. need to think it over a bit.
/// </summary>
public override void clear(IWorkingMemory mem)
{
IAlphaMemory am = (IAlphaMemory)mem.getAlphaMemory(this);
am.clear();
}
internal static NodeInfo Create(AlphaMemoryNode node, IAlphaMemory memory)
{
var items = memory.Facts.Select(f => f.Object.ToString());
return(new NodeInfo(NodeType.AlphaMemory, string.Empty, Empty, Empty, items));
}
internal static NodeInfo Create(AlphaMemoryNode node, IAlphaMemory memory)
{
return new NodeInfo(NodeType.AlphaMemory, string.Empty, Empty, Empty, memory.Facts.Select(f => f.Object.ToString()));
}
