/// <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;
Index inx = new Index(new IFact[] {(IFact) itr.Current});
next.assertLeft(inx, 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);
}
}
}
}
}
/// <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> 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);
}
}
}
}
}
/// <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> 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);
}
}
/// <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);
}
}
/// <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> 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> 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);
}
}
}
}
/// <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);
}
}
}
}
/// <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> 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();
}
/// <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> 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> Get the list of facts that have matched the node
/// </summary>
/// <returns>
///
/// </returns>
public virtual IAlphaMemory getMemory(IWorkingMemory mem)
{
return (IAlphaMemory) mem.getAlphaMemory(this);
}
/// <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);
}
}
}
}
}
/// <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> 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);
}
}
/// <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> Get the list of facts that have matched the node
/// </summary>
/// <returns>
///
/// </returns>
public virtual IAlphaMemory getMemory(IWorkingMemory mem)
{
return((IAlphaMemory)mem.getAlphaMemory(this));
}
/// <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();
}
