/** * Returns the qualified signature corresponding to <code>signature</code>. * * @param signature the signature to qualify * @param context the type inside which an unqualified type will be resolved to find the * qualifier, or <code>null</code> if no context is available * @return the qualified signature */ public static String qualifySignature(final String signature, final IType context) { if (context == null) return signature; String qualifier = Signature.getSignatureQualifier(signature); if (qualifier.length() > 0) return signature; String elementType = Signature.getElementType(signature); String erasure = Signature.getTypeErasure(elementType); String simpleName = Signature.getSignatureSimpleName(erasure); String genericSimpleName = Signature.getSignatureSimpleName(elementType); int dim = Signature.getArrayCount(signature); try { String[][] strings = context.resolveType(simpleName); if (strings != null && strings.length > 0) qualifier = strings[0][0]; } catch (JavaModelException e) { // ignore - not found } if (qualifier.length() == 0) return signature; String qualifiedType = Signature.toQualifiedName(new String[] {qualifier, genericSimpleName}); String qualifiedSignature = Signature.createTypeSignature(qualifiedType, true); String newSignature = Signature.createArraySignature(qualifiedSignature, dim); return newSignature; }
private static String[] getParameterTypesAsStringArray(IMethod method) { Set<String> typeParameterNames = new HashSet<String>(); try { for (ITypeParameter param : method.getDeclaringType().getTypeParameters()) { typeParameterNames.add(param.getElementName()); } for (ITypeParameter param : method.getTypeParameters()) { typeParameterNames.add(param.getElementName()); } } catch (JavaModelException e) { } String[] parameterTypesAsString = new String[method.getParameterTypes().length]; for (int i = 0; i < method.getParameterTypes().length; i++) { String parameterTypeString = Signature.getElementType(method.getParameterTypes()[i]); boolean isArray = !parameterTypeString.equals(method.getParameterTypes()[i]); String parameterType = resolveClassNameBySignature(parameterTypeString, method.getDeclaringType()); if (typeParameterNames.contains(parameterType)) { parameterTypesAsString[i] = Object.class.getName() + (isArray ? ClassUtils.ARRAY_SUFFIX : ""); } else { parameterTypesAsString[i] = parameterType + (isArray ? ClassUtils.ARRAY_SUFFIX : ""); } } return parameterTypesAsString; }
protected void createFragmentForArray(String signature, StringBuilder uriBuilder) { String elementType = Signature.getElementType(signature); createFragment(elementType, uriBuilder); int dim = Signature.getArrayCount(signature); for (int i = 0; i < dim; i++) { uriBuilder.append("[]"); } }
private static void appendMethodReference(IMethod meth, StringBuffer buf) throws JavaModelException { buf.append(meth.getElementName()); /* * The Javadoc tool for Java SE 8 changed the anchor syntax and now tries to avoid "strange" characters in URLs. * This breaks all clients that directly create such URLs. * We can't know what format is required, so we just guess by the project's compiler compliance. */ boolean is18OrHigher = JavaModelUtil.is18OrHigher(meth.getJavaProject()); buf.append(is18OrHigher ? '-' : '('); String[] params = meth.getParameterTypes(); IType declaringType = meth.getDeclaringType(); boolean isVararg = Flags.isVarargs(meth.getFlags()); int lastParam = params.length - 1; for (int i = 0; i <= lastParam; i++) { if (i != 0) { buf.append(is18OrHigher ? "-" : ", "); // $NON-NLS-1$ //$NON-NLS-2$ } String curr = Signature.getTypeErasure(params[i]); String fullName = JavaModelUtil.getResolvedTypeName(curr, declaringType); if (fullName == null) { // e.g. a type parameter "QE;" fullName = Signature.toString(Signature.getElementType(curr)); } if (fullName != null) { buf.append(fullName); int dim = Signature.getArrayCount(curr); if (i == lastParam && isVararg) { dim--; } while (dim > 0) { buf.append(is18OrHigher ? ":A" : "[]"); // $NON-NLS-1$ //$NON-NLS-2$ dim--; } if (i == lastParam && isVararg) { buf.append("..."); // $NON-NLS-1$ } } } buf.append(is18OrHigher ? '-' : ')'); }
private static String typeSignatureToFqn(String signature) { try { switch (Signature.getTypeSignatureKind(signature)) { case Signature.ARRAY_TYPE_SIGNATURE: return typeSignatureToFqn(Signature.getElementType(signature)) + brackets.substring(0, 2 * Signature.getArrayCount(signature)); case Signature.CLASS_TYPE_SIGNATURE: String args[] = Signature.getTypeArguments(signature); if (args.length == 0) { int firstDollar = signature.indexOf('$'); if (firstDollar == -1) { return Signature.getSignatureQualifier(signature) + "." + Signature.getSignatureSimpleName(signature); } else { String shortSig = signature.substring(0, firstDollar) + ";"; return Signature.getSignatureQualifier(shortSig) + "." + Signature.getSignatureSimpleName(shortSig) + signature.substring(firstDollar, signature.length() - 1); } } else { StringBuilder fqnBuilder = new StringBuilder(typeSignatureToFqn(Signature.getTypeErasure(signature))); fqnBuilder.append('<'); boolean first = true; for (String arg : args) { if (first) { first = false; } else { fqnBuilder.append(','); } fqnBuilder.append(typeSignatureToFqn(arg)); } fqnBuilder.append('>'); return fqnBuilder.toString(); } case Signature.BASE_TYPE_SIGNATURE: return Signature.getSignatureSimpleName(signature); case Signature.TYPE_VARIABLE_SIGNATURE: return "<" + Signature.getSignatureSimpleName(signature) + ">"; case Signature.WILDCARD_TYPE_SIGNATURE: if (signature.startsWith("+")) { return "<?+" + typeSignatureToFqn(signature.substring(1)) + ">"; } else if (signature.startsWith("-")) { return "<?-" + typeSignatureToFqn(signature.substring(1)) + ">"; } else { return "<?>"; } case Signature.CAPTURE_TYPE_SIGNATURE: System.out.println("eek"); return ""; default: throw new IllegalArgumentException("Not a valid type signature"); } } catch (Exception e) { e.printStackTrace(); System.out.println("bad"); return null; } }
/** * Returns the fully qualified type name of the given signature, with any type parameters and * arrays erased. * * @param signature the signature * @return the fully qualified type name of the signature * @throws IllegalArgumentException if the signature is syntactically incorrect */ public static String stripSignatureToFQN(String signature) throws IllegalArgumentException { signature = Signature.getTypeErasure(signature); signature = Signature.getElementType(signature); return Signature.toString(signature); }
protected void createResourceURIForArray(String signature, StringBuilder uriBuilder) { String elementType = Signature.getElementType(signature); createResourceURI(elementType, uriBuilder); }