public override void addActivation(IActivation act)
{
if (act is LinkedActivation)
{
LinkedActivation newact = (LinkedActivation) act;
if (lazy)
{
if (count == 0)
{
first = newact;
last = newact;
}
else
{
last.Next = newact;
last = newact;
}
count++;
}
else
{
if (count > 0)
{
quickSort(newact);
}
else if (count == 0)
{
first = newact;
last = newact;
}
count++;
}
}
}
/// <param name="">facts
/// </param>
/// <param name="">engine
///
/// </param>
public override void assertFacts(Index inx, Rete engine, IWorkingMemory mem)
{
long time = (DateTime.Now.Ticks - 621355968000000000)/10000;
if (theRule.ExpirationDate > 0 && time > theRule.EffectiveDate && time < theRule.ExpirationDate)
{
LinkedActivation act = new LinkedActivation(theRule, inx);
act.TerminalNode = this;
// fire the activation immediately
engine.fireActivation(act);
}
}
/// <summary> The implementation checks to see if the rule is active before it tries to
/// assert the fact. It checks in the following order.
/// 1. is the expiration date greater than zero
/// 2. is the current time > the effective date
/// 3. is the current time the expiration date
/// </summary>
/// <param name="">facts
/// </param>
/// <param name="">engine
///
/// </param>
public override void assertFacts(Index inx, Rete engine, IWorkingMemory mem)
{
long time = (DateTime.Now.Ticks - 621355968000000000)/10000;
if (theRule.ExpirationDate > 0 && time > theRule.EffectiveDate && time < theRule.ExpirationDate)
{
LinkedActivation act = new LinkedActivation(theRule, inx);
act.TerminalNode = this;
IGenericMap<Object, Object> tmem = (IGenericMap<Object, Object>) mem.getTerminalMemory(this);
tmem.Put(act.Index, act);
// Add the activation to the current module's activation list.
engine.Agenda.addActivation(act);
}
}
/// <summary> Method will call checkFacts() first to make sure none of the facts have
/// expired. An activation is only created if the facts are valid.
/// </summary>
/// <param name="">facts
/// </param>
/// <param name="">engine
///
/// </param>
public override void assertFacts(Index inx, Rete engine, IWorkingMemory mem)
{
// first check the facts and make sure they didn't expire
if (checkFacts(inx, engine, mem))
{
LinkedActivation act = new LinkedActivation(theRule, inx);
act.TerminalNode = this;
if (temporal)
{
engine.fireActivation(act);
}
else
{
IGenericMap<Object, Object> tmem = (IGenericMap<Object, Object>) mem.getTerminalMemory(this);
tmem.Put(inx, act);
// Add the activation to the current module's activation list.
engine.Agenda.addActivation(act);
}
}
}
/// <summary>
/// method will loop for the given count and return the item before it.
/// for example:
/// 1
/// 2
/// 3
/// 4
/// 5
/// 6
/// If I pass a count of 2 and item #6. it will return #4.
/// </summary>
/// <param name="count">The count.</param>
/// <param name="start">The start.</param>
/// <returns></returns>
protected internal virtual LinkedActivation goUp(int count, LinkedActivation start)
{
LinkedActivation rt = start;
for (int idx = 0; idx < count; idx++)
{
rt = rt.Previous;
}
return rt;
}
/// <summary>
/// method will loop for the given count and return the item after it.
/// for example:
/// 1
/// 2
/// 3
/// 4
/// 5
/// 6
/// If I pass a count of 2 and item #1. it will return #3.
/// </summary>
/// <param name="count">The count.</param>
/// <param name="start">The start.</param>
/// <returns></returns>
protected internal virtual LinkedActivation goDown(int count, LinkedActivation start)
{
LinkedActivation rt = start;
for (int idx = 0; idx < count; idx++)
{
rt = rt.Next;
}
return rt;
}
/// <summary> removeActivation will check to see if the activation is
/// the first or last before removing it.
/// </summary>
public override IActivation removeActivation(IActivation act)
{
if (act is LinkedActivation)
{
LinkedActivation lact = (LinkedActivation) act;
if (first == lact)
{
first = lact.Next;
}
if (last == lact)
{
last = lact.Previous;
}
count--;
lact.remove();
}
return act;
}
/// <summary>
/// the sort method uses binary search to find the correct insertion
/// point for the new activation. It's much faster than the brute
/// force method.
/// </summary>
/// <param name="newact">The newact.</param>
public virtual void quickSort(LinkedActivation newact)
{
if (stratey.compare(newact, last) >= 0)
{
// the new activation has a higher salience than the last, which means
// it should become the bottom activation
last.Next = newact;
last = newact;
}
else if (stratey.compare(newact, first) < 0)
{
// the new activation has a salience lower than the first, which means
// it should become the top activation
newact.Next = first;
first = newact;
}
else
{
// this means the new activation goes in the middle some where
int counter = count/2;
LinkedActivation cur = goUp(counter, last);
bool added = false;
while (!added)
{
if (counter <= 1)
{
// Add the activation
if (stratey.compare(newact, cur) < 0)
{
// if the new activation is lower sailence than the current,
// we Add it before the current (aka above)
newact.Previous = cur.Previous;
newact.Next = cur;
}
else
{
// the new activation is higher salience than the current
// therefore we Add it after (aka below)
newact.Next = cur.Next;
newact.Previous = cur;
}
added = true;
}
else if (stratey.compare(newact, cur) >= 0)
{
// the new activation is of greater salience down half again
counter = counter/2;
cur = goDown(counter, cur);
}
else
{
// the new activation is of lower salience, up half again
counter = counter/2;
cur = goUp(counter, cur);
}
}
}
}
public override IActivation nextActivation()
{
if (lazy)
{
if (count == 0)
{
return null;
}
else
{
LinkedActivation left = last;
LinkedActivation right = last.Previous;
while (right != null)
{
if (stratey.compare(left, right) < 1)
{
left = right;
}
right = right.Previous;
}
if (left == first)
{
first = left.Next;
}
else if (left == last)
{
last = left.Previous;
}
left.remove();
count--;
return left;
}
}
else
{
if (count > 1)
{
LinkedActivation r = last;
last = r.Previous;
count--;
r.remove();
return r;
}
else if (count == 1)
{
LinkedActivation r = last;
last = null;
first = null;
count--;
return r;
}
else
{
return null;
}
}
}
/// <summary> Iterate over the Creshendo.rete.util.LinkedList and null the references to previous
/// and Current in the LinkedActivation
/// </summary>
public override void clear()
{
while (first != null)
{
LinkedActivation la = first;
first = la.Next;
la.remove();
}
last = null;
count = 0;
}