Refine search
private String getElementTypes (JField f) { StringBuilder b = new StringBuilder(); JParameterizedType params = f.getType().isParameterized(); if (params != null) { JClassType[] typeArgs = params.getTypeArgs(); b.append("new Class[] {"); for (JClassType typeArg : typeArgs) { if (typeArg.isWildcard() != null) b.append("null"); else if (!isVisible(typeArg)) b.append("null"); else if (typeArg.isClassOrInterface() != null) b.append(typeArg.isClassOrInterface().getQualifiedSourceName()).append(".class"); else if (typeArg.isParameterized() != null) b.append(typeArg.isParameterized().getQualifiedBinaryName()).append(".class"); else b.append("null"); b.append(", "); } b.append("}"); return b.toString(); } return "null"; }
@Override public String createAssignment(TreeLogger logger, ResourceContext context, JMethod method) throws UnableToCompleteException { JParameterizedType returnType = method.getReturnType().isParameterized(); assert returnType != null; JClassType args[] = returnType.getTypeArgs(); assert args.length == 1; ClassType override = method.getAnnotation(ClassType.class); JClassType toCreate; if (override != null) { toCreate = context.getGeneratorContext().getTypeOracle().findType( override.value().getName().replace('$', '.')); assert toCreate != null; } else { toCreate = args[0]; } JClassType gwtType = context.getGeneratorContext().getTypeOracle().findType( GWT.class.getName()); assert gwtType != null; return "new " + returnType.getParameterizedQualifiedSourceName() + "() {\n public " + toCreate.getQualifiedSourceName() + " create() {\n return " + gwtType.getQualifiedSourceName() + ".create(" + toCreate.getQualifiedSourceName() + ".class);}\n" + "public String getName() { return \"" + method.getName() + "\";}}"; } }
JPrimitiveType primitiveType = type.isPrimitive(); if (primitiveType != null) { return primitiveType.getJNISignature(); JArrayType arrayType = type.isArray(); if (arrayType != null) { JType component = arrayType.getComponentType(); if (component.isClassOrInterface() != null) { return "[L" + getRpcTypeName(arrayType.getComponentType()) + ";"; } else { JParameterizedType parameterizedType = type.isParameterized(); if (parameterizedType != null) { return getRpcTypeName(parameterizedType.getBaseType()); assert (classType != null); JClassType enclosingType = classType.getEnclosingType(); if (enclosingType != null) { return getRpcTypeName(enclosingType) + "$" + classType.getSimpleSourceName(); return classType.getQualifiedSourceName();
String simplePropertyTypeName = propertyType.getSimpleSourceName(); String modelName = this.subModels.get(propertyType); if (modelName != null) { modelName += ".INSTANCE"; if (ModelCreator.COLLECTION_TYPES.contains(propertyType.getQualifiedSourceName())) { JParameterizedType parametrizedType = propertyType.isParameterized(); JType subType = propertyType; if (parametrizedType != null) { subType = parametrizedType.getTypeArgs()[0]; String submodelName = this.subModels.get(subType); if (submodelName != null) { logger.branch(Type.WARN, String.format( "Property [%s] on bean %s is a raw collection type. You cannot use it on editors.", propertyName, this.beanType.getQualifiedSourceName())); modelName = "new ModelCollection((Model) null)";
throws UnableToCompleteException { JType returnType = method.getReturnType(); JPrimitiveType primitive = returnType.isPrimitive(); if (primitive != null && (primitive == JPrimitiveType.BOOLEAN return; JArrayType arrayType = returnType.isArray(); if (arrayType != null) { String arrayComponent = arrayType.getComponentType().getQualifiedSourceName(); if (!arrayComponent.equals("java.lang.String")) { throw error(logger, JParameterizedType paramType = returnType.isParameterized(); if (paramType != null) { JClassType[] typeArgs = paramType.getTypeArgs(); if (typeArgs.length != 2 || !typeArgs[0].getQualifiedSourceName().equals("java.lang.String") || !typeArgs[1].getQualifiedSourceName().equals("java.lang.String")) { throw error(logger, "Map Methods in interfaces extending Constant must be raw or <String, String>");
w.println(); JMethod[] methods = requestedType.getMethods(); JClassType cbType = typeOracle.findType( params[params.length - 1].getType().getQualifiedSourceName() ); if( cbType == null ) w.println( "*** ERROR : Unable to find callback type : " + params[params.length - 1].getType().getQualifiedSourceName() ); return; JParameterizedType returnTypeParametrized = returnType.isParameterized(); if( returnTypeParametrized == null ) logger.log( Type.WARN, "When generating method " + method.getName() + " for server side service interface " + requestedType.getName() + ", return type was not found. This method will not be declared for the server." ); continue; JClassType[] returnTypeTypeParameters = returnTypeParametrized.getTypeArgs(); assert returnTypeTypeParameters.length == 1; String returnTypeName = returnTypeTypeParameters[0].getParameterizedQualifiedSourceName();
JMethod[] methods = ownerType.getMethods(); for (JMethod method : methods) { if (method.isAnnotationPresent(UiFactory.class)) { JClassType factoryType = method.getReturnType().isClassOrInterface(); JParameterizedType paramType = factoryType.isParameterized(); if (paramType != null) { factoryType = paramType.getRawType(); + method.getEnclosingType().getName() + " for type " + factoryType.getName());
/** * Given type assignable to <code>ComposedEditor<Foo,Bar></code>, return * <code>{Foo, Bar}</code>. It is an error to call this method with a type not * assignable to {@link ComposedEditor}. */ static JClassType[] calculateCompositeTypes(JClassType editorType) { JClassType compositeEditorIntf = editorType.getOracle().findType( CompositeEditor.class.getName()); assert compositeEditorIntf.isAssignableFrom(editorType) : editorType.getQualifiedSourceName() + " is not a ComposedEditor"; for (JClassType supertype : editorType.getFlattenedSupertypeHierarchy()) { JParameterizedType parameterized = supertype.isParameterized(); if (parameterized != null) { // Found the Editor<Foo> supertype if (compositeEditorIntf.equals(parameterized.getBaseType())) { JClassType[] typeArgs = parameterized.getTypeArgs(); assert typeArgs.length == 3; return new JClassType[] {typeArgs[1], typeArgs[2]}; } } } assert false : "Did not find ComposedEditor parameterization for " + editorType.getQualifiedSourceName(); throw new RuntimeException(); }
JClassType[] paramType = type.isParameterized().getTypeArgs(); assert (paramType.length == 2); String keyTypeName = keyType.getParameterizedQualifiedSourceName(); JType valueType = paramType[1]; String valueMarshallName = getParamMarshall( valueType ); sw.println( "MapMarshall<" + keyTypeName + "," + valueType.getParameterizedQualifiedSourceName() + "> " + marshallName + " = new MapMarshall<" + keyTypeName + "," + valueType.getParameterizedQualifiedSourceName() + ">( " + valueMarshallName + " );" ); JClassType[] paramType = type.isParameterized().getTypeArgs(); assert (paramType.length == 1); JClassType[] paramType = type.isParameterized().getTypeArgs(); assert (paramType.length == 1); if( c != null ) JType[] interfaces = c.getImplementedInterfaces(); for( int i = 0; i < interfaces.length; i++ ) sw.println( interfaces[i].getQualifiedSourceName() );
JMethod method = eventType.findMethod("getAssociatedType", new JType[0]); if (method == null) { logger.warn( "Method 'getAssociatedType()' could not be found in the event '%s'.", eventType.getName()); return null; logger.warn( "The method 'getAssociatedType()' in the event '%s' returns void.", eventType.getName()); return null; JParameterizedType isParameterized = returnType.isParameterized(); if (isParameterized == null) { logger.warn( JClassType[] argTypes = isParameterized.getTypeArgs(); if ((argTypes.length != 1) && !argTypes[0].isAssignableTo(eventHandlerJClass)) {
public JClassType getAssociationType(PropertyDescriptor p, boolean useField) { JType type = this.getElementType(p, useField); JArrayType jArray = type.isArray(); if (jArray != null) { return jArray.getComponentType().isClassOrInterface(); } JParameterizedType pType = type.isParameterized(); JClassType[] typeArgs; if (pType == null) { JRawType rType = type.isRawType(); typeArgs = rType.getGenericType().getTypeParameters(); } else { typeArgs = pType.getTypeArgs(); } // it is either a Iterable or a Map use the last type arg. return typeArgs[typeArgs.length - 1].isClassOrInterface(); }
/** * Returns a simple qualified name for simple types, including classes and * interfaces, parameterized, and raw types. Null is returned for other types * such as arrays and type parameters (e.g., 'E' in java.util.List<E>) because * filtering is meaningless for such types. */ private String getBaseTypeName(JClassType type) { JClassType baseType = null; if (type instanceof JRealClassType) { baseType = type; } else if (type.isParameterized() != null) { baseType = type.isParameterized().getBaseType(); } else if (type.isRawType() != null) { baseType = type.isRawType(); } return baseType == null ? null : baseType.getQualifiedSourceName(); } }
private JClassType getBeanType(TreeLogger logger, JClassType validator, JClassType gwtSpecificInterface) throws UnableToCompleteException { if (gwtSpecificInterface instanceof JParameterizedType) { JParameterizedType paramType = (JParameterizedType) gwtSpecificInterface; return paramType.getTypeArgs()[0]; } logger.log(TreeLogger.ERROR, validator.getQualifiedSourceName() + " must implement " + GwtSpecificValidator.class.getCanonicalName() + " with a one generic parameter.", null); throw new UnableToCompleteException(); }
public static JClassType[] findParameterizationOf(JClassType intfType, JClassType subType) { assert intfType.isAssignableFrom(subType) : subType.getParameterizedQualifiedSourceName() + " is not assignable to " + subType.getParameterizedQualifiedSourceName(); for (JClassType supertype : subType.getFlattenedSupertypeHierarchy()) { JParameterizedType parameterized = supertype.isParameterized(); if (parameterized != null) { // Found the desired supertype if (intfType.equals(parameterized.getBaseType())) { return parameterized.getTypeArgs(); } } } return null; }
private boolean checkSubtype(TreeLogger logger, JClassType classOrInterface, JClassType originalType, TypePath parent, ProblemReport problems) { if (classOrInterface.isEnum() != null) { JParameterizedType isParameterized = classOrInterface.isParameterized(); if (isParameterized != null) { if (isRawMapOrRawCollection(classOrInterface)) { TreeLogger paramsLogger = logger.branch(TreeLogger.DEBUG, "Checking parameters of '" + isParameterized.getParameterizedQualifiedSourceName() + "'"); for (JTypeParameter param : isParameterized.getBaseType().getTypeParameters()) { if (!checkTypeArgument(paramsLogger, isParameterized.getBaseType(), param.getOrdinal(), isParameterized.getTypeArgs()[param.getOrdinal()], parent, problems)) { return false; JClassType superType = classOrInterface.getSuperclass(); if (superType != null && superType.isRawType() != null) { superType = superType.isRawType().asParameterizedByWildcards();
private static void generateSerializationSignature(GeneratorContext context, JType type, CRC32 crc) throws UnsupportedEncodingException { JParameterizedType parameterizedType = type.isParameterized(); if (parameterizedType != null) { generateSerializationSignature(context, parameterizedType.getRawType(), crc); if (customSerializer != null) { generateSerializationSignature(context, customSerializer, crc); } else if (type.isArray() != null) { JArrayType isArray = type.isArray(); generateSerializationSignature(context, isArray.getComponentType(), crc); } else if (type.isEnum() != null) { JClassType superClass = isClassOrInterface.getSuperclass(); if (superClass != null) { generateSerializationSignature(context, superClass, crc);
private String generateTypeParmString(JParameterizedType t) { StringBuilder builder = new StringBuilder("<"); JClassType[] typeArgs = t.getTypeArgs(); for (int i = 0, typeArgsLength = typeArgs.length; i < typeArgsLength; i++) { JClassType c = typeArgs[i]; builder.append(c.getQualifiedSourceName()); JParameterizedType pt = c.isParameterized(); if (pt != null) builder.append(generateTypeParmString(pt)); if ((i + 1) < typeArgsLength) builder.append(","); } return builder.append(">").toString(); }
public String init(TypeOracle oracle, JField targetWidgetField, JType targetType, JField targetEntityMember, JField targetEntityField, String variable, List<JField> fields) { JClassType widgetCollectionType = targetWidgetField.getType().isClassOrInterface(); JClassType entityCollectionType = targetEntityMember.getType().isClassOrInterface(); JParameterizedType paramaterizedType = widgetCollectionType.isParameterized(); if (paramaterizedType == null) { throw new RuntimeException("cannot generateGetField mappers for collection of widgets (the collection is not properly parameterized: eg. List<Widget>)"); } JClassType widgetType = paramaterizedType.getTypeArgs()[0]; varName = targetEntityField.getType().isClassOrInterface().getName() + targetWidgetField.getName() + "Mapper"; if (compiledTemplate == null) { InputStream istream = this.getClass().getResourceAsStream("CollectionFMGenerator.mv"); compiledTemplate = TemplateCompiler.compileTemplate(istream, null); } Map vars = new HashMap(); vars.put("typeOracle", oracle); vars.put("targetWidgetField", targetWidgetField); vars.put("targetEntityField", targetEntityField); vars.put("targetEntityMember", targetEntityMember); vars.put("widgetType", widgetType); vars.put("entityCollectionType", entityCollectionType); vars.put("widgetCollectionType", widgetCollectionType); vars.put("varName", varName); return String.valueOf(TemplateRuntime.execute(compiledTemplate, vars)); }
JParameterizedType isParameterized = type.isParameterized(); if (isParameterized != null) { return getCallSuffix(isParameterized.getRawType()); } else if (type.isPrimitive() != null) { if (type == JPrimitiveType.BOOLEAN) { return "Boolean"; return null; } else if (type.getQualifiedSourceName().equals("java.lang.String")) { return "String"; } else {
private JClassType getTargetType(JClassType interfaceType, TypeOracle typeOracle) { JClassType[] superTypes = interfaceType.getImplementedInterfaces(); JClassType eventBinderType = typeOracle.findType(EventBinder.class.getCanonicalName()); if (superTypes.length != 1 || !superTypes[0].isAssignableFrom(eventBinderType) || superTypes[0].isParameterized() == null) { throw new IllegalArgumentException( interfaceType + " must extend EventBinder with a type parameter"); } return superTypes[0].isParameterized().getTypeArgs()[0]; }