private void BuildJoinNode(ReteBuilderContext context, List <ExpressionElement> conditions = null)
{
var expressionElements = conditions ?? new List <ExpressionElement>();
var node = context.BetaSource
.Sinks.OfType <JoinNode>()
.FirstOrDefault(x =>
x.RightSource == context.AlphaSource &&
x.LeftSource == context.BetaSource &&
ExpressionElementComparer.AreEqual(
x.Declarations, x.ExpressionElements,
context.Declarations, expressionElements));
if (node == null)
{
var compiledExpressions = new List <ILhsExpression <bool> >(expressionElements.Count);
foreach (var expressionElement in expressionElements)
{
var compiledExpression = _ruleExpressionCompiler.CompileLhsExpression <bool>(expressionElement, context.Declarations);
compiledExpressions.Add(compiledExpression);
}
node = new JoinNode(context.BetaSource, context.AlphaSource, context.Declarations.ToList(), expressionElements, compiledExpressions, context.HasSubnet);
node.Id = GetNodeId();
}
node.NodeInfo.Add(context.Rule);
BuildBetaMemoryNode(context, node);
context.ResetAlphaSource();
}
private static void AssertNotEqual(List <Declaration> declarationsFirst, IEnumerable <NamedExpressionElement> first, List <Declaration> declarationsSecond, IEnumerable <NamedExpressionElement> second)
{
//Act
bool result = ExpressionElementComparer.AreEqual(declarationsFirst, first, declarationsSecond, second);
//Assert
Assert.False(result);
}
private static void AssertNotEqual(NamedExpressionElement first, NamedExpressionElement second)
{
//Act
bool result = ExpressionElementComparer.AreEqual(first, second);
//Assert
Assert.False(result);
}
private void BuildSelectionNode(ReteBuilderContext context, ExpressionElement element)
{
SelectionNode node = context.CurrentAlphaNode
.ChildNodes.OfType <SelectionNode>()
.FirstOrDefault(sn => ExpressionElementComparer.AreEqual(sn.ExpressionElement, element));
if (node == null)
{
var compiledExpression = ExpressionCompiler.CompileLhsFactExpression <bool>(element);
node = new SelectionNode(element, compiledExpression);
context.CurrentAlphaNode.ChildNodes.Add(node);
}
node.NodeInfo.Add(context.Rule, element);
context.CurrentAlphaNode = node;
}
private void BuildBindingNode(ReteBuilderContext context, BindingElement element)
{
var node = context.BetaSource
.Sinks.OfType <BindingNode>()
.FirstOrDefault(x =>
ExpressionElementComparer.AreEqual(x.ExpressionElement, element));
if (node == null)
{
var compiledExpression = ExpressionCompiler.CompileLhsTupleExpression <object>(element, context.Declarations);
node = new BindingNode(element, compiledExpression, element.ResultType, context.BetaSource);
}
node.NodeInfo.Add(context.Rule, element);
BuildBetaMemoryNode(context, node);
context.ResetAlphaSource();
}
private void BuildAggregateNode(ReteBuilderContext context, AggregateElement element)
{
var node = context.AlphaSource
.Sinks.OfType <AggregateNode>()
.FirstOrDefault(x =>
x.RightSource == context.AlphaSource &&
x.LeftSource == context.BetaSource &&
x.Name == element.Name &&
ExpressionElementComparer.AreEqual(x.Expressions, element.Expressions));
if (node == null)
{
var aggregatorFactory = BuildAggregatorFactory(context, element);
node = new AggregateNode(context.BetaSource, context.AlphaSource, element.Name,
element.Expressions, aggregatorFactory, context.HasSubnet);
}
node.NodeInfo.Add(context.Rule, element);
BuildBetaMemoryNode(context, node);
context.ResetAlphaSource();
}