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