/// <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>
/// Method is used to pass a fact to the successor nodes
/// </summary>
/// <param name="inx">The inx.</param>
/// <param name="engine">The engine.</param>
/// <param name="mem">The mem.</param>
protected internal virtual void propogateAssert(Index inx, Rete engine, IWorkingMemory mem)
{
for (int idx = 0; idx < successorNodes.Length; idx++)
{
BaseJoin baseJoin = successorNodes[idx] as BaseJoin;
if (baseJoin != null)
{
baseJoin.assertLeft(inx, engine, mem);
return;
}
TerminalNode terminalNode = successorNodes[idx] as TerminalNode;
if (terminalNode != null)
{
terminalNode.assertFacts(inx, engine, mem);
return;
}
//BaseNode node = successorNodes[idx];
//if (node is BaseJoin)
//{
// ((BaseJoin) node).assertLeft(inx, engine, mem);
//}
//else if (node is TerminalNode)
//{
// ((TerminalNode) node).assertFacts(inx, engine, mem);
//}
}
}
/// <summary>
/// method for propogating the retract
/// </summary>
/// <param name="inx">The inx.</param>
/// <param name="engine">The engine.</param>
/// <param name="mem">The mem.</param>
protected internal virtual void propogateRetract(Index inx, Rete engine, IWorkingMemory mem)
{
for (int idx = 0; idx < successorNodes.Length; idx++)
{
BaseJoin node = successorNodes[idx] as BaseJoin;
if (node != null)
{
node.retractLeft(inx, engine, mem);
}
else
{
TerminalNode tnode = successorNodes[idx] as TerminalNode;
if (tnode != null)
{
tnode.retractFacts(inx, engine, mem);
}
}
//BaseNode node = successorNodes[idx];
//if (node is BaseJoin)
//{
// ((BaseJoin) node).retractLeft(inx, engine, mem);
//}
//else if (node is TerminalNode)
//{
// ((TerminalNode) node).retractFacts(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> 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>
/// Method will attach a new JoinNode to an ancestor node. An ancestor
/// could be LIANode, AlphaNode or BetaNode.
/// </summary>
/// <param name="last">The last.</param>
/// <param name="join">The join.</param>
public virtual void attachJoinNode(BaseNode last, BaseJoin join)
{
if (last is BaseAlpha)
{
((BaseAlpha)last).addSuccessorNode(join, engine, memory);
}
else if (last is BaseJoin)
{
((BaseJoin)last).addSuccessorNode(join, engine, memory);
}
}
public virtual void printWorkingMemoryBetaRight()
{
StringBuilder buf = new StringBuilder();
IEnumerator itr = betaRightMemories.Keys.GetEnumerator();
while (itr.MoveNext())
{
BaseJoin key = (BaseJoin)itr.Current;
buf.Append(key.toPPString());
Object rmem = betaRightMemories.Get(key);
StringBuilder buf2 = new StringBuilder();
if (rmem is IGenericMap <Object, Object> )
{
int count = 0;
IEnumerator fitr = ((IGenericMap <Object, Object>)rmem).Values.GetEnumerator();
buf2.Append(": ");
while (fitr.MoveNext())
{
IFact ft = (IFact)fitr.Current;
buf2.Append(ft.FactId + ",");
count++;
}
buf.Append("- total=" + count + " ");
buf.Append(buf2.ToString());
buf.Append(Constants.LINEBREAK);
}
else
{
HashedAlphaMemoryImpl ham = (HashedAlphaMemoryImpl)rmem;
int count = 0;
Object[] fitr = ham.iterateAll();
if (fitr != null)
{
for (int idz = 0; idz < fitr.Length; idz++)
{
IFact ft = (IFact)fitr[idz];
buf2.Append(ft.FactId + ",");
count++;
}
}
buf.Append("- total=" + count + " :");
buf.Append(buf2.ToString());
buf.Append(Constants.LINEBREAK);
}
}
engine.writeMessage(buf.ToString());
}
/// <summary> propogate the retract
///
/// </summary>
/// <param name="">fact
/// </param>
/// <param name="">engine
///
/// </param>
protected internal override void propogateRetract(IFact fact, Rete engine, IWorkingMemory mem)
{
for (int idx = 0; idx < successorNodes.Length; idx++)
{
BaseNode nNode = successorNodes[idx];
if (nNode is BaseJoin)
{
BaseJoin next = (BaseJoin) nNode;
IFact[] newf = new IFact[] {fact};
next.retractLeft(new Index(newf), engine, mem);
}
else if (nNode is TerminalNode)
{
TerminalNode next = (TerminalNode) nNode;
IFact[] newf = new IFact[] {fact};
next.retractFacts(new Index(newf), engine, mem);
}
}
}
/// <summary> Method is used to pass a fact to the successor nodes
/// </summary>
/// <param name="">fact
/// </param>
/// <param name="">engine
///
/// </param>
protected internal virtual void propogateAssert(IFact fact, Rete engine, IWorkingMemory mem)
{
for (int idx = 0; idx < successorNodes.Length; idx++)
{
Object nNode = successorNodes[idx];
if (nNode is BaseAlpha)
{
BaseAlpha next = (BaseAlpha)nNode;
next.assertFact(fact, engine, mem);
}
else if (nNode is BaseJoin)
{
BaseJoin next = (BaseJoin)nNode;
next.assertRight(fact, engine, mem);
}
else if (nNode is TerminalNode)
{
TerminalNode next = (TerminalNode)nNode;
Index inx = new Index(new IFact[] { fact });
next.assertFacts(inx, engine, mem);
}
}
}
/// <summary>
/// Compiles the joins.
/// </summary>
/// <param name="rule">The rule.</param>
public virtual void compileJoins(Rule.IRule rule)
{
ICondition[] conds = rule.Conditions;
BaseJoin prevJoinNode = null;
BaseJoin joinNode = null;
ICondition prevCE = null;
// only if there's more than 1 condition do we attempt to
// create the join nodes. A rule with just 1 condition has
// no joins
if (conds.Length > 1)
{
// previous Condition
prevCE = conds[0];
//this.compileFirstJoin(engine, memory); moved to the ConditionCompiler.compileFirstJoin method
prevCE.getCompiler(this).compileFirstJoin(prevCE, rule);
// now compile the remaining conditions
for (int idx = 1; idx < conds.Length; idx++)
{
ICondition cdt = conds[idx];
joinNode = cdt.getCompiler(this).compileJoin(cdt, idx, rule);
cdt.getCompiler(this).connectJoinNode(prevCE, cdt, prevJoinNode, joinNode);
// now we set the previous node to current
prevCE = cdt;
prevJoinNode = joinNode;
rule.addJoinNode(joinNode);
}
}
else if (conds.Length == 1)
{
conds[0].getCompiler(this).compileSingleCE(rule);
}
}
/// <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);
}
}
}
/// <summary>
/// When new Successor nodes are added, we propogate the facts that matched to
/// the new join node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="engine">The engine.</param>
/// <param name="mem">The mem.</param>
public virtual void addSuccessorNode(BaseJoin node, Rete engine, IWorkingMemory mem)
{
if (addNode(node))
{
// first, we Get the memory for this node
IGenericMap <Object, Object> leftmem = (IGenericMap <Object, Object>)mem.getBetaLeftMemory(this);
// now we iterate over the entry set
IEnumerator itr = leftmem.GetEnumerator();
while (itr.MoveNext())
{
IBetaMemory bmem = (IBetaMemory)itr.Current;
Index left = bmem.Index;
// iterate over the matches
IGenericMap <Object, Object> rightmem = (IGenericMap <Object, Object>)mem.getBetaRightMemory(this);
IEnumerator ritr = rightmem.Keys.GetEnumerator();
while (ritr.MoveNext())
{
IFact rfcts = (IFact)ritr.Current;
// now assert in the new join node
node.assertLeft(left.add(rfcts), engine, mem);
}
}
}
}
/// <summary> method for propogating the retract
/// </summary>
/// <param name="">fact
/// </param>
/// <param name="">engine
///
/// </param>
protected internal virtual void propogateRetract(IFact fact, Rete engine, IWorkingMemory mem)
{
for (int idx = 0; idx < successorNodes.Length; idx++)
{
Object nNode = successorNodes[idx];
if (nNode is BaseAlpha)
{
BaseAlpha next = (BaseAlpha)nNode;
next.retractFact(fact, engine, mem);
}
else if (nNode is BaseJoin)
{
BaseJoin next = (BaseJoin)nNode;
// AlphaNodes always call retractRight in the
// BetaNode
next.retractRight(fact, engine, mem);
}
else if (nNode is TerminalNode)
{
Index inx = new Index(new IFact[] { fact });
((TerminalNode)nNode).retractFacts(inx, engine, mem);
}
}
}
public virtual void clear()
{
reteNode = null;
}
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>
/// Method will attach a new JoinNode to an ancestor node. An ancestor
/// could be LIANode, AlphaNode or BetaNode.
/// </summary>
/// <param name="last">The last.</param>
/// <param name="join">The join.</param>
public virtual void attachJoinNode(BaseNode last, BaseJoin join)
{
if (last is BaseAlpha)
{
((BaseAlpha) last).addSuccessorNode(join, engine, memory);
}
else if (last is BaseJoin)
{
((BaseJoin) last).addSuccessorNode(join, engine, memory);
}
}
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> Add join nodes to the rule
/// </summary>
public virtual void addJoinNode(BaseJoin node)
{
joins.Add(node);
}
/// <summary>
/// When new Successor nodes are added, we propogate the facts that matched to
/// the new join node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="engine">The engine.</param>
/// <param name="mem">The mem.</param>
public virtual void addSuccessorNode(BaseJoin node, Rete engine, IWorkingMemory mem)
{
if (addNode(node))
{
// first, we Get the memory for this node
IGenericMap<Object, Object> leftmem = (IGenericMap<Object, Object>) mem.getBetaLeftMemory(this);
// now we iterate over the entry set
IEnumerator itr = leftmem.GetEnumerator();
while (itr.MoveNext())
{
IBetaMemory bmem = (IBetaMemory) itr.Current;
Index left = bmem.Index;
// iterate over the matches
IGenericMap<Object, Object> rightmem = (IGenericMap<Object, Object>) mem.getBetaRightMemory(this);
IEnumerator ritr = rightmem.Keys.GetEnumerator();
while (ritr.MoveNext())
{
IFact rfcts = (IFact) ritr.Current;
// now assert in the new join node
node.assertLeft(left.add(rfcts), engine, mem);
}
}
}
}