@Override
public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
SpelNodeImpl leftOp = getLeftOperand();
SpelNodeImpl rightOp = getRightOperand();
Object operandOne = leftOp.getValueInternal(state).getValue();
Object operandTwo = rightOp.getValueInternal(state).getValue();
if (operandOne instanceof Number && operandTwo instanceof Number) {
Number op1 = (Number) operandOne;
Number op2 = (Number) operandTwo;
if (op1 instanceof Double || op2 instanceof Double) {
return new TypedValue(Math.pow(op1.doubleValue(), op2.doubleValue()));
} else if (op1 instanceof Long || op2 instanceof Long) {
double d = Math.pow(op1.longValue(), op2.longValue());
return new TypedValue((long) d);
} else {
double d = Math.pow(op1.longValue(), op2.longValue());
if (d > Integer.MAX_VALUE) {
return new TypedValue((long) d);
} else {
return new TypedValue((int) d);
}
}
}
return state.operate(Operation.POWER, operandOne, operandTwo);
}
/**
* 获取shardKey所在的表名
*
* @return
*/
public String getTableName(String table, Number shardKey) {
if (orMapping.getShardCount() <= 1 || shardKey == null || shardKey.longValue() <= 0) {
return table;
}
return table + calShardNum(shardKey.longValue());
}
private static Object getProperValue(Number number, Class<?> expectedClass) {
Class<?> klazz = ClassUtils.wrapperToPrimitive(number.getClass());
Object value = null;
// Dexlib will only ever make byte (t), int, long (l), or short (s)
if (klazz == byte.class) {
value = number.byteValue();
if (expectedClass == boolean.class) {
value = (byte) value == 1;
}
} else if (klazz == short.class) {
value = number.shortValue();
if (expectedClass == char.class) {
value = (char) number.shortValue();
}
} else if (klazz == int.class) {
if (expectedClass == int.class) {
value = number.intValue();
} else if (expectedClass == float.class) {
value = Float.intBitsToFloat(number.intValue());
}
} else if (klazz == long.class) {
value = number.longValue();
if (expectedClass == long.class) {
value = number.longValue();
} else if (expectedClass == double.class) {
value = Double.longBitsToDouble(number.longValue());
}
}
return value;
}
private String saveTxn(TransactionVO currentTransaction) throws ParseException {
insertTransaction =
new SimpleJdbcInsert(getDataSource())
.withTableName("transaction")
.usingGeneratedKeyColumns("id");
SqlParameterSource parameters =
new MapSqlParameterSource()
.addValue("dateReported", getMySQLSaveDate(currentTransaction.getDateReported()))
.addValue("customerId", currentTransaction.getCustomerId())
.addValue("productCategory", currentTransaction.getProductCategory())
.addValue("makeId", currentTransaction.getMakeId())
.addValue("modelId", currentTransaction.getModelId())
.addValue("serialNo", currentTransaction.getSerialNo())
.addValue("accessories", currentTransaction.getAccessories())
.addValue("complaintReported", currentTransaction.getComplaintReported())
.addValue("complaintDiagnosed", currentTransaction.getComplaintDiagonsed())
.addValue("engineerRemarks", currentTransaction.getEnggRemark())
.addValue("repairAction", currentTransaction.getRepairAction())
.addValue("note", currentTransaction.getNotes())
.addValue("status", currentTransaction.getStatus())
.addValue("createdOn", currentTransaction.getCreatedOn())
.addValue("modifiedOn", currentTransaction.getModifiedOn())
.addValue("createdBy", currentTransaction.getCreatedBy())
.addValue("modifiedBy", currentTransaction.getModifiedBy());
Number newId = insertTransaction.executeAndReturnKey(parameters);
LOG.info(" the queryForInt resulted in " + newId.longValue());
currentTransaction.setId(newId.longValue());
// update the tag No
String tagNo = "WON2N" + newId.longValue();
String query = "update transaction set TagNo = '" + tagNo + "' where id =" + newId.longValue();
getJdbcTemplate().update(query);
return tagNo;
}
static boolean equals(Object o1, Object o2) {
if (o1 == o2) return true;
if (o1 instanceof JsonObject) {
return objectEquals(((JsonObject) o1).map, o2);
}
if (o1 instanceof Map<?, ?>) {
return objectEquals((Map<?, ?>) o1, o2);
}
if (o1 instanceof JsonArray) {
return JsonArray.arrayEquals(((JsonArray) o1).getList(), o2);
}
if (o1 instanceof List<?>) {
return JsonArray.arrayEquals((List<?>) o1, o2);
}
if (o1 instanceof Number && o2 instanceof Number && o1.getClass() != o2.getClass()) {
Number n1 = (Number) o1;
Number n2 = (Number) o2;
if (o1 instanceof Float
|| o1 instanceof Double
|| o2 instanceof Float
|| o2 instanceof Double) {
return n1.doubleValue() == n2.doubleValue();
} else {
return n1.longValue() == n2.longValue();
}
}
return o1.equals(o2);
}
/**
* This method is invoked when the builtin is called in a rule body.
*
* @param args the array of argument values for the builtin, this is an array of Nodes, some of
* which may be Node_RuleVariables.
* @param length the length of the argument list, may be less than the length of the args array
* for some rule engines
* @param context an execution context giving access to other relevant data
* @return return true if the buildin predicate is deemed to have succeeded in the current
* environment
*/
public boolean bodyCall(Node[] args, int length, RuleContext context) {
checkArgs(length, context);
BindingEnvironment env = context.getEnv();
Node n1 = getArg(0, args, context);
Node n2 = getArg(1, args, context);
if (n1.isLiteral() && n2.isLiteral()) {
Object v1 = n1.getLiteralValue();
Object v2 = n2.getLiteralValue();
Node sum = null;
if (v1 instanceof Number && v2 instanceof Number) {
Number nv1 = (Number) v1;
Number nv2 = (Number) v2;
if (v1 instanceof Float
|| v1 instanceof Double
|| v2 instanceof Float
|| v2 instanceof Double) {
sum = Util.makeDoubleNode(nv1.doubleValue() - nv2.doubleValue());
} else {
sum = Util.makeLongNode(nv1.longValue() - nv2.longValue());
}
return env.bind(args[2], sum);
}
}
// Doesn't (yet) handle partially bound cases
return false;
}
public void importarPendientes(Long sucursalId) {
String sql = "select * from sx_clientes_log where tx_importado is null";
JdbcTemplate template = ReplicaServices.getInstance().getJdbcTemplate(sucursalId);
List<Map<String, Object>> rows = template.queryForList(sql);
for (Map<String, Object> row : rows) {
System.out.println("Importando: " + row);
try {
Number cliente_id = (Number) row.get("CLIENTE_ID");
HibernateTemplate source = ReplicaServices.getInstance().getHibernateTemplate(sucursalId);
List<Cliente> clientes =
source.find(
"from Cliente c "
+ " left join fetch c.direcciones d"
+ " left join fetch c.telefonos t"
+ " where c.id=?",
cliente_id.longValue());
Cliente c = clientes.get(0);
Services.getInstance().getHibernateTemplate().replicate(c, ReplicationMode.IGNORE);
} catch (Exception e) {
logger.error("Error importando cliente: " + row, e);
}
try {
Number id = (Number) row.get("ID");
String update = "UPDATE SX_CLIENTES_LOG SET TX_IMPORTADO=NOW() WHERE ID=?";
template.update(update, new Object[] {id.longValue()});
} catch (Exception e) {
logger.error("Error actualizando importado: " + row);
}
}
}
private static Object toType(Number val, int returnType) {
switch (returnType) {
case DataTypes.W_DOUBLE:
case DataTypes.DOUBLE:
return val.doubleValue();
case DataTypes.W_FLOAT:
case DataTypes.FLOAT:
return val.floatValue();
case DataTypes.INTEGER:
case DataTypes.W_INTEGER:
return val.intValue();
case DataTypes.W_LONG:
case DataTypes.LONG:
return val.longValue();
case DataTypes.W_SHORT:
case DataTypes.SHORT:
return val.shortValue();
case DataTypes.BIG_DECIMAL:
return new BigDecimal(val.doubleValue());
case DataTypes.BIG_INTEGER:
return BigInteger.valueOf(val.longValue());
case DataTypes.STRING:
return val.doubleValue();
}
throw new RuntimeException("internal error: " + returnType);
}
/** @return The hashing values for the user source that were stored in the backup */
public Hashing getHashing() {
prisms.util.LongList mults = new prisms.util.LongList();
prisms.util.LongList mods = new prisms.util.LongList();
try {
if (!"hashing".equals(theJsonReader.getNextProperty())) return null;
JsonSerialReader.StructState rootState = theJsonReader.startObject();
try {
if (!"multiples".equals(theJsonReader.getNextProperty())) return null;
theJsonReader.startArray();
Number num;
do {
num = theJsonReader.parseNumber();
if (num != null) mults.add(num.longValue());
} while (num != null);
theJsonReader.endArray(null);
if (!"modulos".equals(theJsonReader.getNextProperty())) return null;
theJsonReader.startArray();
do {
num = theJsonReader.parseNumber();
if (num != null) mods.add(num.longValue());
} while (num != null);
theJsonReader.endArray(null);
} finally {
theJsonReader.endObject(rootState);
}
} catch (Exception e) {
log.error("Could not read JSON backup data", e);
return null;
}
Hashing ret = new Hashing();
ret.setPrimaryHashing(mults.toArray(), mods.toArray());
return ret;
}
public static int compare(Number param, Number threshold) throws Throwable {
try {
int eval = 0;
if (threshold instanceof Double) {
eval = Double.compare(param.doubleValue(), threshold.doubleValue());
} else if (threshold instanceof Float) {
eval = Float.compare(param.floatValue(), threshold.floatValue());
} else if (threshold instanceof Long) {
eval = (Long.valueOf(param.longValue())).compareTo(Long.valueOf(threshold.longValue()));
} else if (threshold instanceof Integer) {
eval = param.intValue() > threshold.intValue() ? 1 : -1;
}
return eval;
} catch (VirtualMachineError err) {
SystemFailure.initiateFailure(err);
// If this ever returns, rethrow the error. We're poisoned
// now, so don't let this thread continue.
throw err;
} catch (Throwable e) {
// Whenever you catch Error or Throwable, you must also
// catch VirtualMachineError (see above). However, there is
// _still_ a possibility that you are dealing with a cascading
// error condition, so you also need to check to see if the JVM
// is still usable:
SystemFailure.checkFailure();
throw e;
}
}
private Number incrValue(int dir) {
Number newValue;
if ((value instanceof Float) || (value instanceof Double)) {
double v = value.doubleValue() + (stepSize.doubleValue() * (double) dir);
if (value instanceof Double) {
newValue = new Double(v);
} else {
newValue = new Float(v);
}
} else {
long v = value.longValue() + (stepSize.longValue() * (long) dir);
if (value instanceof Long) {
newValue = new Long(v);
} else if (value instanceof Integer) {
newValue = new Integer((int) v);
} else if (value instanceof Short) {
newValue = new Short((short) v);
} else {
newValue = new Byte((byte) v);
}
}
if ((maximum != null) && (maximum.compareTo(newValue) < 0)) {
return null;
}
if ((minimum != null) && (minimum.compareTo(newValue) > 0)) {
return null;
} else {
return newValue;
}
}
/**
* Expression may return number value which is not directly compatible with feature type (e.g.
* Double when Integer is expected), or EEnumLiteral meta-object when literal instance is expected
*
* @generated
*/
public static Object performCast(Object value, EDataType targetType) {
if (targetType instanceof EEnum) {
if (value instanceof EEnumLiteral) {
EEnumLiteral literal = (EEnumLiteral) value;
return (literal.getInstance() != null) ? literal.getInstance() : literal;
}
}
if (false == value instanceof Number
|| targetType == null
|| targetType.getInstanceClass() == null) {
return value;
}
Class<?> targetClass = targetType.getInstanceClass();
Number num = (Number) value;
Class<?> valClass = value.getClass();
Class<?> targetWrapperClass = targetClass;
if (targetClass.isPrimitive()) {
targetWrapperClass = EcoreUtil.wrapperClassFor(targetClass);
}
if (valClass.equals(targetWrapperClass)) {
return value;
}
if (Number.class.isAssignableFrom(targetWrapperClass)) {
if (targetWrapperClass.equals(Byte.class)) return new Byte(num.byteValue());
if (targetWrapperClass.equals(Integer.class)) return new Integer(num.intValue());
if (targetWrapperClass.equals(Short.class)) return new Short(num.shortValue());
if (targetWrapperClass.equals(Long.class)) return new Long(num.longValue());
if (targetWrapperClass.equals(BigInteger.class)) return BigInteger.valueOf(num.longValue());
if (targetWrapperClass.equals(Float.class)) return new Float(num.floatValue());
if (targetWrapperClass.equals(Double.class)) return new Double(num.doubleValue());
if (targetWrapperClass.equals(BigDecimal.class)) return new BigDecimal(num.doubleValue());
}
return value;
}
@Override
public void update(Object[] accRow, Object val) {
if (val != null) {
Number value = (Number) val;
if (fieldType == Double.class || fieldType == Float.class) {
((DoubleSum) accRow[outPos]).update(value.doubleValue());
} else if (fieldType == Integer.class
|| fieldType == Byte.class
|| fieldType == Short.class) {
value = value.longValue();
Number sum = (Number) accRow[outPos];
if (sum != null) {
if (fieldType == Long.class) {
value = sum.longValue() + value.longValue();
} else if (fieldType == BigInteger.class) {
value = ((BigInteger) sum).add((BigInteger) value);
} else if (fieldType == BigDecimal.class) {
value = ((BigDecimal) sum).add((BigDecimal) value);
} else {
// byte, short, int
value = sum.intValue() + value.intValue();
}
}
accRow[outPos] = value;
}
}
}
/**
* Constructs a new <code>LongRange</code> with the specified minimum and maximum numbers (both
* inclusive).
*
* <p>The arguments may be passed in the order (min,max) or (max,min). The getMinimum and
* getMaximum methods will return the correct values.
*
* @param number1 first number that defines the edge of the range, inclusive
* @param number2 second number that defines the edge of the range, inclusive
* @throws IllegalArgumentException if either number is <code>null</code>
*/
public LongRange(Number number1, Number number2) {
super();
if (number1 == null || number2 == null) {
throw new IllegalArgumentException("The numbers must not be null");
}
long number1val = number1.longValue();
long number2val = number2.longValue();
if (number2val < number1val) {
this.min = number2val;
this.max = number1val;
if (number2 instanceof Long) {
this.minObject = (Long) number2;
}
if (number1 instanceof Long) {
this.maxObject = (Long) number1;
}
} else {
this.min = number1val;
this.max = number2val;
if (number1 instanceof Long) {
this.minObject = (Long) number1;
}
if (number2 instanceof Long) {
this.maxObject = (Long) number2;
}
}
}
public long getNextSequence(TypeDescriptor typeDescriptor, Session session) {
// check if there is an id in the cache
ConcurrentLinkedQueue cachedIds =
(ConcurrentLinkedQueue) this.typeDescriptorToIdCache.get(typeDescriptor);
if (null == cachedIds) {
typeDescriptorToIdCache.putIfAbsent(typeDescriptor, new ConcurrentLinkedQueue());
cachedIds = (ConcurrentLinkedQueue) this.typeDescriptorToIdCache.get(typeDescriptor);
}
Number cachedId = (Number) cachedIds.poll();
if (cachedId == null) {
synchronized (cachedIds) {
cachedId = (Number) cachedIds.poll();
if (cachedId == null) {
List newIds = this.getNextSequenceImpl(typeDescriptor, session);
Assert.condition(0 < newIds.size());
// reserve first for own use
cachedId = (Number) newIds.remove(0);
cachedIds.addAll(newIds);
}
}
}
if (trace.isDebugEnabled()) {
trace.debug("returning unique ID: " + cachedId.longValue());
}
return cachedId.longValue();
}
public Number compute(Number d1, Number d2) {
long d2Long = d2.longValue();
if (d2Long == 0) {
return null;
}
return d1.longValue() / d2Long;
}
@Override
public JSONRPC2Response process(final Map<String, Object> params) {
try {
final Number tid =
HandlerUtils.<Number>fetchField(MonitoringHandler.TENANT, params, true, null);
final Number dpid =
HandlerUtils.<Number>fetchField(MonitoringHandler.VDPID, params, false, -1);
final OVXMap map = OVXMap.getInstance();
final LinkedList<Map<String, Object>> flows = new LinkedList<Map<String, Object>>();
if (dpid.longValue() == -1) {
HashMap<String, Object> res = new HashMap<String, Object>();
for (OVXSwitch vsw : map.getVirtualNetwork(tid.intValue()).getSwitches()) {
flows.clear();
final Collection<OVXFlowMod> fms = vsw.getFlowTable().getFlowTable();
for (final OVXFlowMod flow : fms) {
final Map<String, Object> entry = flow.toMap();
flows.add(entry);
}
res.put(vsw.getSwitchName(), flows.clone());
}
this.resp = new JSONRPC2Response(res, 0);
} else {
final OVXSwitch vsw = map.getVirtualNetwork(tid.intValue()).getSwitch(dpid.longValue());
final Collection<OVXFlowMod> fms = vsw.getFlowTable().getFlowTable();
for (final OVXFlowMod flow : fms) {
final Map<String, Object> entry = flow.toMap();
flows.add(entry);
}
this.resp = new JSONRPC2Response(flows, 0);
}
} catch (ClassCastException | MissingRequiredField e) {
this.resp =
new JSONRPC2Response(
new JSONRPC2Error(
JSONRPC2Error.INVALID_PARAMS.getCode(),
this.cmdName() + ": Unable to fetch virtual topology : " + e.getMessage()),
0);
} catch (final InvalidDPIDException e) {
this.resp =
new JSONRPC2Response(
new JSONRPC2Error(
JSONRPC2Error.INVALID_PARAMS.getCode(),
this.cmdName() + ": Unable to fetch virtual topology : " + e.getMessage()),
0);
} catch (NetworkMappingException e) {
this.resp =
new JSONRPC2Response(
new JSONRPC2Error(
JSONRPC2Error.INVALID_PARAMS.getCode(),
this.cmdName() + ": Unable to fetch virtual topology : " + e.getMessage()),
0);
}
return this.resp;
}
public static Number OR(Number a, Number b) {
if (a.longValue() > 0) {
return a;
}
if (b.longValue() > 0) {
return b;
}
return a;
}
public static Object virtual_calculateCompileTimeConstantValue_1587718783752756055(
SNode thisNode, Object leftValue, Object rightValue) {
if (leftValue instanceof Number && rightValue instanceof Number) {
Number a = (Number) leftValue;
Number b = (Number) rightValue;
if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912(
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfbdeb6fecfL,
"jetbrains.mps.baseLanguage.structure.BinaryOperation"),
Double.class,
a,
b)) {
return a.doubleValue() < b.doubleValue();
}
if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912(
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfbdeb6fecfL,
"jetbrains.mps.baseLanguage.structure.BinaryOperation"),
Float.class,
a,
b)) {
return a.floatValue() < b.floatValue();
}
if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912(
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfbdeb6fecfL,
"jetbrains.mps.baseLanguage.structure.BinaryOperation"),
Long.class,
a,
b)) {
return a.longValue() < b.longValue();
}
if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912(
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfbdeb6fecfL,
"jetbrains.mps.baseLanguage.structure.BinaryOperation"),
Integer.class,
a,
b)) {
return a.intValue() < b.intValue();
}
} else if (leftValue instanceof Character && rightValue instanceof Character) {
return ((Character) leftValue).charValue() < ((Character) rightValue).charValue();
}
return null;
}
@Override
boolean compare(Object queryValue, Object storedValue) {
List<Integer> queryList = typecast(command + " clause", queryValue, List.class);
enforce(queryList.size() == 2, command + " clause must be a List of size 2");
Number modulus = queryList.get(0);
Number expectedValue = queryList.get(1);
return (storedValue != null)
&& (typecast("value", storedValue, Number.class).longValue())
% modulus.longValue()
== expectedValue.longValue();
}
protected Number subtractNumbers(Number nOne, Number nTwo) {
assert nOne != null;
assert nTwo != null;
if (nOne instanceof Double || nTwo instanceof Double) {
return Double.valueOf(nOne.doubleValue() - nTwo.doubleValue());
} else if (nOne instanceof Long || nTwo instanceof Long) {
return Long.valueOf(nOne.longValue() - nTwo.longValue());
} else {
return Integer.valueOf(nOne.intValue() - nTwo.intValue());
}
}
@SuppressWarnings("unchecked")
@Override
public Function<Object[], ?> visit(UnaryExpression e) {
final Function<Object[], ?> first = e.getFirst().accept(this);
switch (e.getExpressionType()) {
case ExpressionType.ArrayLength:
return t -> Array.getLength(first.apply(t));
case ExpressionType.BitwiseNot:
return (Function<Object[], ?>) bitwiseNot((Function<Object[], Number>) first);
case ExpressionType.Convert:
final Class<?> to = e.getResultType();
if (to.isPrimitive() || Number.class.isAssignableFrom(to))
return t -> {
Object source = first.apply(t);
if (source instanceof Number) {
Number result = (Number) source;
if (to.isPrimitive()) {
if (to == Integer.TYPE) return result.intValue();
if (to == Long.TYPE) return result.longValue();
if (to == Float.TYPE) return result.floatValue();
if (to == Double.TYPE) return result.doubleValue();
if (to == Byte.TYPE) return result.byteValue();
if (to == Character.TYPE) return (char) result.intValue();
if (to == Short.TYPE) return result.shortValue();
} else if (result != null) {
if (to == BigInteger.class) return BigInteger.valueOf(result.longValue());
if (to == BigDecimal.class) return BigDecimal.valueOf(result.doubleValue());
}
}
if (source instanceof Character) {
if (to == Integer.TYPE) return (int) (char) source;
if (to == Long.TYPE) return (long) (char) source;
if (to == Float.TYPE) return (float) (char) source;
if (to == Double.TYPE) return (double) (char) source;
}
return to.cast(source);
};
return first;
case ExpressionType.IsNull:
return first.andThen(r -> r == null);
case ExpressionType.LogicalNot:
return normalize(not((Function<Object[], Boolean>) first));
case ExpressionType.Negate:
return (Function<Object[], ?>) negate((Function<Object[], Number>) first);
case ExpressionType.Quote:
return constant(first);
// case ExpressionType.UnaryPlus:
// return abs((Function<? extends Number, Object[]>) first);
default:
throw new IllegalArgumentException(ExpressionType.toString(e.getExpressionType()));
}
}
private long updateTimeSinceStart(List<CompletableFuture<Map<String, Number>>> responseList)
throws Exception {
long timeSinceStartMax = 0;
for (Future<Map<String, Number>> f : responseList) {
Map<String, Number> m = f.get();
Number timeSinceStart = m.get(TIME_SINCE_START);
if (timeSinceStart.longValue() > timeSinceStartMax) {
timeSinceStartMax = timeSinceStart.longValue();
}
}
return timeSinceStartMax;
}
public Number add(Number x) {
if (x instanceof Integer) {
return set(Integer.valueOf(number.intValue() + x.intValue()));
}
if (x instanceof Long) {
return set(Long.valueOf(number.longValue() + x.longValue()));
}
if (x instanceof Double) {
return set(Double.valueOf(number.doubleValue() + x.doubleValue()));
}
return number;
}
/**
* @param lhs
* @param rhs
* @return
*/
protected Number divide(Number lhs, Number rhs) {
Number result = null;
if (isFloat(lhs) || isFloat(rhs)) {
result = lhs.doubleValue() / rhs.doubleValue();
} else {
if (isLong(lhs) || isLong(rhs)) {
result = lhs.longValue() / lhs.longValue();
} else {
result = lhs.intValue() / rhs.intValue();
}
}
return result;
}
@Override
public Number evaluate(Object... na) {
if (!(na[0] instanceof Number) || !(na[1] instanceof Number)) return null;
Number na1 = (Number) na[0];
Number na2 = (Number) na[1];
if (na1 instanceof Double || na2 instanceof Double)
return na1.doubleValue() % na2.doubleValue();
else if (na1 instanceof Float || na2 instanceof Float)
return na1.floatValue() % na2.floatValue();
else if (na1 instanceof Long || na2 instanceof Long) return na1.longValue() % na2.longValue();
else if (na1 instanceof Integer || na2 instanceof Integer)
return na1.intValue() % na2.intValue();
return na1.byteValue() % na2.byteValue();
}
public Object calculate() {
Number lval = (Number) calculateItem(this.left);
Number rval = (Number) calculateItem(this.right);
if (rval instanceof Double || lval instanceof Double) {
return lval.doubleValue() <= rval.doubleValue();
}
if (rval instanceof Float || lval instanceof Float) {
return lval.floatValue() <= rval.floatValue();
}
if (rval instanceof Long || lval instanceof Long) {
return lval.longValue() <= rval.longValue();
}
return lval.intValue() <= rval.intValue();
}
@Override
// TODO: recursive expressions as operands
public boolean process(
ProvaReagent prova,
ProvaDerivationNode node,
ProvaGoal goal,
List<ProvaLiteral> newLiterals,
ProvaRule query) {
ProvaLiteral literal = goal.getGoal();
List<ProvaVariable> variables = query.getVariables();
ProvaList terms = (ProvaList) literal.getTerms().cloneWithVariables(variables);
ProvaObject[] data = terms.getFixed();
if (data.length != 3) return false;
ProvaObject lt = data[0];
if (lt instanceof ProvaVariablePtr) {
ProvaVariablePtr varPtr = (ProvaVariablePtr) lt;
lt = variables.get(varPtr.getIndex()).getRecursivelyAssigned();
}
if (!((lt instanceof ProvaVariable) || (lt instanceof ProvaConstant))) return false;
ProvaObject a1 = data[1];
if (a1 instanceof ProvaVariablePtr) {
ProvaVariablePtr varPtr = (ProvaVariablePtr) a1;
a1 = variables.get(varPtr.getIndex()).getRecursivelyAssigned();
}
if (!(a1 instanceof ProvaConstant)) return false;
Object oa1 = ((ProvaConstant) a1).getObject();
if (!(oa1 instanceof Number)) return false;
ProvaObject a2 = data[2];
if (a2 instanceof ProvaVariablePtr) {
ProvaVariablePtr varPtr = (ProvaVariablePtr) a2;
a2 = variables.get(varPtr.getIndex()).getRecursivelyAssigned();
}
if (!(a2 instanceof ProvaConstant)) return false;
Object oa2 = ((ProvaConstant) a2).getObject();
if (!(oa2 instanceof Number)) return false;
Number na1 = (Number) oa1;
Number na2 = (Number) oa2;
Number result;
if (na1 instanceof Double || na2 instanceof Double)
result = na1.doubleValue() * na2.doubleValue();
else if (na1 instanceof Float || na2 instanceof Float)
result = na1.floatValue() * na2.floatValue();
else if (na1 instanceof Long || na2 instanceof Long) result = na1.longValue() * na2.longValue();
else if (na1 instanceof Integer || na2 instanceof Integer)
result = na1.intValue() * na2.intValue();
else result = na1.byteValue() * na2.byteValue();
if (lt instanceof ProvaConstant) return ((ProvaConstant) lt).getObject() == result;
((ProvaVariable) lt).setAssigned(ProvaConstantImpl.create(result));
return true;
}
/** Return the string for the object passed in. */
protected String doGetString(Object value) {
if (value instanceof Number) {
Number num = (Number) value;
switch (fNumberType) {
case BYTE:
if (num.byteValue() == Byte.MAX_VALUE) return sMaxValue;
else if (num.byteValue() == Byte.MIN_VALUE) return sMinValue;
else break;
case DOUBLE:
if (num.doubleValue() == Double.MAX_VALUE) return sMaxValue;
else if (num.doubleValue() == Double.MIN_VALUE) return sMinValue;
case FLOAT:
if (fNumberType == FLOAT) {
if (num.floatValue() == Float.MAX_VALUE) return sMaxValue;
else if (num.floatValue() == Float.MIN_VALUE) return sMinValue;
}
// The formatter doesn't handle big/small floats. (i.e. more than the MIN digits we set).
// It doesn't go to scientific notation as necessary. The only way to test this is to
// roundtrip the number. If they come up to be the same, then it is ok. Else format using
// toString.
String result = fFormatter.format(value);
try {
Number roundTrip = fFormatter.parse(result);
if (roundTrip.doubleValue() != num.doubleValue()) result = value.toString();
} catch (ParseException e) {
result = value.toString();
}
return result;
case INTEGER:
if (num.intValue() == Integer.MAX_VALUE) return sMaxValue;
else if (num.intValue() == Integer.MIN_VALUE) return sMinValue;
else break;
case LONG:
if (num.longValue() == Long.MAX_VALUE) return sMaxValue;
else if (num.longValue() == Long.MIN_VALUE) return sMinValue;
else break;
case SHORT:
if (num.shortValue() == Short.MAX_VALUE) return sMaxValue;
else if (num.shortValue() == Short.MIN_VALUE) return sMinValue;
else break;
default:
break;
}
return fFormatter.format(value);
} else {
return null; // Invalid or null. No string to display.
}
}
public static boolean greatThan(Number num1, Number num2) {
if (num1 == null || num2 == null) {
return false;
}
if (num1 instanceof Long && num2 instanceof Long) {
return num1.longValue() > num2.longValue();
} else if (num1 instanceof Long && num2 instanceof Integer) {
return num1.longValue() > num2.intValue();
} else if (num1 instanceof Integer && num2 instanceof Long) {
return num1.intValue() > num2.longValue();
} else if (num1 instanceof Integer && num2 instanceof Integer) {
return num1.intValue() > num2.intValue();
}
return false;
}
