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