/// <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> 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>
/// it's unlikely 2 rules are identical, except for the name. The implementation
/// gets the current memory and propogates, but I wonder how much sense this
/// makes in a real production environment. An user really shouldn't be deploying
/// identical rules with different rule name.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="engine">The engine.</param>
/// <param name="mem">The mem.</param>
public virtual void addSuccessorNode(TerminalNode 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.Values.GetEnumerator();
while (itr.MoveNext())
{
Object omem = itr.Current;
if (omem is IBetaMemory)
{
IBetaMemory bmem = (IBetaMemory)omem;
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;
// merge the left and right fact into a new Array
node.assertFacts(left.add(rfcts), engine, mem);
}
}
}
}
}
/// <summary> NotJoin has to have a special addSuccessorNode since it needs
/// to just propogate the left facts if it has zero matches.
/// </summary>
public override void addSuccessorNode(TerminalNode 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.Values.GetEnumerator();
while (itr.MoveNext())
{
Object omem = itr.Current;
if (omem is IBetaMemory)
{
IBetaMemory bmem = (IBetaMemory)omem;
EqHashIndex inx = new EqHashIndex(NodeUtils.getLeftValues(binds, bmem.LeftFacts));
HashedAlphaMemoryImpl rightmem = (HashedAlphaMemoryImpl)mem.getBetaRightMemory(this);
// we don't bother adding the right fact to the left, since
// the right side is already Hashed
if (rightmem.count(inx) == 0)
{
node.assertFacts(bmem.Index, engine, mem);
}
}
}
}
}
/// <summary> NotJoin has to have a special addSuccessorNode since it needs
/// to just propogate the left facts if it has zero matches.
/// </summary>
public override void addSuccessorNode(TerminalNode 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.Values.GetEnumerator();
while (itr.MoveNext())
{
Object omem = itr.Current;
if (omem is IBetaMemory)
{
IBetaMemory bmem = (IBetaMemory) omem;
EqHashIndex inx = new EqHashIndex(NodeUtils.getLeftValues(binds, bmem.LeftFacts));
HashedAlphaMemoryImpl rightmem = (HashedAlphaMemoryImpl) mem.getBetaRightMemory(this);
// we don't bother adding the right fact to the left, since
// the right side is already Hashed
if (rightmem.count(inx) == 0)
{
node.assertFacts(bmem.Index, 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> 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);
}
}
}
protected internal virtual void attachTerminalNode(BaseNode last, TerminalNode terminal)
{
if (last != null && terminal != null)
{
try
{
if (last is BaseJoin)
{
((BaseJoin)last).addSuccessorNode(terminal, engine, memory);
}
else if (last is BaseAlpha)
{
((BaseAlpha)last).addSuccessorNode(terminal, engine, memory);
}
}
catch (AssertException e)
{
}
}
}
/// <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> NotJoin has to have a special addSuccessorNode since it needs
/// to just propogate the left facts if it has zero matches.
/// </summary>
public override void addSuccessorNode(TerminalNode 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.Values.GetEnumerator();
while (itr.MoveNext())
{
Object omem = itr.Current;
if (omem is IBetaMemory)
{
IBetaMemory bmem = (IBetaMemory)omem;
// iterate over the matches
if (bmem.matchCount() == 0)
{
node.assertFacts(bmem.Index, engine, mem);
}
}
}
}
}
/// <summary> NotJoin has to have a special addSuccessorNode since it needs
/// to just propogate the left facts if it has zero matches.
/// </summary>
public override void addSuccessorNode(TerminalNode 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.Values.GetEnumerator();
while (itr.MoveNext())
{
Object omem = itr.Current;
if (omem is IBetaMemory)
{
IBetaMemory bmem = (IBetaMemory) omem;
// iterate over the matches
if (bmem.matchCount() == 0)
{
node.assertFacts(bmem.Index, engine, mem);
}
}
}
}
}
protected internal virtual void attachTerminalNode(BaseNode last, TerminalNode terminal)
{
if (last != null && terminal != null)
{
try
{
if (last is BaseJoin)
{
((BaseJoin) last).addSuccessorNode(terminal, engine, memory);
}
else if (last is BaseAlpha)
{
((BaseAlpha) last).addSuccessorNode(terminal, engine, memory);
}
}
catch (AssertException e)
{
}
}
}
/// <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>
/// it's unlikely 2 rules are identical, except for the name. The implementation
/// gets the current memory and propogates, but I wonder how much sense this
/// makes in a real production environment. An user really shouldn't be deploying
/// identical rules with different rule name.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="engine">The engine.</param>
/// <param name="mem">The mem.</param>
public virtual void addSuccessorNode(TerminalNode 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.Values.GetEnumerator();
while (itr.MoveNext())
{
Object omem = itr.Current;
if (omem is IBetaMemory)
{
IBetaMemory bmem = (IBetaMemory) omem;
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;
// merge the left and right fact into a new Array
node.assertFacts(left.add(rfcts), engine, mem);
}
}
}
}
}