/// <summary> /// Does the OR calculation to generate a list of AND groups of /// operands. /// </summary> /// <param name="startingOpNode"></param> /// <param name="isNot"></param> /// <returns></returns> private List <List <Operand> > OrOperation(BoolExprTreeNode startingOpNode, bool isNot) { if (null == startingOpNode) { throw new ArgumentNullException($"{nameof(startingOpNode)}"); } if (startingOpNode.IsLeaf()) { throw new BoolExprTreeException("The specified starting node doesn't have 2 children."); } if (startingOpNode.Operator == BoolExprTreeNode.BoolOperator.NOT) { throw new BoolExprTreeException("The specified starting node is a unary operator node."); } var left = ConvertToOrGroups(startingOpNode.Left, isNot); var right = ConvertToOrGroups(startingOpNode.Right, isNot); if (null == left || null == right) { throw new BoolExprTreeException("The specified Binary Boolean Expression Tree is not valid."); } left.AddRange(right); return(left); }
/// <summary> /// Deeply copies the subtree starting from the specified node. /// </summary> /// <param name="other"></param> public BoolExprTreeNode(BoolExprTreeNode other) { _op = other._op; _left = other._left == null ? null : new BoolExprTreeNode(other._left); _right = other._right == null ? null : new BoolExprTreeNode(other._right); _literal = new StringBuilder(other._literal).ToString(); }
/// <summary> /// Builds the Binary Boolean Expression Tree. /// </summary> /// <param name="polishNotationTokensEnumerator"></param> /// <returns></returns> public BoolExprTreeNode GenerateBoolBinTree(ref List <Token> .Enumerator polishNotationTokensEnumerator) { if (polishNotationTokensEnumerator.Current.Type == Token.TokenType.LITERAL) { var literalNode = BoolExprTreeNode.CreateBoolVar(polishNotationTokensEnumerator.Current.Value); polishNotationTokensEnumerator.MoveNext(); return(literalNode); } else { if (polishNotationTokensEnumerator.Current.Value == "NOT") { polishNotationTokensEnumerator.MoveNext(); var operand = GenerateBoolBinTree(ref polishNotationTokensEnumerator); return(BoolExprTreeNode.CreateNotOpNode(operand)); } else if (polishNotationTokensEnumerator.Current.Value == "AND") { polishNotationTokensEnumerator.MoveNext(); var leftNode = GenerateBoolBinTree(ref polishNotationTokensEnumerator); var rightNode = GenerateBoolBinTree(ref polishNotationTokensEnumerator); return(BoolExprTreeNode.CreateAndOpNode(leftNode, rightNode)); } else if (polishNotationTokensEnumerator.Current.Value == "OR") { polishNotationTokensEnumerator.MoveNext(); var leftNode = GenerateBoolBinTree(ref polishNotationTokensEnumerator); var rightNode = GenerateBoolBinTree(ref polishNotationTokensEnumerator); return(BoolExprTreeNode.CreateOrOpNode(leftNode, rightNode)); } } return(null); }
private BoolExprTreeNode(string literal) { _op = BoolOperator.LEAF; _left = null; _right = null; _literal = literal; }
// // Private constructors // private BoolExprTreeNode(BoolOperator op, BoolExprTreeNode left, BoolExprTreeNode right) { _op = op; _left = left; _right = right; _literal = null; }
public void Dispose() { _op = BoolOperator.LEAF; _left = null; _right = null; _literal = null; }
/// <summary> /// Traverse the Binary Boolean Expression Tree from the given starting /// node, in order to generate a list of OR groups of operands. /// </summary> /// <param name="boolExprTreeNode"></param> /// <param name="isNot"></param> /// <returns></returns> public List <List <Operand> > ConvertToOrGroups(BoolExprTreeNode boolExprTreeNode, bool isNot = false) { if (null != boolExprTreeNode) { if (boolExprTreeNode.IsLeaf()) { return(new List <List <Operand> >() { new List <Operand>() { new Operand(boolExprTreeNode.Literal, isNot) } }); } else { if (boolExprTreeNode.Operator == BoolExprTreeNode.BoolOperator.OR) { if (isNot) { return(AndOperation(boolExprTreeNode, isNot)); } else { return(OrOperation(boolExprTreeNode, isNot)); } } if (boolExprTreeNode.Operator == BoolExprTreeNode.BoolOperator.AND) { var left = ConvertToOrGroups(boolExprTreeNode.Left); var right = ConvertToOrGroups(boolExprTreeNode.Right); if (isNot) { return(OrOperation(boolExprTreeNode, isNot)); } else { return(AndOperation(boolExprTreeNode, isNot)); } } if (boolExprTreeNode.Operator == BoolExprTreeNode.BoolOperator.NOT) { if (null != boolExprTreeNode.Right || null == boolExprTreeNode.Left) { throw new BoolExprTreeException("The specified Binary Boolean Expression Tree is not valid."); } return(ConvertToOrGroups(boolExprTreeNode.Left, true)); } } } return(null); }
/// <summary> /// Does the AND calculation to generate a list of AND groups of /// operands. /// </summary> /// <param name="startingOpNode"></param> /// <param name="isNot"></param> /// <returns></returns> private List <List <Operand> > AndOperation(BoolExprTreeNode startingOpNode, bool isNot) { if (null == startingOpNode) { throw new ArgumentNullException($"{nameof(startingOpNode)}"); } if (startingOpNode.IsLeaf()) { throw new BoolExprTreeException("The specified starting node doesn't have 2 children."); } if (startingOpNode.Operator == BoolExprTreeNode.BoolOperator.NOT) { throw new BoolExprTreeException("The specified starting node is a unary operator node."); } var left = ConvertToOrGroups(startingOpNode.Left, isNot); var right = ConvertToOrGroups(startingOpNode.Right, isNot); if (null == left || null == right) { throw new BoolExprTreeException("The specified Binary Boolean Expression Tree is not valid."); } var combinations = (from l in left from r in right select new { l, r }).ToList(); var results = new List <List <Operand> >(); combinations.ForEach(combination => { var result = new List <Operand>(combination.l); var newRight = new List <Operand>(combination.r); result.AddRange(newRight); results.Add(result); }); return(results); }
public static BoolExprTreeNode CreateOrOpNode(BoolExprTreeNode left, BoolExprTreeNode right) { return(new BoolExprTreeNode(BoolOperator.OR, left, right)); }
public static BoolExprTreeNode CreateNotOpNode(BoolExprTreeNode child) { return(new BoolExprTreeNode(BoolOperator.NOT, child, null)); }