SecureDelete.FileSearch.ExpressionEvaluator.AssociateElements C# (CSharp) Method

        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;
        }