/// <summary>
/// Convert a List of Expression objects to a nested Expression containing OR between each Expression in the list.
/// </summary>
/// <param name="exprList">List of Expression objects.</param>
/// <returns>A nested Expression.</returns>
public static WrapperExpression ListToNestedOrExpression(List <WrapperExpression> exprList)
{
if (exprList == null)
{
throw new ArgumentNullException(nameof(exprList));
}
if (exprList.Count < 1)
{
return(null);
}
int evaluated = 0;
WrapperExpression ret = null;
WrapperExpression left = null;
List <WrapperExpression> remainder = new List <WrapperExpression>();
if (exprList.Count == 1)
{
foreach (WrapperExpression curr in exprList)
{
ret = curr;
break;
}
return(ret);
}
else
{
foreach (WrapperExpression curr in exprList)
{
if (evaluated == 0)
{
left = new WrapperExpression();
left.LeftTerm = curr.LeftTerm;
left.Operator = curr.Operator;
left.RightTerm = curr.RightTerm;
evaluated++;
}
else
{
remainder.Add(curr);
evaluated++;
}
}
ret = new WrapperExpression();
ret.LeftTerm = left;
ret.Operator = Operators.Or;
WrapperExpression right = ListToNestedOrExpression(remainder);
ret.RightTerm = right;
return(ret);
}
}
/// <summary>
/// Prepends the Expression with the supplied Expression using an OR clause.
/// </summary>
/// <param name="prepend">The Expression to prepend.</param>
public void PrependOr(WrapperExpression prepend)
{
if (prepend == null)
{
throw new ArgumentNullException(nameof(prepend));
}
WrapperExpression orig = new WrapperExpression(this.LeftTerm, this.Operator, this.RightTerm);
WrapperExpression e = PrependOrClause(prepend, orig);
LeftTerm = e.LeftTerm;
Operator = e.Operator;
RightTerm = e.RightTerm;
return;
}
/// <summary>
/// Prepends the Expression in prepend to the Expression original using an OR clause.
/// </summary>
/// <param name="prepend">The Expression to prepend.</param>
/// <param name="original">The original Expression.</param>
/// <returns>A new Expression.</returns>
public static WrapperExpression PrependOrClause(WrapperExpression prepend, WrapperExpression original)
{
if (prepend == null)
{
throw new ArgumentNullException(nameof(prepend));
}
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
WrapperExpression ret = new WrapperExpression
{
LeftTerm = prepend,
Operator = Operators.Or,
RightTerm = original
};
return(ret);
}
/// <summary>
/// Prepends a new Expression using the supplied left term, operator, and right term using an OR clause.
/// </summary>
/// <param name="left">The left term of the expression; can either be a string term or a nested Expression.</param>
/// <param name="oper">The operator.</param>
/// <param name="right">The right term of the expression; can either be an object for comparison or a nested Expression.</param>
public void PrependOr(object left, Operators oper, object right)
{
WrapperExpression e = new WrapperExpression(left, oper, right);
PrependOr(e);
}
