public virtual void PropagateAssert(IExecutionContext context, List <Fact> facts)
{
var toAssert = new List <Fact>();
using (var counter = PerfCounter.Assert(context, this))
{
foreach (var fact in facts)
{
if (IsSatisfiedBy(context, fact))
{
toAssert.Add(fact);
}
}
counter.AddInputs(facts.Count);
counter.AddOutputs(toAssert.Count);
}
if (toAssert.Count > 0)
{
foreach (var childNode in ChildNodes)
{
childNode.PropagateAssert(context, toAssert);
}
MemoryNode?.PropagateAssert(context, toAssert);
}
}
public void PropagateAssert(IExecutionContext context, TupleFactList tupleFactList)
{
if (tupleFactList.Count == 0)
{
return;
}
IBetaMemory memory = context.WorkingMemory.GetNodeMemory(this);
var toAssert = new List <Tuple>();
using (var counter = PerfCounter.Assert(context, this))
{
var enumerator = tupleFactList.GetEnumerator();
while (enumerator.MoveNext())
{
var childTuple = new Tuple(context.IdGenerator.NextTupleId(), enumerator.CurrentTuple,
enumerator.CurrentFact);
childTuple.GroupId = enumerator.CurrentTuple.Id;
toAssert.Add(childTuple);
}
counter.AddItems(tupleFactList.Count);
}
PropagateAssertInternal(context, memory, toAssert);
}
public override void PropagateAssert(IExecutionContext context, List <Fact> facts)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var aggregation = new Aggregation();
using (var counter = PerfCounter.Assert(context, this))
{
var joinedSets = JoinedSets(context, facts);
foreach (var set in joinedSets)
{
if (set.Facts.Count == 0)
{
continue;
}
IFactAggregator aggregator = GetFactAggregator(context, set.Tuple);
if (aggregator == null)
{
aggregator = CreateFactAggregator(context, set.Tuple);
var originalSet = JoinedSet(context, set.Tuple);
var matchingOriginalFacts = originalSet.Facts;
AddToAggregate(aggregationContext, aggregator, aggregation, originalSet.Tuple, matchingOriginalFacts);
}
AddToAggregate(aggregationContext, aggregator, aggregation, set.Tuple, set.Facts);
}
counter.AddInputs(facts.Count);
counter.AddOutputs(aggregation.Count);
}
PropagateAggregation(context, aggregation);
}
public void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
using var counter = PerfCounter.Assert(context, this);
foreach (var tuple in tuples)
{
var activation = new Activation(CompiledRule, tuple);
context.WorkingMemory.SetState(this, tuple, activation);
context.Agenda.Add(activation);
context.EventAggregator.RaiseActivationCreated(context.Session, activation);
}
counter.AddItems(tuples.Count);
}
public override void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
var toAssert = new TupleFactList();
using (var counter = PerfCounter.Assert(context, this))
{
foreach (var tuple in tuples)
{
AssertBinding(context, tuple, toAssert);
}
counter.AddItems(tuples.Count);
}
MemoryNode.PropagateAssert(context, toAssert);
}
private void PropagateAssertInternal(IExecutionContext context, IBetaMemory memory, List <Tuple> tuples)
{
if (tuples.Count > 0)
{
for (int i = 0; i < _sinks.Count; i++)
{
_sinks[i].PropagateAssert(context, tuples);
}
using (var counter = PerfCounter.Assert(context, this))
{
memory.Add(tuples);
counter.SetCount(memory.TupleCount);
}
}
}
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 void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
var toAssert = new List <Fact>(tuples.Count);
using (var counter = PerfCounter.Assert(context, this))
{
foreach (var tuple in tuples)
{
var wrapperFact = new WrapperFact(tuple);
context.WorkingMemory.SetState(this, tuple, wrapperFact);
toAssert.Add(wrapperFact);
}
counter.AddItems(tuples.Count);
}
foreach (var sink in _sinks)
{
sink.PropagateAssert(context, toAssert);
}
}
public override void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var aggregation = new Aggregation();
using (var counter = PerfCounter.Assert(context, this))
{
var joinedSets = JoinedSets(context, tuples);
foreach (var set in joinedSets)
{
IFactAggregator aggregator = CreateFactAggregator(context, set.Tuple);
AddToAggregate(aggregationContext, aggregator, aggregation, set.Tuple, set.Facts);
}
counter.AddInputs(tuples.Count);
counter.AddOutputs(aggregation.Count);
}
PropagateAggregation(context, aggregation);
}
public override void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
var toAssert = new TupleFactList();
using (var counter = PerfCounter.Assert(context, this))
{
var joinedSets = JoinedSets(context, tuples);
foreach (var set in joinedSets)
{
var quantifier = context.CreateQuantifier(this, set.Tuple);
quantifier.Value += set.Facts.Count;
if (quantifier.Value > 0)
{
toAssert.Add(set.Tuple, null);
}
}
counter.AddInputs(tuples.Count);
counter.AddOutputs(toAssert.Count);
}
MemoryNode.PropagateAssert(context, toAssert);
}
public override void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
var toAssert = new TupleFactList();
using (var counter = PerfCounter.Assert(context, this))
{
var joinedSets = JoinedSets(context, tuples);
foreach (var set in joinedSets)
{
foreach (var fact in set.Facts)
{
if (MatchesConditions(context, set.Tuple, fact))
{
toAssert.Add(set.Tuple, fact);
}
}
}
counter.AddInputs(tuples.Count);
counter.AddOutputs(toAssert.Count);
}
MemoryNode.PropagateAssert(context, toAssert);
}
public override void PropagateAssert(IExecutionContext context, List <Fact> facts)
{
var toRetract = new TupleFactList();
using (var counter = PerfCounter.Assert(context, this))
{
var joinedSets = JoinedSets(context, facts);
foreach (var set in joinedSets)
{
var quantifier = context.GetQuantifier(this, set.Tuple);
int startingCount = quantifier.Value;
quantifier.Value += set.Facts.Count;
if (startingCount == 0 && quantifier.Value > 0)
{
toRetract.Add(set.Tuple, null);
}
}
counter.AddInputs(facts.Count);
counter.AddOutputs(toRetract.Count);
}
MemoryNode.PropagateRetract(context, toRetract);
}
