@SuppressWarnings("unchecked")
public static <T> T coerceClassic(Class<T> clz, Object value) {
if (clz == null || value == null) {
return null;
}
if (clz == value.getClass()) {
return (T) value;
}
if (clz == Typ.string || clz == Typ.chars) {
return (T) value.toString();
} else if (clz == Typ.integer || clz == Typ.intgr) {
Integer i = toInt(value);
return (T) i;
} else if (clz == Typ.longWrapper || clz == Typ.lng) {
Long l = toLong(value);
return (T) l;
} else if (clz == Typ.doubleWrapper || clz == Typ.dbl) {
Double i = toDouble(value);
return (T) i;
} else if (clz == Typ.date) {
return (T) toDate(value);
} else if (clz == Typ.bigInteger) {
return (T) toBigInteger(value);
} else if (clz == Typ.bigDecimal) {
return (T) toBigDecimal(value);
} else if (clz == Typ.calendar) {
return (T) toCalendar(toDate(value));
} else if (clz == Typ.floatWrapper || clz == Typ.flt) {
Float i = toFloat(value);
return (T) i;
} else if (clz == Typ.stringArray) {
die("Need to fix this");
return null;
} else if (clz == Typ.bool || clz == Typ.bln) {
Boolean b = toBoolean(value);
return (T) b;
} else if (Typ.isMap(clz)) {
return (T) toMap(value);
} else if (clz.isArray()) {
return toPrimitiveArrayIfPossible(clz, value);
} else if (Typ.isCollection(clz)) {
return toCollection(clz, value);
} else if (clz.getPackage() != null
&& !clz.getPackage().getName().startsWith("java")
&& Typ.isMap(value.getClass())
&& Typ.doesMapHaveKeyTypeString(value)) {
return (T) MapObjectConversion.fromMap((Map<String, Object>) value);
} else if (clz.isEnum()) {
return (T) toEnum((Class<? extends Enum>) clz, value);
} else {
return null;
}
}
public static <T> T coerce(TypeType coerceTo, Class<T> clz, Object value) {
if (value == null) {
if (coerceTo != TypeType.INSTANCE && !clz.isPrimitive()) {
return null;
} else if (clz.isPrimitive()) {
if (clz == boolean.class) {
return (T) (Boolean) false;
}
return (T) (Number) 0;
}
}
switch (coerceTo) {
case STRING:
case CHAR_SEQUENCE:
return (T) value.toString();
case NUMBER:
if (value instanceof Number) {
return (T) value;
} else {
Double d = toDouble(value);
return (T) d;
}
case INT:
case INTEGER_WRAPPER:
Integer i = toInt(value);
return (T) i;
case SHORT:
case SHORT_WRAPPER:
Short s = toShort(value);
return (T) s;
case BYTE:
case BYTE_WRAPPER:
Byte by = toByte(value);
return (T) by;
case CHAR:
case CHAR_WRAPPER:
Character ch = toChar(value);
return (T) ch;
case LONG:
case LONG_WRAPPER:
Long l = toLong(value);
return (T) l;
case DOUBLE:
case DOUBLE_WRAPPER:
Double d = toDouble(value);
return (T) d;
case FLOAT:
case FLOAT_WRAPPER:
Float f = toFloat(value);
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) toBoolean(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 LIST:
case SET:
case COLLECTION:
return toCollection(clz, value);
case INSTANCE:
if (value instanceof Value) {
value = ((Value) value).toValue();
}
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 {
return createFromArg(clz, value);
}
case ENUM:
return (T) toEnum((Class<? extends Enum>) clz, value);
case PATH:
return (T) IO.path(value.toString());
case CLASS:
return (T) toClass(value);
case TIME_ZONE:
return (T) toTimeZone(value);
case UUID:
return (T) toUUID(value);
case CURRENCY:
return (T) toCurrency(value);
case OBJECT:
return (T) value;
case HANDLER:
return (T) value;
default:
return createFromArg(clz, value);
}
}
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;
}
public static Map<String, Object> toMap(Object value) {
return MapObjectConversion.toMap(value);
}
