public bool FindAndReplace(ExpressionTreeElement findElement, ExpressionTreeElement replaceElement)
{
if (Root.Equals(findElement) &&
replaceElement is ExpressionTreeNode)
{
Root = replaceElement as ExpressionTreeNode;
return(true);
}
var expression = Root.Find(findElement.Parent) as BooleanOperatorNode;
if (expression != null)
{
if (expression.Left != null &&
expression.Left.Equals(findElement))
{
expression.Left = replaceElement;
}
else if (expression.Right != null &&
expression.Right.Equals(findElement))
{
expression.Right = replaceElement;
}
else
{
return(false);
}
return(true);
}
return(false);
}
/// <summary>
/// Find element in expression tree
/// </summary>
/// <param name="element">Required element</param>
/// <returns>Required element in expression tree</returns>
public override ExpressionTreeElement Find(ExpressionTreeElement element)
{
if (element == null)
{
return(null);
}
if (element.ToString() == ToString())
{
return(this);
}
if (Left != null)
{
var leftFind = Left.Find(element);
if (leftFind != null)
{
return(leftFind);
}
}
if (Right == null)
{
return(null);
}
var rightFind = Right.Find(element);
return(rightFind);
}
/// <summary>
/// Find element in expression tree
/// </summary>
/// <param name="element">Required element</param>
/// <returns>Required element in expression tree</returns>
public override ExpressionTreeElement Find(ExpressionTreeElement element)
{
if (element != null &&
element.ToString() == ToString())
{
return(this);
}
return(null);
}
public BooleanOperatorNode(ExpressionTreeNode parent, ExpressionTreeElement left, ExpressionTreeElement right, BooleanOperators boolOp)
: base(parent, left, right)
{
Operator = boolOp;
}
protected ExpressionTreeNode(ExpressionTreeNode parent, ExpressionTreeElement left, ExpressionTreeElement right)
: base(parent)
{
Left = left;
Right = right;
}
/// <summary>
/// Constructor with comparison expression node
/// </summary>
/// <param name="compOp">Comparison operator</param>
/// <param name="left">Left operand (child)</param>
/// <param name="right">Right operand (child)</param>
public ExpressionTree(ComparisonOperators compOp, ExpressionTreeElement left, ExpressionTreeElement right)
: this(compOp)
{
Root.Left = left;
Root.Right = right;
}
/// <summary>
/// Constructor with logical expression node
/// </summary>
/// <param name="boolOp">Logical operator</param>
/// <param name="left">Left operand (child)</param>
/// <param name="right">Right operand (child)</param>
public ExpressionTree(BooleanOperators boolOp, ExpressionTreeElement left, ExpressionTreeElement right)
: this(boolOp)
{
Root.Left = left;
Root.Right = right;
}
/// <summary>
/// Find element in expression tree
/// </summary>
/// <param name="element">Required element</param>
/// <returns>Required element in expression tree</returns>
public ExpressionTreeElement Find(ExpressionTreeElement element)
{
return(Root.Find(element));
}
/// <summary> /// Find element in expression tree /// </summary> /// <param name="element">Required element</param> /// <returns>Required element in expression tree</returns> public abstract ExpressionTreeElement Find(ExpressionTreeElement element);
public ComparisonOperatorNode(ExpressionTreeNode parent, ExpressionTreeElement left, ExpressionTreeElement right, ComparisonOperators compOp)
: base(parent, left, right)
{
Operator = compOp;
}
