public static TypedExpressionValue <bool> Compare(IExpressionNumeric leftNumeric, IExpressionNumeric rightNumeric, ExpressionOperator op)
{
ExpressionDouble left = leftNumeric.ToDoubleExpression();
ExpressionDouble right = rightNumeric.ToDoubleExpression();
string[] elementIDs = left.UsedIdentifiers.Concat(right.UsedIdentifiers).Distinct().ToArray();
switch (op)
{
case ExpressionOperator.GreaterThan:
return(new ExpressionBool(elementIDs, () => { return left.Result > right.Result; }));
case ExpressionOperator.GreaterEquals:
return(new ExpressionBool(elementIDs, () => { return left.Result >= right.Result; }));
case ExpressionOperator.LessThan:
return(new ExpressionBool(elementIDs, () => { return left.Result < right.Result; }));
case ExpressionOperator.LessEquals:
return(new ExpressionBool(elementIDs, () => { return left.Result <= right.Result; }));
case ExpressionOperator.Equals:
return(new ExpressionBool(elementIDs, () => { return left.Result == right.Result; }));
}
throw new InvalidOperationException(UserMessages.ExceptionNoComparison(left.ExpressionType, right.ExpressionType, op));
}
/// <summary>
/// Compares with expression
/// </summary>
/// <param name="expressionValue">Expression to compare with</param>
/// <param name="op">Operator</param>
/// <returns>Boolean expression</returns>
public override TypedExpressionValue <bool> Compare(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCompare(expressionValue, op))
{
if (expressionValue.Type == typeof(bool))
{
AddToChain((expressionValue as ExpressionBool).GetExpression(), op);
UsedWidgetIDs = CombineWidgets(expressionValue);
return(this);
}
}
throw new InvalidOperationException(UserMessages.ExceptionNoComparison(Type, expressionValue.Type, op));
}
public override TypedExpressionValue <bool> Compare(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCompare(expressionValue, op))
{
switch (expressionValue)
{
case ExpressionText expressionText:
return(CompareWith(expressionText, op));
default:
throw new NotImplementedException();
}
}
throw new InvalidOperationException(UserMessages.ExceptionNoComparison(ExpressionType, expressionValue.ExpressionType, op));
}
public override TypedExpressionValue <bool> Compare(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCompare(expressionValue, op))
{
switch (expressionValue)
{
case IExpressionNumeric expressionNumeric:
return(NumericUtils.Compare(this, expressionNumeric, op));
default:
throw new NotImplementedException();
}
}
throw new InvalidOperationException(UserMessages.ExceptionNoComparison(ExpressionType, expressionValue.ExpressionType, op));
}
/// <summary>
/// Compares with expression
/// </summary>
/// <param name="expressionValue">Expression to compare with</param>
/// <param name="op">Operator</param>
/// <returns>Boolean expression</returns>
public override TypedExpressionValue <bool> Compare(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCompare(expressionValue, op))
{
if (expressionValue.Type == typeof(double))
{
return(CompareValue(expressionValue as TypedExpressionValue <double>, op));
}
else if (expressionValue.Type == typeof(int))
{
return(CompareValue(expressionValue as ExpressionInt, op)); // Uses implicit cast
}
}
throw new InvalidOperationException(UserMessages.ExceptionNoComparison(Type, expressionValue.Type, op));
}
/// <summary>
/// Compares expression with double expression
/// </summary>
/// <param name="item">double expression</param>
/// <param name="op">Compare operator</param>
/// <returns>Boolean expression</returns>
private TypedExpressionValue <bool> CompareValue(TypedExpressionValue <double> item, ExpressionOperator op)
{
switch (op)
{
case ExpressionOperator.GreaterThan:
return(new ExpressionBool(CombineWidgets(item), () => { return Result > item.Result; }));
case ExpressionOperator.GreaterEquals:
return(new ExpressionBool(CombineWidgets(item), () => { return Result >= item.Result; }));
case ExpressionOperator.LessThan:
return(new ExpressionBool(CombineWidgets(item), () => { return Result < item.Result; }));
case ExpressionOperator.LessEquals:
return(new ExpressionBool(CombineWidgets(item), () => { return Result <= item.Result; }));
case ExpressionOperator.Equals:
return(new ExpressionBool(CombineWidgets(item), () => { return Result == item.Result; }));
}
throw new InvalidOperationException(UserMessages.ExceptionNoComparison(Type, item.Type, op));
}
public override TypedExpressionValue <bool> Compare(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCompare(expressionValue, op))
{
ExpressionBool expression;
switch (expressionValue.ExpressionType)
{
case ExpressionType.Bool:
expression = expressionValue as ExpressionBool;
break;
default:
throw new NotImplementedException();
}
AddToChain(expression.GetExpression(), op);
UsedIdentifiers = CombineElements(expressionValue);
return(this);
}
throw new InvalidOperationException(UserMessages.ExceptionNoComparison(ExpressionType, expressionValue.ExpressionType, op));
}
