/// <summary>
/// Combines with expressionValue
/// </summary>
/// <param name="item">Right hand side</param>
/// <param name="op">Operator</param>
/// <returns>Resulting expression</returns>
public override ExpressionValue Combine(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCombine(expressionValue, op))
{
// Convert to correct expresion type
ExpressionInt expression = null;
if (expressionValue.Type == typeof(int))
{
expression = expressionValue as ExpressionInt;
}
else if (expressionValue.Type == typeof(double))
{
expression = expressionValue as ExpressionDouble;
}
else
{
throw new NotImplementedException();
}
AddToChain(expression.GetExpression(), op);
UsedWidgetIDs = CombineWidgets(expressionValue);
return(this);
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(Type, expressionValue.Type, op));
}
public override ExpressionValue Combine(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCombine(expressionValue, op))
{
ExpressionDouble expression;
switch (expressionValue.ExpressionType)
{
case ExpressionType.Int:
// Double has more precision, convert int to double (implicit)
expression = expressionValue as ExpressionInt;
break;
case ExpressionType.Double:
expression = expressionValue as ExpressionDouble;
break;
default:
throw new NotImplementedException();
}
AddToChain(expression.GetExpression(), op);
UsedIdentifiers = CombineElements(expressionValue);
return(this);
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(ExpressionType, expressionValue.ExpressionType, op));
}
public override ExpressionValue Combine(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCombine(expressionValue, op))
{
// Convert to correct expresion type
switch (expressionValue.ExpressionType)
{
case ExpressionType.Int:
// Combine the two integers
ExpressionInt expression = expressionValue as ExpressionInt;
AddToChain(expression.GetExpression(), op);
UsedIdentifiers = CombineElements(expressionValue);
return(this);
case ExpressionType.Double:
// Convert to double to continue combination
return(ToDoubleExpression().Combine(expressionValue, op));
default:
throw new NotImplementedException();
}
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(ExpressionType, expressionValue.ExpressionType, op));
}
/// <summary>
/// Combines two boolean expressions
/// </summary>
/// <param name="item1">Left hand side</param>
/// <param name="item2">Right hand side</param>
/// <param name="op">Operator</param>
/// <returns>Resulting delegate</returns>
protected override Func <bool> CombineExpressions(Func <bool> item1, Func <bool> item2, ExpressionOperator op)
{
switch (op)
{
case ExpressionOperator.And:
return(() => item1() && item2());
case ExpressionOperator.Or:
return(() => item1() || item2());
case ExpressionOperator.Equals:
return(() => item1() == item2());
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(Type, Type, op));
}
public override ExpressionValue Combine(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCombine(expressionValue, op))
{
switch (expressionValue)
{
case ExpressionText expressionText:
AddToChain(expressionText.GetExpression(), op);
UsedIdentifiers = CombineElements(expressionText);
return(this);
default:
throw new NotImplementedException();
}
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(ExpressionType, expressionValue.ExpressionType, op));
}
protected override Func <double> CombineExpressions(Func <double> item1, Func <double> item2, ExpressionOperator op)
{
switch (op)
{
case ExpressionOperator.Plus:
return(() => item1() + item2());
case ExpressionOperator.Minus:
return(() => item1() - item2());
case ExpressionOperator.Multiply:
return(() => item1() * item2());
case ExpressionOperator.Divide:
return(() => item1() / item2());
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(ExpressionType, ExpressionType, op));
}
/// <summary>
/// Combines with expressionValue
/// </summary>
/// <param name="item">Right hand side</param>
/// <param name="op">Operator</param>
/// <returns>Resulting expression</returns>
public override ExpressionValue Combine(ExpressionValue item, ExpressionOperator op)
{
if (ValidCombine(item, op))
{
ExpressionBool expression = null;
if (item.Type == typeof(bool))
{
expression = item as ExpressionBool;
}
else
{
throw new NotImplementedException();
}
AddToChain(expression.GetExpression(), op);
UsedWidgetIDs = CombineWidgets(item);
return(this);
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(Type, item.Type, op));
}
public override ExpressionValue Combine(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCombine(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.ExceptionNoCombination(ExpressionType, expressionValue.ExpressionType, op));
}
public override ExpressionValue Combine(ExpressionValue expressionValue, ExpressionOperator op)
{
if (ValidCombine(expressionValue, op))
{
switch (expressionValue.ExpressionType)
{
case ExpressionType.Hex:
ExpressionHex expression = expressionValue as ExpressionHex;
AddToChain(expression.GetExpression(), op);
UsedIdentifiers = CombineElements(expression);
return(this);
case ExpressionType.Int:
return(ToIntExpression().Combine(expressionValue, op));
case ExpressionType.Double:
return(ToDoubleExpression().Combine(expressionValue, op));
default:
throw new NotImplementedException();
}
}
throw new InvalidOperationException(UserMessages.ExceptionNoCombination(ExpressionType, expressionValue.ExpressionType, op));
}
