public static <T> T createFromArg(Class<T> clz, Object value) { if (value == null) { return null; } ClassMeta meta = ClassMeta.classMeta(clz); List<ConstructorAccess> constructors = meta.oneArgumentConstructors(); if (constructors.size() == 0) { return null; } else if (constructors.size() == 1) { ConstructorAccess constructorAccess = constructors.get(0); Class<?> arg1Type = constructorAccess.parameterTypes()[0]; if (arg1Type.isInstance(value)) { return (T) constructorAccess.create(value); } else { return (T) constructorAccess.create(coerce(arg1Type, value)); } } else { for (ConstructorAccess c : constructors) { Class<?> arg1Type = c.parameterTypes()[0]; if (arg1Type.isInstance(value)) { return (T) c.create(value); } } for (ConstructorAccess c : constructors) { Class<?> arg1Type = c.parameterTypes()[0]; if (arg1Type.isAssignableFrom(value.getClass())) { return (T) c.create(value); } } } return null; }
/** * This flattens a list. * * @param o object that might be a list * @param list list to add o to or all of o's items to. * @return an object or a list */ public static Object unifyListOrArray(Object o, List list) { if (o == null) { return null; } boolean isArray = o.getClass().isArray(); if (list == null && !isArray && !(o instanceof Iterable)) { return o; } if (list == null) { list = new LinkedList(); } if (isArray) { int length = Array.getLength(o); for (int index = 0; index < length; index++) { Object o1 = Array.get(o, index); if (o1 instanceof Iterable || o.getClass().isArray()) { unifyListOrArray(o1, list); } else { list.add(o1); } } } else if (o instanceof Collection) { Collection i = ((Collection) o); for (Object item : i) { if (item instanceof Iterable || o.getClass().isArray()) { unifyListOrArray(item, list); } else { list.add(item); } } } else { list.add(o); } return list; }
/** * Converts the value to boolean, and if it is null, it uses the default value passed. * * @param obj value to convert to boolean * @param defaultValue default value * @return obj converted to boolean */ public static boolean toBoolean(Object obj, boolean defaultValue) { if (obj == null) { return defaultValue; } if (obj instanceof Boolean) { return ((Boolean) obj).booleanValue(); } else if (obj instanceof Number || obj.getClass().isPrimitive()) { int value = toInt(obj); return value != 0 ? true : false; } else if (obj instanceof String || obj instanceof CharSequence) { String str = Conversions.toString(obj); if (str.length() == 0) { return false; } if (str.equals("false")) { return false; } else { return true; } } else if (Boon.isArray(obj)) { return Boon.len(obj) > 0; } else if (obj instanceof Collection) { if (len(obj) > 0) { List list = Lists.list((Collection) obj); while (list.remove(null)) {} return Lists.len(list) > 0; } else { return false; } } else { return toBoolean(Conversions.toString(obj)); } }
/** * This flattens a list. * * @param o object that might be a list * @param list list to add o to or all of o's items to. * @return an object or a list */ public static Object unifyList(Object o, List list) { if (o == null) { return null; } if (list == null) { list = new ArrayList(); } if (o instanceof Iterable) { Iterable i = ((Iterable) o); for (Object item : i) { unifyListOrArray(item, list); } } else { list.add(o); } return list; }
public static <T> T coerceWithFlag( TypeType coerceTo, Class<T> clz, boolean[] flag, Object value) { flag[0] = true; if (value == null) { return null; } if (clz.isInstance(value)) { return (T) value; } switch (coerceTo) { case STRING: case CHAR_SEQUENCE: return (T) value.toString(); case INT: case INTEGER_WRAPPER: Integer i = toInt(value); if (i == Integer.MIN_VALUE) { flag[0] = false; } return (T) i; case SHORT: case SHORT_WRAPPER: Short s = toShort(value); if (s == Short.MIN_VALUE) { flag[0] = false; } return (T) s; case BYTE: case BYTE_WRAPPER: Byte by = toByte(value); if (by == Byte.MIN_VALUE) { flag[0] = false; } return (T) by; case CHAR: case CHAR_WRAPPER: Character ch = toChar(value); if (ch == (char) 0) { flag[0] = false; } return (T) ch; case LONG: case LONG_WRAPPER: Long l = toLong(value); if (l == Long.MIN_VALUE) { flag[0] = false; } return (T) l; case DOUBLE: case DOUBLE_WRAPPER: Double d = toDouble(value); if (d == Double.MIN_VALUE) { flag[0] = false; } return (T) d; case FLOAT: case FLOAT_WRAPPER: Float f = toFloat(value); if (f == Float.MIN_VALUE) { flag[0] = false; } return (T) f; case DATE: return (T) toDate(value); case BIG_DECIMAL: return (T) toBigDecimal(value); case BIG_INT: return (T) toBigInteger(value); case CALENDAR: return (T) toCalendar(toDate(value)); case BOOLEAN: case BOOLEAN_WRAPPER: return (T) (Boolean) toBooleanOrDie(value); case MAP: return (T) toMap(value); case ARRAY: case ARRAY_INT: case ARRAY_BYTE: case ARRAY_SHORT: case ARRAY_FLOAT: case ARRAY_DOUBLE: case ARRAY_LONG: case ARRAY_STRING: case ARRAY_OBJECT: return toPrimitiveArrayIfPossible(clz, value); case COLLECTION: return toCollection(clz, value); case INSTANCE: if (value instanceof Map) { return MapObjectConversion.fromMap((Map<String, Object>) value, clz); } else if (value instanceof List) { return MapObjectConversion.fromList((List<Object>) value, clz); } else if (clz.isInstance(value)) { return (T) value; } else { ClassMeta meta = ClassMeta.classMeta(clz); List<ConstructorAccess> constructors = meta.oneArgumentConstructors(); if (constructors.size() == 0) { return null; } else if (constructors.size() == 1) { ConstructorAccess constructorAccess = constructors.get(0); Class<?> arg1Type = constructorAccess.parameterTypes()[0]; if (arg1Type.isInstance(value)) { return (T) constructorAccess.create(value); } else { return (T) constructorAccess.create(coerce(arg1Type, value)); } } else { for (ConstructorAccess c : constructors) { Class<?> arg1Type = c.parameterTypes()[0]; if (arg1Type.isInstance(value)) { return (T) c.create(value); } } for (ConstructorAccess c : constructors) { Class<?> arg1Type = c.parameterTypes()[0]; if (arg1Type.isAssignableFrom(value.getClass())) { return (T) c.create(value); } } flag[0] = false; break; } } case ENUM: return (T) toEnum((Class<? extends Enum>) clz, value); case CLASS: return (T) toClass(value); case TIME_ZONE: return (T) toTimeZone(flag, value); case UUID: return (T) toUUID(flag, value); case CURRENCY: return (T) toCurrency(value); case OBJECT: return (T) value; default: flag[0] = false; break; } return null; }