public static boolean asBoolean(Object value, boolean coerceType) { if (value == null) { return false; } if (value instanceof Boolean) { return (Boolean) value; } Object got = get(value, Types.BOOLEAN); if (got != NO_METHOD) { return (Boolean) got; } if (coerceType) { return !asEmpty(value); } return true; }
@Override public boolean compareNull(Object left, Object right) { // at least one is null, see if other is null or acts as a null return left == right || DuckType.asNull(left == null ? right : left); }
public static Number asNumber(Object value) { return asNumber(value, true); }
protected static Method findMethod(Class c, Types type) { if (c == null || c == Object.class) { return null; } Method m = getMethod(c, type.name); if (m != null) { return m; } for (Class i : c.getInterfaces()) { m = findMethod(i, type); if (m != null) { return m; } } m = findMethod(c.getSuperclass(), type); if (m != null) { return m; } return null; }
public static Number asNumber(Object value, boolean coerceType) { if (value == null) { return null; } if (value instanceof Number) { return (Number)value; } Object got = get(value, Types.NUMBER); if (got != NO_METHOD) { return (Number)got; } if (coerceType) { String string = asString(value);// coerce to string if (string != null) { return new BigDecimal(string); } } return null; }
public static String asString(Object value) { return asString(value, true); }
Method method = findMethod(c, type); if (method == null)
/** * Computes boolean value of this reference * Returns the actual value of reference return type * boolean, and 'true' if value is not null * * @param context context to compute value with * @return True if evaluation was ok. * @throws MethodInvocationException */ public boolean evaluate(InternalContextAdapter context) throws MethodInvocationException { Object value = execute(this, context); // non-null object as first parameter by convention for 'evaluate' if (value == null) { return false; } try { return DuckType.asBoolean(value, checkEmpty); } catch(Exception e) { throw new VelocityException("Reference evaluation threw an exception at " + StringUtils.formatFileString(this), e); } }
@Override public boolean compareNonNumber(Object left, Object right) { /** * if both are not null, then assume that if one class * is a subclass of the other that we should use the equals operator */ if (left.getClass().isAssignableFrom(right.getClass()) || right.getClass().isAssignableFrom(left.getClass())) { return left.equals(right); } // coerce to string, remember getAsString() methods may return null left = DuckType.asString(left); right = DuckType.asString(right); if (left == right) { return true; } else if (left == null || right == null) { return false; } else { return left.equals(right); } }
public static String asString(Object value, boolean coerceType) { if (value == null) { return null; } if (value instanceof String) { return (String)value; } Object got = get(value, Types.STRING); if (got == NO_METHOD) { return coerceType ? value.toString() : null; } return (String)got; }
@Override protected Object handleSpecial(Object left, Object right, InternalContextAdapter context) { // check for strings, but don't coerce String lstr = DuckType.asString(left, false); String rstr = DuckType.asString(right, false); if (lstr != null || rstr != null) { if (lstr == null) { lstr = left != null ? left.toString() : jjtGetChild(0).literal(); } else if (rstr == null) { rstr = right != null ? right.toString() : jjtGetChild(1).literal(); } return lstr.concat(rstr); } return null; }
public Boolean compareNumbers(Object left, Object right) { try { left = DuckType.asNumber(left); } catch (NumberFormatException nfe) {} try { right = DuckType.asNumber(right); } catch (NumberFormatException nfe) {} // only compare Numbers if (left instanceof Number && right instanceof Number) { return numberTest(MathUtils.compare((Number)left, (Number)right)); } return null; }
Object isEmpty = get(value, Types.EMPTY); if (isEmpty != NO_METHOD) Object length = get(value, Types.LENGTH); if (length != NO_METHOD && length instanceof Number) Object size = get(value, Types.SIZE); if (size != NO_METHOD && size instanceof Number) Object asString = get(value, Types.STRING); if (asString == null) Object asNumber = get(value, Types.NUMBER); if (asNumber == null)
toString = DuckType.asString(value);
try value = DuckType.asNumber(value);