public static boolean isNumericallyCoercible(final MetaClass target, final MetaClass parm) {
MetaClass boxedTarget = target.isPrimitive() ? target.asBoxed() : target;
if (boxedTarget != null && Number_MetaClass.isAssignableFrom(target)) {
if ((boxedTarget = parm.isPrimitive() ? parm.asBoxed() : parm) != null) {
return Number_MetaClass.isAssignableFrom(boxedTarget);
}
}
return false;
}
public static int scoreMethods(
final MetaClass[] arguments, final MetaParameter[] parmTypes, final boolean isVarArgs) {
int score = 0;
for (int i = 0; i != arguments.length; i++) {
final MetaClass actualParamType;
if (isVarArgs && !arguments[arguments.length - 1].isArray() && i >= parmTypes.length - 1)
actualParamType = parmTypes[parmTypes.length - 1].getType().getComponentType();
else actualParamType = parmTypes[i].getType();
if (arguments[i] == null) {
if (!actualParamType.isPrimitive()) {
score += 6;
} else {
score = 0;
break;
}
} else if (actualParamType.equals(arguments[i])) {
score += 7;
} else if (actualParamType.isPrimitive() && actualParamType.asBoxed().equals(arguments[i])) {
score += 6;
} else if (arguments[i].isPrimitive() && arguments[i].asUnboxed().equals(actualParamType)) {
score += 6;
} else if (actualParamType.isAssignableFrom(arguments[i])) {
score += 5;
} else if (isNumericallyCoercible(arguments[i], actualParamType)) {
score += 4;
} else if (actualParamType.asBoxed().isAssignableFrom(arguments[i].asBoxed())
&& !Object_MetaClass.equals(arguments[i])) {
score += 3 + scoreInterface(actualParamType, arguments[i]);
} else if (canConvert(actualParamType, arguments[i])) {
if (actualParamType.isArray() && arguments[i].isArray()) {
final MetaClass outerComponentTypeActual = actualParamType.getOuterComponentType();
final MetaClass outerComponentTypeArg = arguments[i].getOuterComponentType();
if (canConvert(outerComponentTypeActual, outerComponentTypeArg)) {
score += 1;
} else {
continue;
}
} else if (actualParamType.equals(char_MetaClass)
&& arguments[i].equals(String_MetaClass)) {
score += 1;
}
score += 1;
} else if (actualParamType.equals(Object_MetaClass)
|| arguments[i].equals(NullType_MetaClass)) {
score += 1;
} else {
score = 0;
break;
}
}
return score;
}
private static Statement paramFromStringStatement(MetaClass toType, Statement stringValue) {
// make sure it's really a string
stringValue = Stmt.castTo(String.class, stringValue);
if (toType.isAssignableTo(String.class)) {
return stringValue;
} else if (toType.asBoxed().isAssignableTo(Number.class)) {
return Stmt.invokeStatic(toType.asBoxed(), "valueOf", stringValue);
} else if (toType.asBoxed().isAssignableTo(Boolean.class)) {
return Stmt.invokeStatic(Boolean.class, "valueOf", stringValue);
} else {
throw new UnsupportedOperationException(
"@PageState fields of type " + toType.getFullyQualifiedName() + " are not supported");
}
}
public static void assertAssignableTypes(
final Context context, final MetaClass from, final MetaClass to) {
if (!to.asBoxed().isAssignableFrom(from.asBoxed())) {
if (to.isArray()
&& from.isArray()
&& GenUtil.getArrayDimensions(to) == GenUtil.getArrayDimensions(from)
&& to.getOuterComponentType().isAssignableFrom(from.getOuterComponentType())) {
return;
}
if (!context.isPermissiveMode()) {
if (classAliases.contains(from.getFullyQualifiedName())
&& classAliases.contains(to.getFullyQualifiedName())) {
// handle convertibility between MetaClass API and java Class reference.
return;
}
throw new InvalidTypeException(
to.getFullyQualifiedName() + " is not assignable from " + from.getFullyQualifiedName());
}
}
}
private Statement defaultValueStatement(MetaClass type) {
if (type.isPrimitive()) {
if (type.asBoxed().isAssignableTo(Number.class)) {
return Stmt.castTo(type, Stmt.load(0));
} else if (type.isAssignableTo(boolean.class)) {
return Stmt.load(false);
} else {
throw new UnsupportedOperationException(
"Don't know how to make a default value for @PageState field of type "
+ type.getFullyQualifiedName());
}
} else {
return Stmt.load(null);
}
}
public static Statement convert(final Context context, Object input, final MetaClass targetType) {
try {
if (input instanceof Statement) {
if (input instanceof LiteralValue<?>) {
input = ((LiteralValue<?>) input).getValue();
} else {
if ("null".equals(((Statement) input).generate(context))) {
return (Statement) input;
}
assertAssignableTypes(context, ((Statement) input).getType(), targetType);
return (Statement) input;
}
}
if (input != null
&& MetaClassFactory.get(input.getClass())
.getOuterComponentType()
.getFullyQualifiedName()
.equals(MetaClass.class.getName())) {
return generate(context, input);
}
if (Object.class.getName().equals(targetType.getFullyQualifiedName())) {
return generate(context, input);
}
Class<?> inputClass = input == null ? Object.class : input.getClass();
if (MetaClass.class.isAssignableFrom(inputClass)) {
inputClass = Class.class;
}
final Class<?> targetClass = targetType.asBoxed().asClass();
if (NullType.class.getName().equals(targetClass.getName())) {
return generate(context, input);
}
if (!targetClass.isAssignableFrom(inputClass)
&& DataConversion.canConvert(targetClass, inputClass)) {
return generate(context, DataConversion.convert(input, targetClass));
} else {
return generate(context, input);
}
} catch (NumberFormatException nfe) {
throw new InvalidTypeException(nfe);
}
}
