/**
* 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);
}
