public static String getSimpleTypeName(Type type) { if (type instanceof ParameterizedType) { String typeName = type.typeName() + "<"; boolean firstParameter = true; for (Type parameter : ((ParameterizedType) type).typeArguments()) { if (firstParameter) { typeName += getSimpleTypeName(parameter); firstParameter = false; } else { typeName += "," + getSimpleTypeName(parameter); } } typeName += ">"; return typeName; } return type.typeName(); }
protected static IndentingPrintWriter writeTypeTo(IndentingPrintWriter out, Type type) { if (type != null) { out.append(type.typeName()); final ParameterizedType parameterizedType = type.asParameterizedType(); if (parameterizedType != null) { final Type[] generics = parameterizedType.typeArguments(); if (generics.length > 0) { out.append("<"); String sep = ""; for (Type generic : generics) { writeTypeTo(out.append(sep), generic); sep = ", "; } out.append(">"); } } out.append(type.dimension()); } return out; }
private void addAllInterfaceTypes(Map results, Type type, Type[] interfaceTypes, boolean raw) { for (int i = 0; i < interfaceTypes.length; i++) { Type interfaceType = interfaceTypes[i]; ClassDoc interfaceClassDoc = interfaceType.asClassDoc(); if (! (interfaceClassDoc.isPublic() || interfaceClassDoc.isIncluded())) { continue; } if (raw) interfaceType = interfaceType.asClassDoc(); results.put(interfaceClassDoc, interfaceType); List superInterfaces = getAllInterfaces(interfaceType); for (Iterator iter = superInterfaces.iterator(); iter.hasNext(); ) { Type superInterface = (Type) iter.next(); results.put(superInterface.asClassDoc(), superInterface); } } if (type instanceof ParameterizedType) findAllInterfaceTypes(results, (ParameterizedType) type); else if (((ClassDoc) type).typeParameters().length == 0) findAllInterfaceTypes(results, (ClassDoc) type, raw); else findAllInterfaceTypes(results, (ClassDoc) type, true); }
/** * Appends to the current document the list of parameters * from the given ``type`` if any. * * @param source Source package to start URL from. * @param type Target type to append parameters from. */ private void parameterLinks(final PackageDoc source, final Type type) { final ParameterizedType invocation = type.asParameterizedType(); if (invocation != null) { final Type [] types = invocation.typeArguments(); if (types.length > 0) { character('<'); for (int i = 0; i < types.length; i++) { parameterLink(source, types[i]); if (i < types.length - 1) { text(", "); } } character('>'); } } }
/** * This will grab the internal type from an array or a parameterized container. * @param type * @return */ public static String internalContainerType(Type type) { //treat arrays first if (type.dimension() != null && !type.dimension().isEmpty()) return basicType(type); ParameterizedType pType = type.asParameterizedType(); if (pType != null) { Type[] paramTypes = ((ParameterizedType)type).typeArguments(); if (!isEmpty(paramTypes)) return basicType(paramTypes[0]); } //TODO look into supporting models. return "Object"; }
protected boolean isParameterizedTypeInStopClasses(Type type) { if (!this.isInStopClasses(type.asClassDoc())) { return false; } ParameterizedType pt = type.asParameterizedType(); if (pt != null) { for (Type arg : pt.typeArguments()) { if (!this.isParameterizedTypeInStopClasses(arg)) { return false; } } } return true; }
protected List<APIParameter> getFields(Type type, ParameterType paramType, HashSet<String> processingClasses) { processingClasses.add(type.toString()); List<APIParameter> result = new LinkedList<APIParameter>(); if (!type.isPrimitive()) { ParameterizedType pt = type.asParameterizedType(); if (pt != null && pt.typeArguments().length > 0) { for (Type arg : pt.typeArguments()) { if (!this.isParameterizedTypeInStopClasses(arg)) { APIParameter tmp = new APIParameter(); tmp.setName(arg.simpleTypeName()); tmp.setType(this.getTypeName(arg, false)); tmp.setDescription(""); tmp.setParentTypeArgument(true); if (!processingClasses.contains(arg.qualifiedTypeName())) { tmp.setFields(this.getFields(arg, paramType, processingClasses)); } result.add(tmp); } } } ClassDoc classDoc = this.wrDoc.getConfiguration().root.classNamed(type.qualifiedTypeName()); if (classDoc != null) { result.addAll(this.getFields(classDoc, paramType, processingClasses)); } } return result; }
private void findAllInterfaceTypes(Map results, ClassDoc c, boolean raw) { Type superType = c.superclassType(); if (superType == null) return; addAllInterfaceTypes(results, superType, superType instanceof ClassDoc ? ((ClassDoc) superType).interfaceTypes() : ((ParameterizedType) superType).interfaceTypes(), raw); }
private void findAllInterfaceTypes(Map results, ParameterizedType p) { Type superType = p.superclassType(); if (superType == null) return; addAllInterfaceTypes(results, superType, superType instanceof ClassDoc ? ((ClassDoc) superType).interfaceTypes() : ((ParameterizedType) superType).interfaceTypes(), false); }
protected TypeInfo parseTypeInfo(Type type) { TypeInfo typeInfoNode = objectFactory.createTypeInfo(); typeInfoNode.setName(type.simpleTypeName()); typeInfoNode.setDisplayName(type.simpleTypeName()); if (type.isPrimitive()) { typeInfoNode.setIdentifier(type.qualifiedTypeName()); } else { typeInfoNode.setIdentifier(parseIdentifier(type)); } typeInfoNode.setFull(type.qualifiedTypeName()); String dimension = type.dimension(); if (dimension.length() > 0) { typeInfoNode.setDimension(dimension); } WildcardType wildcard = type.asWildcardType(); if (wildcard != null) { typeInfoNode.setWildcard(parseWildcard(wildcard)); } ParameterizedType parameterized = type.asParameterizedType(); if (parameterized != null) { for (Type typeArgument : parameterized.typeArguments()) { typeInfoNode.getGeneric().add(parseTypeInfo(typeArgument)); } } return typeInfoNode; }
/** * Convert generic type args from javadoc to my TypeInfo objects. * @param errInfo * @param ptype * @param errorContext * @return List of TypeInfo objects * @throws GeneratorException */ private List<TypeInfo> getParameterizedTypeArgs(ErrorInfo errInfo, ParameterizedType ptype, String errorContext) throws GeneratorException { errInfo = errInfo.copy(); List<TypeInfo> argInfos = null; if (ptype != null) { Type[] targs = ptype.typeArguments(); argInfos = new ArrayList<TypeInfo>(targs.length); for (int i = 0; i < targs.length; i++) { errInfo.typeArg = "<" + targs[i] + ">"; argInfos.add( makeElementTypeInfo(errInfo, targs[i], errorContext) ); } } return argInfos; }
/** * Returns type string. * * @param type type for which to return type string * @return type string, including parametrized types, dimensions and links. */ private String getTypeString(Type type) { String typeQualifiedName = type.qualifiedTypeName().replaceFirst("^java\\.lang\\.", ""); typeQualifiedName = typeQualifiedName.replaceFirst("^com\\.qspin\\.qtaste\\.testsuite\\.(QTaste\\w*Exception)", "$1"); String typeDocFileName = null; if (typeQualifiedName.startsWith("com.qspin.")) { String javaDocDir = typeQualifiedName.startsWith("com.qspin.qtaste.") ? QTaste_JAVADOC_URL_PREFIX : SUT_JAVADOC_URL_PREFIX; typeDocFileName = javaDocDir + typeQualifiedName.replace('.', '/') + ".html"; } String typeString = typeQualifiedName; if (typeDocFileName != null) { typeString = "<A HREF=\"" + typeDocFileName + "\">" + typeString + "</A>"; } if (type.asParameterizedType() != null) { ParameterizedType parametrizedType = type.asParameterizedType(); final Type[] parameterTypes = parametrizedType.typeArguments(); if (parameterTypes.length > 0) { String[] parametersTypeStrings = new String[parameterTypes.length]; for (int i = 0; i < parameterTypes.length; i++) { parametersTypeStrings[i] = getTypeString(parameterTypes[i]); } typeString += "<" + Strings.join(parametersTypeStrings, ",") + ">"; } } typeString += type.dimension(); return typeString; }
public List getAllInterfaces(Type type) { Map results = new TreeMap(); Type[] interfaceTypes = null; Type superType = null; if (type instanceof ParameterizedType) { interfaceTypes = ((ParameterizedType) type).interfaceTypes(); superType = ((ParameterizedType) type).superclassType(); } else if (type instanceof ClassDoc) { interfaceTypes = ((ClassDoc) type).interfaceTypes(); superType = ((ClassDoc) type).superclassType(); } else { interfaceTypes = type.asClassDoc().interfaceTypes(); superType = type.asClassDoc().superclassType(); } for (int i = 0; i < interfaceTypes.length; i++) { Type interfaceType = interfaceTypes[i]; ClassDoc interfaceClassDoc = interfaceType.asClassDoc(); if (! (interfaceClassDoc.isPublic() || interfaceClassDoc.isIncluded())) { continue; } results.put(interfaceClassDoc, interfaceType); List superInterfaces = getAllInterfaces(interfaceType); for (Iterator iter = superInterfaces.iterator(); iter.hasNext(); ) { Type t = (Type) iter.next(); results.put(t.asClassDoc(), t); } } if (superType == null) return new ArrayList(results.values()); //Try walking the tree. addAllInterfaceTypes(results, superType, superType instanceof ClassDoc ? ((ClassDoc) superType).interfaceTypes() : ((ParameterizedType) superType).interfaceTypes(), false); List resultsList = new ArrayList(results.values()); Collections.sort(resultsList, new TypeComparator()); return resultsList; }
@Override public void renderOn(HtmlCanvas html) throws IOException { if (type.isPrimitive()) { html.write(type.typeName() + type.dimension()); } else { String name; ClassDoc classDoc = type.asClassDoc(); DocReferenceable referenceable = generator.getRefLocator().getClassDocRef(classDoc); String ref = PageRenderer.getPage(html).getReferenceTo(referenceable); if ((flags & FQN) != 0) { name = classDoc.qualifiedName(); } else { name = referenceable.getName(); } if ((flags & LINK) != 0 && ref != null) { html.a(href(PageRenderer.getPage(html).getReferenceTo(referenceable))).content(name, HtmlCanvas.NO_ESCAPE); } else { html.write(name); } } ParameterizedType parameterizedType = type.asParameterizedType(); if (parameterizedType != null) { Type[] typeArguments = parameterizedType.typeArguments(); if (typeArguments.length > 0) { html.write("<"); for (int typeVarCount = 0; typeVarCount < typeArguments.length; typeVarCount++) { Type typeArgument = typeArguments[typeVarCount]; if (typeVarCount > 0) { html.write(", "); } renderReferenceable(generator.getRefLocator().getClassDocRef(typeArgument.asClassDoc()), html); } html.write(">"); } } else if (!type.isPrimitive()) { TypeVariable[] typeVariables = type.asClassDoc().typeParameters(); if (typeVariables.length > 0) { html.write("<"); for (int typeVarCount = 0; typeVarCount < typeVariables.length; typeVarCount++) { TypeVariable typeVariable = typeVariables[typeVarCount]; if (typeVarCount > 0) { html.write(", "); } html.write(typeVariable.typeName()); if ((flags & BOUNDS) != 0) { Type[] bounds = typeVariable.bounds(); if (bounds.length > 0) { html.write(" extends "); for (int boundCnt = 0; boundCnt < bounds.length; boundCnt++) { ClassDoc boundClass = bounds[boundCnt].asClassDoc(); if (boundCnt > 0) { html.write(" & "); } renderReferenceable(generator.getRefLocator().getClassDocRef(boundClass), html); } } } } html.write(">"); } } }
/** * Convert a javadoc Type object into an object of my TypeInfo class. * @param errInfo * @param type * @param errorContext * @return TypeInfo object * @throws GeneratorException */ private TypeInfo makeElementTypeInfo(ErrorInfo errInfo, Type type, String errorContext) throws GeneratorException { errInfo = errInfo.copy(); if (type == null) return null; TypeInfo tinfo = null; WildcardType wtype = type.asWildcardType(); String qname = type.qualifiedTypeName(); if (wtype != null) { // Wildcard Parameter machen keinen Sinn. // Die Elemente werden sowohl als Konsument als auch als Produzent verwendet. // http://www.torsten-horn.de/techdocs/java-generics.htm#Wildcard-extends-versus-T-extends errInfo.msg = "Wildcard parameter types are unsupported, please replace type=\"" + type +"\" by \"Object\"."; throw new GeneratorException(errInfo); } else { ParameterizedType ptype = type.asParameterizedType(); List<TypeInfo> argInfos = getParameterizedTypeArgs(errInfo, ptype, errorContext); ClassDoc cls = type.asClassDoc(); boolean isEnum = false; boolean isInline = false; boolean isFinal = false; if (cls != null) { isEnum = cls.isEnum() || cls.isEnumConstant(); isInline = isInline(cls); isFinal = cls.isFinal(); } tinfo = classDB.createTypeInfo( type.simpleTypeName(), qname, type.dimension(), argInfos, isEnum, isFinal, isInline); makeSerialInfoForCollectionType(errInfo, tinfo); } return tinfo; }
/** * @return the full JSON for the given Type */ protected JSONObject processParameterizedType(ParameterizedType parameterizedType) { if (parameterizedType == null) { return null; } JSONObject retMe = new JSONObject(); retMe.put("typeArguments", processTypes( parameterizedType.typeArguments() ) ); return retMe; }