org.apache.activemq.artemis.selector.filter.ArithmeticExpression Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.activemq.artemis.selector.filter;
/**
* An expression which performs an operation on two expression values
*
* @version $Revision: 1.2 $
*/
public abstract class ArithmeticExpression extends BinaryExpression
{
protected static final int INTEGER = 1;
protected static final int LONG = 2;
protected static final int DOUBLE = 3;
boolean convertStringExpressions = false;
/**
* @param left
* @param right
*/
public ArithmeticExpression(Expression left, Expression right)
{
super(left, right);
convertStringExpressions = ComparisonExpression.CONVERT_STRING_EXPRESSIONS.get() != null;
}
public static Expression createPlus(Expression left, Expression right)
{
return new ArithmeticExpression(left, right)
{
protected Object evaluate(Object lvalue, Object rvalue)
{
if (lvalue instanceof String)
{
String text = (String) lvalue;
String answer = text + rvalue;
return answer;
}
else
{
return plus(asNumber(lvalue), asNumber(rvalue));
}
}
public String getExpressionSymbol()
{
return "+";
}
};
}
public static Expression createMinus(Expression left, Expression right)
{
return new ArithmeticExpression(left, right)
{
protected Object evaluate(Object lvalue, Object rvalue)
{
return minus(asNumber(lvalue), asNumber(rvalue));
}
public String getExpressionSymbol()
{
return "-";
}
};
}
public static Expression createMultiply(Expression left, Expression right)
{
return new ArithmeticExpression(left, right)
{
protected Object evaluate(Object lvalue, Object rvalue)
{
return multiply(asNumber(lvalue), asNumber(rvalue));
}
public String getExpressionSymbol()
{
return "*";
}
};
}
public static Expression createDivide(Expression left, Expression right)
{
return new ArithmeticExpression(left, right)
{
protected Object evaluate(Object lvalue, Object rvalue)
{
return divide(asNumber(lvalue), asNumber(rvalue));
}
public String getExpressionSymbol()
{
return "/";
}
};
}
public static Expression createMod(Expression left, Expression right)
{
return new ArithmeticExpression(left, right)
{
protected Object evaluate(Object lvalue, Object rvalue)
{
return mod(asNumber(lvalue), asNumber(rvalue));
}
public String getExpressionSymbol()
{
return "%";
}
};
}
protected Number plus(Number left, Number right)
{
switch (numberType(left, right))
{
case INTEGER:
return new Integer(left.intValue() + right.intValue());
case LONG:
return new Long(left.longValue() + right.longValue());
default:
return new Double(left.doubleValue() + right.doubleValue());
}
}
protected Number minus(Number left, Number right)
{
switch (numberType(left, right))
{
case INTEGER:
return new Integer(left.intValue() - right.intValue());
case LONG:
return new Long(left.longValue() - right.longValue());
default:
return new Double(left.doubleValue() - right.doubleValue());
}
}
protected Number multiply(Number left, Number right)
{
switch (numberType(left, right))
{
case INTEGER:
return new Integer(left.intValue() * right.intValue());
case LONG:
return new Long(left.longValue() * right.longValue());
default:
return new Double(left.doubleValue() * right.doubleValue());
}
}
protected Number divide(Number left, Number right)
{
return new Double(left.doubleValue() / right.doubleValue());
}
protected Number mod(Number left, Number right)
{
return new Double(left.doubleValue() % right.doubleValue());
}
private int numberType(Number left, Number right)
{
if (isDouble(left) || isDouble(right))
{
return DOUBLE;
}
else if (left instanceof Long || right instanceof Long)
{
return LONG;
}
else
{
return INTEGER;
}
}
private boolean isDouble(Number n)
{
return n instanceof Float || n instanceof Double;
}
protected Number asNumber(Object value)
{
if (value instanceof Number)
{
return (Number) value;
}
else
{
if (convertStringExpressions && value instanceof String)
{
String v = (String) value;
try
{
if (v.contains("."))
{
return new Double(v);
}
else
{
return new Long(v);
}
}
catch (NumberFormatException e)
{
throw new RuntimeException("Cannot convert value: " + value + " into a number");
}
}
throw new RuntimeException("Cannot convert value: " + value + " into a number");
}
}
public Object evaluate(Filterable message) throws FilterException
{
Object lvalue = left.evaluate(message);
if (lvalue == null)
{
return null;
}
Object rvalue = right.evaluate(message);
if (rvalue == null)
{
return null;
}
return evaluate(lvalue, rvalue);
}
/**
* @param lvalue
* @param rvalue
* @return
*/
protected abstract Object evaluate(Object lvalue, Object rvalue);
}