private ExpressionTree AssociateElements(ExpressionElement[] elements, int elementCount)
{
if(elementCount == 2) {
throw new Exception("Invalid expression element count");
}
// handle special case
if(elementCount == 1) {
if(elements[0].Type == ElementType.Implication) {
return null;
}
else if(elements[0].Type == ElementType.Tree) {
return (ExpressionTree)elements[0].Element;
}
else {
ExpressionTree tree = new ExpressionTree();
tree.Root = new FilterNode((FilterBase)elements[0].Element);
return tree;
}
}
// normal case
// middle element should be an Implication
if(elements[1].Type != ElementType.Implication) {
return null;
}
ExpressionTree parent = new ExpressionTree();
ExpressionElement left = elements[0];
ExpressionElement right = elements[2];
FilterImplication implication = (FilterImplication)elements[1].Element;
// build the tree
if(left.Type == ElementType.Tree && right.Type == ElementType.Filter) {
parent = ExpressionTreeBuilder.AssociateTreeWithFilter((ExpressionTree)left.Element,
(FilterBase)right.Element,
implication, TreeDirection.Left);
}
else if(left.Type == ElementType.Filter && right.Type == ElementType.Tree) {
parent = ExpressionTreeBuilder.AssociateTreeWithFilter((ExpressionTree)right.Element,
(FilterBase)left.Element,
implication, TreeDirection.Right);
}
else if(left.Type == ElementType.Tree && right.Type == ElementType.Tree) {
parent = ExpressionTreeBuilder.AssociateTrees((ExpressionTree)left.Element,
(ExpressionTree)right.Element,
implication);
}
else if(left.Type == ElementType.Filter && right.Type == ElementType.Filter) {
parent = ExpressionTreeBuilder.AssociateFilters((FilterBase)left.Element,
(FilterBase)right.Element,
implication);
}
return parent;
}