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;
}
/** Adds two numbers, coercing the second to the type of the first. */
private Number sum(Number a, Number b) {
if (a instanceof Integer) {
return new Integer(a.intValue() + b.intValue());
} else if (a instanceof Float) {
return new Float(a.floatValue() + b.floatValue());
} else if (a instanceof Short) {
return new Short((short) (a.shortValue() + b.shortValue()));
} else if (a instanceof Byte) {
return new Byte((byte) (a.byteValue() + b.byteValue()));
} else {
// should never happen
throw new AnalyticsException("Invalid number type");
}
}
/** 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 JsonPrimitive fromPrimitive(Object object) {
if (object != null) {
if (object instanceof Number) {
JsonPrimitive jsonPrimitive;
Number objectNumber = (Number) object;
if (objectNumber instanceof Byte)
jsonPrimitive = new JsonPrimitive(objectNumber.byteValue());
else if (objectNumber instanceof Double)
jsonPrimitive = new JsonPrimitive(objectNumber.doubleValue());
else if (objectNumber instanceof Float)
jsonPrimitive = new JsonPrimitive(objectNumber.floatValue());
else if (objectNumber instanceof Integer)
jsonPrimitive = new JsonPrimitive(objectNumber.intValue());
else if (objectNumber instanceof Long)
jsonPrimitive = new JsonPrimitive(objectNumber.longValue());
else if (objectNumber instanceof Short)
jsonPrimitive = new JsonPrimitive(objectNumber.shortValue());
else jsonPrimitive = new JsonPrimitive(objectNumber);
return jsonPrimitive;
} else if (object instanceof Boolean) {
return new JsonPrimitive((Boolean) object);
} else if (object instanceof String) {
return new JsonPrimitive((String) object);
} else if (object instanceof Character) {
return new JsonPrimitive((Character) object);
}
}
return null;
}
/** {@inheritDoc} */
@Override
protected byte[] toArray(final Number number) {
final ByteBuffer buff = ByteBuffer.allocate(BYTES_PER_ELEMENT);
buff.order(ByteOrder.LITTLE_ENDIAN);
buff.putShort(number.shortValue());
return buff.array();
}
public static Number convert(Number val, Class<? extends Number> type) {
if (val == null) {
return null;
} else if (Double.class.equals(type)) {
if (val instanceof Double) {
return val;
}
return Double.valueOf(val.doubleValue());
} else if (Float.class.equals(type)) {
if (val instanceof Float) {
return val;
}
return Float.valueOf(val.floatValue());
} else if (Integer.class.equals(type)) {
if (val instanceof Integer) {
return val;
}
return Integer.valueOf(val.intValue());
} else if (Byte.class.equals(type)) {
if (val instanceof Byte) {
return val;
}
return Byte.valueOf(val.byteValue());
} else if (Short.class.equals(type)) {
if (val instanceof Short) {
return val;
}
return Short.valueOf(val.shortValue());
} else {
throw new UnsupportedOperationException("Class " + type + " can't be used in a value Range");
}
}
/**
* Checks if the value can safely be converted to a short primitive.
*
* @param value The value validation is being performed on.
* @param locale The locale to use to parse the number (system default if null)
* @return the converted Short value.
*/
public static Short formatShort(String value, Locale locale) {
Short result = null;
if (value != null) {
NumberFormat formatter = null;
if (locale != null) {
formatter = NumberFormat.getNumberInstance(locale);
} else {
formatter = NumberFormat.getNumberInstance(Locale.getDefault());
}
formatter.setParseIntegerOnly(true);
ParsePosition pos = new ParsePosition(0);
Number num = formatter.parse(value, pos);
// If there was no error and we used the whole string
if (pos.getErrorIndex() == -1
&& pos.getIndex() == value.length()
&& num.doubleValue() >= Short.MIN_VALUE
&& num.doubleValue() <= Short.MAX_VALUE) {
result = new Short(num.shortValue());
}
}
return result;
}
/**
* Cast a primitive value represented by its java.lang wrapper type to the specified java.lang
* wrapper type. e.g. Byte(5) to Integer(5) or Integer(5) to Byte(5)
*
* @param toType is the java TYPE type
* @param value is the value in java.lang wrapper. value may not be null.
*/
static Object castWrapper(Class toType, Object value) {
if (!toType.isPrimitive()) throw new InterpreterError("invalid type in castWrapper: " + toType);
if (value == null) throw new InterpreterError("null value in castWrapper, guard");
if (value instanceof Boolean) {
if (toType != Boolean.TYPE) throw new InterpreterError("bad wrapper cast of boolean");
else return value;
}
// first promote char to Number type to avoid duplicating code
if (value instanceof Character) value = new Integer(((Character) value).charValue());
if (!(value instanceof Number)) throw new InterpreterError("bad type in cast");
Number number = (Number) value;
if (toType == Byte.TYPE) return new Byte(number.byteValue());
if (toType == Short.TYPE) return new Short(number.shortValue());
if (toType == Character.TYPE) return new Character((char) number.intValue());
if (toType == Integer.TYPE) return new Integer(number.intValue());
if (toType == Long.TYPE) return new Long(number.longValue());
if (toType == Float.TYPE) return new Float(number.floatValue());
if (toType == Double.TYPE) return new Double(number.doubleValue());
throw new InterpreterError("error in wrapper cast");
}
public static final <T> T convert(final Class<T> type, final Number value) {
T converted = null;
if (type == Double.class) {
Double doubleValue = value.doubleValue();
converted = (T) doubleValue;
} else if (type == Integer.class) {
Integer intValue = value.intValue();
converted = (T) intValue;
} else if (type == Float.class) {
Float floatValue = value.floatValue();
converted = (T) floatValue;
} else if (type == Byte.class) {
Byte byteValue = value.byteValue();
converted = (T) byteValue;
} else if (type == Long.class) {
Long longValue = value.longValue();
converted = (T) longValue;
} else if (type == Short.class) {
Short shortValue = value.shortValue();
converted = (T) shortValue;
} else {
throw new IllegalStateException("Could not covert Number.");
}
return converted;
}
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);
}
@SuppressWarnings("boxing")
private void cipEqu(Number actual, Number expected, int flags) {
Number res = OverloadedNumberUtil.addFallbackType(actual, flags);
assertEquals(expected.getClass(), res.getClass());
assertEquals(expected, res);
// Some number types wrap the number with multiple types and equals() only compares one of them.
// So we try to
// catch any inconsistency:
assertEquals(expected.byteValue(), res.byteValue());
assertEquals(expected.shortValue(), res.shortValue());
assertEquals(expected.intValue(), res.intValue());
assertEquals(expected.longValue(), res.longValue());
assertEquals(expected.floatValue(), res.floatValue());
assertEquals(expected.doubleValue(), res.doubleValue());
}
/*
* We need to coerce numbers to the tightest possible type and let the
* schema coerce them to the proper
*/
@SuppressWarnings("unchecked")
private static Object tightenNumericTypes(Object o) {
if (o == null) {
return null;
} else if (o instanceof List) {
List l = (List) o;
for (int i = 0; i < l.size(); i++) l.set(i, tightenNumericTypes(l.get(i)));
return l;
} else if (o instanceof Map) {
Map m = (Map) o;
for (Map.Entry entry : (Set<Map.Entry>) m.entrySet())
m.put(entry.getKey(), tightenNumericTypes(entry.getValue()));
return m;
} else if (o instanceof Number) {
Number n = (Number) o;
if (o instanceof Integer) {
if (n.intValue() < Byte.MAX_VALUE) return n.byteValue();
else if (n.intValue() < Short.MAX_VALUE) return n.shortValue();
else return n;
} else if (o instanceof Double) {
if (n.doubleValue() < Float.MAX_VALUE) return n.floatValue();
else return n;
} else {
throw new RuntimeException("Unsupported numeric type: " + o.getClass());
}
} else {
return o;
}
}
private static Object convertConstant(Number source, ClassNode target) {
if (ClassHelper.Byte_TYPE.equals(target)) {
return source.byteValue();
}
if (ClassHelper.Short_TYPE.equals(target)) {
return source.shortValue();
}
if (ClassHelper.Integer_TYPE.equals(target)) {
return source.intValue();
}
if (ClassHelper.Long_TYPE.equals(target)) {
return source.longValue();
}
if (ClassHelper.Float_TYPE.equals(target)) {
return source.floatValue();
}
if (ClassHelper.Double_TYPE.equals(target)) {
return source.doubleValue();
}
if (ClassHelper.BigInteger_TYPE.equals(target)) {
return DefaultGroovyMethods.asType(source, BigInteger.class);
}
if (ClassHelper.BigDecimal_TYPE.equals(target)) {
return DefaultGroovyMethods.asType(source, BigDecimal.class);
}
throw new IllegalArgumentException("Unsupported conversion");
}
/**
* This is a constructor provided to clone Number. Since V is instantiation time and not known
* during module creation, a copy is needed. Currently only the following are supported: Double,
* Integer, Float, Long, and Short. If you derive your own class from Number then you need to
* override getValue to help make a correct copy.
*
* @param num to clone from
* @return value as a correct sub-class (V) object
*/
@SuppressWarnings("unchecked")
public V getValue(Number num) {
Number val;
switch (type) {
case DOUBLE:
val = new Double(num.doubleValue());
break;
case INTEGER:
val = new Integer(num.intValue());
break;
case FLOAT:
val = new Float(num.floatValue());
break;
case LONG:
val = new Long(num.longValue());
break;
case SHORT:
val = new Short(num.shortValue());
break;
default:
val = new Double(num.doubleValue());
break;
}
return (V) val;
}
public Object convertToNumber(Number value, Class toType) throws Exception {
if (AtomicInteger.class == toType) {
return new AtomicInteger((Integer) convertToNumber(value, Integer.class));
} else if (AtomicLong.class == toType) {
return new AtomicLong((Long) convertToNumber(value, Long.class));
} else if (Integer.class == toType) {
return value.intValue();
} else if (Short.class == toType) {
return value.shortValue();
} else if (Long.class == toType) {
return value.longValue();
} else if (Float.class == toType) {
return value.floatValue();
} else if (Double.class == toType) {
return value.doubleValue();
} else if (Byte.class == toType) {
return value.byteValue();
} else if (BigInteger.class == toType) {
return new BigInteger(value.toString());
} else if (BigDecimal.class == toType) {
return new BigDecimal(value.toString());
} else {
return null;
}
}
/**
* 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;
}
/**
* Convert the specified object into a Short.
*
* @param value the value to convert
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to a short
*/
public static Short toShort(Object value) throws ConversionException {
Number n = toNumber(value, Short.class);
if (n instanceof Short) {
return (Short) n;
} else {
return new Short(n.shortValue());
}
}
/** @see org.inigma.lwrest.config.Configuration#getShort(java.lang.String, java.lang.Number) */
@Override
public Short getShort(String key, Number defaultValue) {
Number value = get(key, defaultValue);
if (value == null) {
return null;
}
return value.shortValue();
}
/**
* Looks up the given key in the given map, converting the result into a {@link Short}. First,
* {@link #getNumber(Map,Object)} is invoked. If the result is null, then null is returned.
* Otherwise, the short value of the resulting {@link Number} is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Short} or null
*/
public static Short getShort(Map map, Object key) {
Number answer = getNumber(map, key);
if (answer == null) {
return null;
} else if (answer instanceof Short) {
return (Short) answer;
}
return new Short(answer.shortValue());
}
/**
* Coerces the specified Number value to an alternative specified Number type via the standard
* Number defined conversion methods.
*
* @throws BeanException if the specified value could not be coerced to the property type or to
* wrap a multitude of exceptions which can be thrown on coercion (ex: NumberFormatException).
*/
public <T extends Number> T coerceNumber(Class<T> type, Number val) throws BeanException {
if (type == Byte.class) val = new Byte(val.byteValue());
else if (type == Short.class) val = new Short(val.shortValue());
else if (type == Integer.class) val = new Integer(val.intValue());
else if (type == Long.class) val = new Long(val.shortValue());
else if (type == Float.class) val = new Float(val.floatValue());
else if (type == Double.class) val = new Double(val.doubleValue());
else if (type == BigInteger.class) {
val = BigInteger.valueOf(val.longValue());
} else if (type == BigDecimal.class) {
try {
val = BigDecimal.valueOf(val.doubleValue());
} catch (NumberFormatException x) {
throw new BeanException(x);
}
} else throw new BeanException("Unsupported Number type: " + type.getName());
return type.cast(val);
}
@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()));
}
}
/**
* Coerces the value to be a number of the specified type; needed because all numbers come back
* from the datastore as Long and this screws up any type that expects something smaller. Also
* does toString just for the hell of it.
*/
Object coerceNumber(Number value, Class<?> type) {
if ((type == Byte.class) || (type == Byte.TYPE)) return value.byteValue();
else if ((type == Short.class) || (type == Short.TYPE)) return value.shortValue();
else if ((type == Integer.class) || (type == Integer.TYPE)) return value.intValue();
else if ((type == Long.class) || (type == Long.TYPE)) return value.longValue();
else if ((type == Float.class) || (type == Float.TYPE)) return value.floatValue();
else if ((type == Double.class) || (type == Double.TYPE)) return value.doubleValue();
else if (type == String.class) return value.toString();
else
throw new IllegalArgumentException(
"Don't know how to convert " + value.getClass() + " to " + type);
}
static Number addNumbers(Number paramNumber1, Number paramNumber2)
{
if (((paramNumber1 instanceof Double)) || ((paramNumber2 instanceof Double))) {
return Double.valueOf(paramNumber1.doubleValue() + paramNumber2.doubleValue());
}
if (((paramNumber1 instanceof Float)) || ((paramNumber2 instanceof Float))) {
return Float.valueOf(paramNumber1.floatValue() + paramNumber2.floatValue());
}
if (((paramNumber1 instanceof Long)) || ((paramNumber2 instanceof Long))) {
return Long.valueOf(paramNumber1.longValue() + paramNumber2.longValue());
}
if (((paramNumber1 instanceof Integer)) || ((paramNumber2 instanceof Integer))) {
return Integer.valueOf(paramNumber1.intValue() + paramNumber2.intValue());
}
if (((paramNumber1 instanceof Short)) || ((paramNumber2 instanceof Short))) {
return Integer.valueOf(paramNumber1.shortValue() + paramNumber2.shortValue());
}
if (((paramNumber1 instanceof Byte)) || ((paramNumber2 instanceof Byte))) {
return Integer.valueOf(paramNumber1.byteValue() + paramNumber2.byteValue());
}
throw new RuntimeException("Unknown number type.");
}
public short getParameter(String key, short defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.shortValue();
}
String value = getParameter(key);
if (value == null || value.length() == 0) {
return defaultValue;
}
short s = Short.parseShort(value);
getNumbers().put(key, s);
return s;
}
public short getMethodParameter(String method, String key, short defaultValue) {
String methodKey = method + "." + key;
Number n = getNumbers().get(methodKey);
if (n != null) {
return n.shortValue();
}
String value = getMethodParameter(method, key);
if (value == null || value.length() == 0) {
return defaultValue;
}
short s = Short.parseShort(value);
getNumbers().put(methodKey, s);
return s;
}
public static void put(
ByteBuffer buf, VertexFormatElement e, boolean denormalize, Number fill, Number... ns) {
if (e.getElementCount() > ns.length && fill == null)
throw new IllegalArgumentException("not enough elements");
Number n;
for (int i = 0; i < e.getElementCount(); i++) {
if (i < ns.length) n = ns[i];
else n = fill;
switch (e.getType()) {
case BYTE:
buf.put(denormalize ? (byte) (n.floatValue() * (Byte.MAX_VALUE - 1)) : n.byteValue());
break;
case UBYTE:
buf.put(denormalize ? (byte) (n.floatValue() * ((1 << Byte.SIZE) - 1)) : n.byteValue());
break;
case SHORT:
buf.putShort(
denormalize ? (short) (n.floatValue() * (Short.MAX_VALUE - 1)) : n.shortValue());
break;
case USHORT:
buf.putShort(
denormalize ? (short) (n.floatValue() * ((1 << Short.SIZE) - 1)) : n.shortValue());
break;
case INT:
buf.putInt(
denormalize ? (int) (n.doubleValue() * (Integer.MAX_VALUE - 1)) : n.intValue());
break;
case UINT:
buf.putInt(
denormalize ? (int) (n.doubleValue() * ((1L << Integer.SIZE) - 1)) : n.intValue());
break;
case FLOAT:
buf.putFloat(n.floatValue());
break;
}
}
}
public Number coerceNumber(Object inputArgument, Class<?> paraType) {
Number number = (Number) inputArgument;
if (paraType == int.class || paraType == Integer.class) {
return number.intValue();
} else if (paraType == double.class || paraType == Double.class) {
return number.doubleValue();
} else if (paraType == float.class || paraType == Float.class) {
return number.floatValue();
} else if (paraType == short.class || paraType == Short.class) {
return number.shortValue();
} else if (paraType == byte.class || paraType == Byte.class) {
return number.byteValue();
}
return null;
}
/*
* (non-Javadoc)
*
* @see
* com.vaadin.data.util.converter.Converter#convertToModel(java.lang.Object,
* java.lang.Class, java.util.Locale)
*/
@Override
public Short convertToModel(String value, Class<? extends Short> targetType, Locale locale)
throws ConversionException {
Number n = convertToNumber(value, targetType, locale);
if (n == null) {
return null;
}
short shortValue = n.shortValue();
if (shortValue == n.longValue()) {
return shortValue;
}
throw new ConversionException(
"Could not convert '" + value + "' to " + Short.class.getName() + ": value out of range");
}
@Override
protected Object cast(Class<?> target, Type[] neededGenerics, Object rawVal) {
Number value = (Number) rawVal;
// Wrapper classes are evil!
if (target.equals(Number.class)) {
return value;
} else if (target.equals(int.class) || target.equals(Integer.class)) {
if (value instanceof Integer) {
return value;
} else {
return value.intValue();
}
} else if (target.equals(byte.class) || target.equals(Byte.class)) {
if (value instanceof Byte) {
return value;
} else {
return value.byteValue();
}
} else if (target.equals(long.class) || target.equals(Long.class)) {
if (value instanceof Long) {
return value;
} else {
return value.longValue();
}
} else if (target.equals(double.class) || target.equals(Double.class)) {
if (value instanceof Double) {
return value;
} else {
return value.doubleValue();
}
} else if (target.equals(float.class) || target.equals(Float.class)) {
if (value instanceof Float) {
return value;
} else {
return value.floatValue();
}
} else if (target.equals(short.class) || target.equals(Short.class)) {
if (value instanceof Short) {
return value;
} else {
return value.shortValue();
}
}
return null;
}
/**
* Detects whether an attribute is a default value or not. Method temporarily copied from
* CoreRenderer. Should be replaced by a call of CoreRenderer in the long run.
*
* @param value the value to be checked
* @return true if the value is not the default value
*/
protected boolean shouldRenderAttribute(Object value) {
if (value == null) return false;
if (value instanceof Boolean) {
return ((Boolean) value).booleanValue();
} else if (value instanceof Number) {
Number number = (Number) value;
if (value instanceof Integer) return number.intValue() != Integer.MIN_VALUE;
else if (value instanceof Double) return number.doubleValue() != Double.MIN_VALUE;
else if (value instanceof Long) return number.longValue() != Long.MIN_VALUE;
else if (value instanceof Byte) return number.byteValue() != Byte.MIN_VALUE;
else if (value instanceof Float) return number.floatValue() != Float.MIN_VALUE;
else if (value instanceof Short) return number.shortValue() != Short.MIN_VALUE;
}
return true;
}
