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; }