private static boolean isType(JClassType type, Class<?> class1) {
try {
return type.getOracle().getType(class1.getName()).isAssignableFrom(type);
} catch (NotFoundException e) {
throw new RuntimeException("Could not find " + class1.getName(), e);
}
}
public RequestFactoryModel(TreeLogger logger, JClassType factoryType)
throws UnableToCompleteException {
this.logger = logger;
this.factoryType = factoryType;
this.oracle = factoryType.getOracle();
collectionInterface = oracle.findType(Collection.class.getCanonicalName());
entityProxyInterface = oracle.findType(EntityProxy.class.getCanonicalName());
instanceRequestInterface = oracle.findType(InstanceRequest.class.getCanonicalName());
listInterface = oracle.findType(List.class.getCanonicalName());
mapInterface = oracle.findType(Map.class.getCanonicalName());
requestContextInterface = oracle.findType(RequestContext.class.getCanonicalName());
requestFactoryInterface = oracle.findType(RequestFactory.class.getCanonicalName());
requestInterface = oracle.findType(Request.class.getCanonicalName());
setInterface = oracle.findType(Set.class.getCanonicalName());
splittableType = oracle.findType(Splittable.class.getCanonicalName());
valueProxyInterface = oracle.findType(ValueProxy.class.getCanonicalName());
extraTypes = checkExtraTypes(factoryType, false);
for (JMethod method : factoryType.getOverridableMethods()) {
if (method.getEnclosingType().equals(requestFactoryInterface)) {
// Ignore methods defined an RequestFactory itself
continue;
}
if (method.getParameters().length > 0) {
poison("Unexpected parameter on method %s", method.getName());
continue;
}
JClassType contextType = method.getReturnType().isInterface();
if (contextType == null || !requestContextInterface.isAssignableFrom(contextType)) {
poison(
"Unexpected return type %s on method %s is not" + " an interface assignable to %s",
method.getReturnType().getQualifiedSourceName(),
method.getName(),
requestContextInterface.getSimpleSourceName());
continue;
}
ContextMethod.Builder builder = new ContextMethod.Builder();
builder.setDeclaredMethod(method);
buildContextMethod(builder, contextType);
contextMethods.add(builder.build());
}
if (poisoned) {
die(poisonedMessage());
}
}
private void checkSerializable(TreeLogger logger, JClassType type)
throws UnableToCompleteException {
JClassType javaSerializable = type.getOracle().findType(Serializable.class.getName());
boolean serializable = type.isAssignableTo(javaSerializable);
if (!serializable) {
boolean abortCompile = "true".equals(System.getProperty(FAIL_IF_NOT_SERIALIZABLE));
logger.log(
abortCompile ? Type.ERROR : Type.WARN,
type
+ " is used in RPC or shared state but does not implement "
+ Serializable.class.getName()
+ ". Communication will work but the Application on server side cannot be serialized if it refers to objects of this type. "
+ "If the system property "
+ FAIL_IF_NOT_SERIALIZABLE
+ " is set to \"true\", this causes the compilation to fail instead of just emitting a warning.");
if (abortCompile) {
throw new UnableToCompleteException();
}
}
}
protected String getDataObjectReadExpression(JClassType dataObjectType, String bindPath)
throws NoSuchFieldException {
StringBuilder getExpression = new StringBuilder();
bindPathType =
JClassUtils.buildGetValueExpression(
getExpression, dataObjectType, bindPath, DATA_OBJECT_VAR_REF, false, true);
String converterVariable = getConverterVariable();
if (converterVariable != null) {
getExpression.insert(0, converterVariable + ".to(").append(")");
JClassType typeConverterType =
converterType.getOracle().findType(TypeConverter.class.getCanonicalName());
JClassType[] types = JClassUtils.getActualParameterTypes(converterType, typeConverterType);
bindInfoType = types[1];
} else {
bindInfoType = bindPathType;
}
// TODO validate conveter type and expression type here
return "(" + getExpression.toString() + ")";
}
/**
* Returns <code>true</code> if the lhs and rhs are assignable without consideration of the
* supertypes of the rhs.
*
* @param lhsType
* @param rhsType
* @return true if rhsType can be assigned to lhsType
*/
private static boolean areClassTypesAssignableNoSupers(JClassType lhsType, JClassType rhsType) {
if (lhsType == rhsType) {
// Done, these are the same types.
return true;
}
if (lhsType == lhsType.getOracle().getJavaLangObject()) {
// Done, any type can be assigned to object.
return true;
}
/*
* Get the generic base type, if there is one, for the lhs type and convert
* it to a raw type if it is generic.
*/
if (lhsType.isGenericType() != null) {
lhsType = lhsType.isGenericType().getRawType();
}
if (rhsType.isGenericType() != null) {
// Treat the generic rhs type as a raw type.
rhsType = rhsType.isGenericType().getRawType();
}
// Check for JTypeParameters.
JTypeParameter lhsTypeParam = lhsType.isTypeParameter();
JTypeParameter rhsTypeParam = rhsType.isTypeParameter();
if (lhsTypeParam != null) {
JClassType[] lhsTypeBounds = lhsTypeParam.getBounds();
for (JClassType lhsTypeBound : lhsTypeBounds) {
if (!areClassTypesAssignable(lhsTypeBound, rhsType)) {
// Done, the rhsType was not assignable to one of the bounds.
return false;
}
}
// Done, the rhsType was assignable to all of the bounds.
return true;
} else if (rhsTypeParam != null) {
JClassType[] possibleSubtypeBounds = rhsTypeParam.getBounds();
for (JClassType possibleSubtypeBound : possibleSubtypeBounds) {
if (areClassTypesAssignable(lhsType, possibleSubtypeBound)) {
// Done, at least one bound is assignable to this type.
return true;
}
}
return false;
}
/*
* Check for JWildcards. We have not examined this part in great detail
* since there should not be top level wildcard types.
*/
JWildcardType lhsWildcard = lhsType.isWildcard();
JWildcardType rhsWildcard = rhsType.isWildcard();
if (lhsWildcard != null && rhsWildcard != null) {
// Both types are wildcards.
return areWildcardsAssignable(lhsWildcard, rhsWildcard);
} else if (lhsWildcard != null) {
// The lhs type is a wildcard but the rhs is not.
// ? extends T, U OR ? super T, U
JClassType[] lowerBounds = lhsWildcard.getLowerBounds();
if (lowerBounds.length > 0) {
// ? super T will reach object no matter what the rhs type is
return true;
} else {
return areClassTypesAssignable(lhsWildcard.getFirstBound(), rhsType);
}
}
// Check for JArrayTypes.
JArrayType lhsArray = lhsType.isArray();
JArrayType rhsArray = rhsType.isArray();
if (lhsArray != null) {
if (rhsArray == null) {
return false;
} else {
return areArraysAssignable(lhsArray, rhsArray);
}
} else if (rhsArray != null) {
// Safe although perhaps not necessary
return false;
}
// Check for JParameterizedTypes and JRawTypes.
JMaybeParameterizedType lhsMaybeParameterized = lhsType.isMaybeParameterizedType();
JMaybeParameterizedType rhsMaybeParameterized = rhsType.isMaybeParameterizedType();
if (lhsMaybeParameterized != null && rhsMaybeParameterized != null) {
if (lhsMaybeParameterized.getBaseType() == rhsMaybeParameterized.getBaseType()) {
if (lhsMaybeParameterized.isRawType() != null
|| rhsMaybeParameterized.isRawType() != null) {
/*
* Any raw type can be assigned to or from any parameterization of its
* generic type.
*/
return true;
}
assert (lhsMaybeParameterized.isRawType() == null
&& rhsMaybeParameterized.isRawType() == null);
JParameterizedType lhsParameterized = lhsMaybeParameterized.isParameterized();
JParameterizedType rhsParameterized = rhsMaybeParameterized.isParameterized();
assert (lhsParameterized != null && rhsParameterized != null);
return areTypeArgumentsAssignable(lhsParameterized, rhsParameterized);
}
}
// Default to not being assignable.
return false;
}
