List of usage examples for org.eclipse.jdt.core Signature getTypeArguments
public static String[] getTypeArguments(String parameterizedTypeSignature) throws IllegalArgumentException
From source file:at.bestsolution.fxide.jdt.corext.util.MethodOverrideTester.java
License:Open Source License
private void computeSubstitutions(IType instantiatedType, IType instantiatingType, String[] typeArguments) throws JavaModelException { Substitutions s = new Substitutions(); fTypeVariableSubstitutions.put(instantiatedType, s); ITypeParameter[] typeParameters = instantiatedType.getTypeParameters(); if (instantiatingType == null) { // the focus type for (int i = 0; i < typeParameters.length; i++) { ITypeParameter curr = typeParameters[i]; // use star to make type variables different from type refs s.addSubstitution(curr.getElementName(), '*' + curr.getElementName(), getTypeParameterErasure(curr, instantiatedType)); }/*from w ww . j a v a 2 s . c o m*/ } else { if (typeParameters.length == typeArguments.length) { for (int i = 0; i < typeParameters.length; i++) { ITypeParameter curr = typeParameters[i]; String substString = getSubstitutedTypeName(typeArguments[i], instantiatingType); // substitute in the context of the instantiatingType String erasure = getErasedTypeName(typeArguments[i], instantiatingType); // get the erasure from the type argument s.addSubstitution(curr.getElementName(), substString, erasure); } } else if (typeArguments.length == 0) { // raw type reference for (int i = 0; i < typeParameters.length; i++) { ITypeParameter curr = typeParameters[i]; String erasure = getTypeParameterErasure(curr, instantiatedType); s.addSubstitution(curr.getElementName(), erasure, erasure); } } else { // code with errors } } String superclassTypeSignature = instantiatedType.getSuperclassTypeSignature(); if (superclassTypeSignature != null) { String[] superTypeArguments = Signature.getTypeArguments(superclassTypeSignature); IType superclass = fHierarchy.getSuperclass(instantiatedType); if (superclass != null && !fTypeVariableSubstitutions.containsKey(superclass)) { computeSubstitutions(superclass, instantiatedType, superTypeArguments); } } String[] superInterfacesTypeSignature; if (instantiatedType.isAnonymous()) { // special case: superinterface is also returned by IType#getSuperclassTypeSignature() superInterfacesTypeSignature = new String[] { superclassTypeSignature }; } else { superInterfacesTypeSignature = instantiatedType.getSuperInterfaceTypeSignatures(); } int nInterfaces = superInterfacesTypeSignature.length; if (nInterfaces > 0) { IType[] superInterfaces = fHierarchy.getSuperInterfaces(instantiatedType); if (superInterfaces.length == nInterfaces) { for (int i = 0; i < nInterfaces; i++) { String[] superTypeArguments = Signature.getTypeArguments(superInterfacesTypeSignature[i]); IType superInterface = superInterfaces[i]; if (!fTypeVariableSubstitutions.containsKey(superInterface)) { computeSubstitutions(superInterface, instantiatedType, superTypeArguments); } } } } }
From source file:at.bestsolution.fxide.jdt.corext.util.MethodOverrideTester.java
License:Open Source License
private StringBuffer internalGetSubstitutedTypeName(String typeSig, IMember context, boolean erasure, StringBuffer buf) throws JavaModelException { int sigKind = Signature.getTypeSignatureKind(typeSig); switch (sigKind) { case Signature.BASE_TYPE_SIGNATURE: return buf.append(Signature.toString(typeSig)); case Signature.ARRAY_TYPE_SIGNATURE: internalGetSubstitutedTypeName(Signature.getElementType(typeSig), context, erasure, buf); for (int i = Signature.getArrayCount(typeSig); i > 0; i--) { buf.append('[').append(']'); }/*from w ww.jav a2 s . co m*/ return buf; case Signature.CLASS_TYPE_SIGNATURE: { String erasureSig = Signature.getTypeErasure(typeSig); String erasureName = Signature.getSimpleName(Signature.toString(erasureSig)); char ch = erasureSig.charAt(0); if (ch == Signature.C_RESOLVED) { buf.append(erasureName); } else if (ch == Signature.C_UNRESOLVED) { // could be a type variable if (erasure) { buf.append(getVariableErasure(context, erasureName)); } else { buf.append(getVariableSubstitution(context, erasureName)); } } else { Assert.isTrue(false, "Unknown class type signature"); //$NON-NLS-1$ } if (!erasure) { String[] typeArguments = Signature.getTypeArguments(typeSig); if (typeArguments.length > 0) { buf.append('<'); for (int i = 0; i < typeArguments.length; i++) { if (i > 0) { buf.append(','); } internalGetSubstitutedTypeName(typeArguments[i], context, erasure, buf); } buf.append('>'); } } return buf; } case Signature.TYPE_VARIABLE_SIGNATURE: String varName = Signature.toString(typeSig); if (erasure) { return buf.append(getVariableErasure(context, varName)); } else { return buf.append(getVariableSubstitution(context, varName)); } case Signature.WILDCARD_TYPE_SIGNATURE: { buf.append('?'); char ch = typeSig.charAt(0); if (ch == Signature.C_STAR) { return buf; } else if (ch == Signature.C_EXTENDS) { buf.append(" extends "); //$NON-NLS-1$ } else { buf.append(" super "); //$NON-NLS-1$ } return internalGetSubstitutedTypeName(typeSig.substring(1), context, erasure, buf); } case Signature.CAPTURE_TYPE_SIGNATURE: return internalGetSubstitutedTypeName(typeSig.substring(1), context, erasure, buf); default: Assert.isTrue(false, "Unhandled type signature kind"); //$NON-NLS-1$ return buf; } }
From source file:at.bestsolution.fxide.jdt.editor.internal.MethodUtil.java
License:Open Source License
/** * The type and method signatures received in * <code>CompletionProposals</code> of type <code>METHOD_REF</code> * contain concrete type bounds. When comparing parameters of the signature * with an <code>IMethod</code>, we have to make sure that we match the * case where the formal method declaration uses a type variable which in * the signature is already substituted with a concrete type (bound). * <p>//from w w w . j av a2 s .c om * This method creates a map from type variable names to type signatures * based on the position they appear in the type declaration. The type * signatures are filtered through * {@link SignatureUtil#getLowerBound(char[])}. * </p> * * @param type the type to get the variables from * @return a map from type variables to concrete type signatures * @throws JavaModelException if accessing the java model fails */ private static Map<String, char[]> computeTypeVariables(char[] declarationSignature, IType type) throws JavaModelException { Map<String, char[]> map = new HashMap<>(); if (declarationSignature == null) // array methods don't contain a declaration signature return map; char[][] concreteParameters = Signature.getTypeArguments(declarationSignature); ITypeParameter[] typeParameters = type.getTypeParameters(); for (int i = 0; i < typeParameters.length; i++) { String variable = typeParameters[i].getElementName(); if (concreteParameters.length > i) // use lower bound since method equality is only parameter based map.put(variable, SignatureUtil.getLowerBound(concreteParameters[i])); else // fProposal.getDeclarationSignature() is a raw type - use Object map.put(variable, "Ljava.lang.Object;".toCharArray()); //$NON-NLS-1$ } return map; }
From source file:at.bestsolution.fxide.jdt.editor.internal.SignatureUtil.java
License:Open Source License
/** * Returns the lower bound of a type signature. Returns the null type * signature if <code>signature</code> is a wildcard or upper bound (<code>? extends T</code>); * returns the signature of the type <code>T</code> of a lower bound (<code>? super T</code>) * or <code>signature</code> itself if it is not a bound signature. * * @param signature the signature/*from w w w. j a v a 2s .co m*/ * @return the lower bound signature of <code>signature</code> */ public static char[] getLowerBound(char[] signature) { if (signature.length < 1) return signature; if (signature.length == 1 && signature[0] == Signature.C_STAR) return signature; int superIndex = indexOf(signature, Signature.C_EXTENDS); if (superIndex == 0) return NULL_TYPE_SIGNATURE_ARRAY; if (superIndex != -1) { char afterSuper = signature[superIndex + 1]; if (afterSuper == Signature.C_STAR || afterSuper == Signature.C_EXTENDS) // impossible captured type return NULL_TYPE_SIGNATURE_ARRAY; } char[][] typeArguments = Signature.getTypeArguments(signature); for (int i = 0; i < typeArguments.length; i++) if (Arrays.equals(typeArguments[i], NULL_TYPE_SIGNATURE_ARRAY)) return NULL_TYPE_SIGNATURE_ARRAY; if (signature[0] == Signature.C_SUPER) { char[] type = new char[signature.length - 1]; System.arraycopy(signature, 1, type, 0, signature.length - 1); return type; } return signature; }
From source file:at.bestsolution.fxide.jdt.text.viewersupport.JavaElementLabelComposer.java
License:Open Source License
protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags) { int sigKind = Signature.getTypeSignatureKind(typeSig); switch (sigKind) { case Signature.BASE_TYPE_SIGNATURE: fBuffer.append(Signature.toString(typeSig)); break;//from ww w . j a v a 2 s. co m case Signature.ARRAY_TYPE_SIGNATURE: appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags); for (int dim = Signature.getArrayCount(typeSig); dim > 0; dim--) { fBuffer.append('[').append(']'); } break; case Signature.CLASS_TYPE_SIGNATURE: String baseType = getSimpleTypeName(enclosingElement, typeSig); fBuffer.append(baseType); String[] typeArguments = Signature.getTypeArguments(typeSig); appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags); break; case Signature.TYPE_VARIABLE_SIGNATURE: fBuffer.append(getSimpleTypeName(enclosingElement, typeSig)); break; case Signature.WILDCARD_TYPE_SIGNATURE: char ch = typeSig.charAt(0); if (ch == Signature.C_STAR) { //workaround for bug 85713 fBuffer.append('?'); } else { if (ch == Signature.C_EXTENDS) { fBuffer.append("? extends "); //$NON-NLS-1$ appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags); } else if (ch == Signature.C_SUPER) { fBuffer.append("? super "); //$NON-NLS-1$ appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags); } } break; case Signature.CAPTURE_TYPE_SIGNATURE: appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags); break; case Signature.INTERSECTION_TYPE_SIGNATURE: String[] typeBounds = Signature.getIntersectionTypeBounds(typeSig); appendTypeBoundsSignaturesLabel(enclosingElement, typeBounds, flags); break; default: // unknown } }
From source file:com.codenvy.ide.ext.java.server.core.search.SearchPattern.java
License:Open Source License
private static SearchPattern createMethodOrConstructorPattern(String patternString, int limitTo, int matchRule, boolean isConstructor) { // use 1.7 as the source level as there are more valid tokens in 1.7 mode // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673 Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/, ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/, true/*taskCaseSensitive*/); scanner.setSource(patternString.toCharArray()); final int InsideSelector = 1; final int InsideTypeArguments = 2; final int InsideParameter = 3; final int InsideReturnType = 4; int lastToken = -1; String declaringType = null, selector = null, parameterType = null; String[] parameterTypes = null; char[][] typeArguments = null; String typeArgumentsString = null; int parameterCount = -1; String returnType = null;/*from www . j a v a 2s . c o m*/ boolean foundClosingParenthesis = false; int mode = InsideSelector; int token, argCount = 0; try { token = scanner.getNextToken(); } catch (InvalidInputException e) { return null; } while (token != TerminalTokens.TokenNameEOF) { switch (mode) { // read declaring type and selector case InsideSelector: if (argCount == 0) { switch (token) { case TerminalTokens.TokenNameLESS: argCount++; if (selector == null || lastToken == TerminalTokens.TokenNameDOT) { typeArgumentsString = scanner.getCurrentTokenString(); mode = InsideTypeArguments; break; } if (declaringType == null) { declaringType = selector; } else { declaringType += '.' + selector; } declaringType += scanner.getCurrentTokenString(); selector = null; break; case TerminalTokens.TokenNameDOT: if (!isConstructor && typeArgumentsString != null) return null; // invalid syntax if (declaringType == null) { if (selector == null) return null; // invalid syntax declaringType = selector; } else if (selector != null) { declaringType += scanner.getCurrentTokenString() + selector; } selector = null; break; case TerminalTokens.TokenNameLPAREN: parameterTypes = new String[5]; parameterCount = 0; mode = InsideParameter; break; case TerminalTokens.TokenNameWHITESPACE: switch (lastToken) { case TerminalTokens.TokenNameWHITESPACE: case TerminalTokens.TokenNameDOT: case TerminalTokens.TokenNameGREATER: case TerminalTokens.TokenNameRIGHT_SHIFT: case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT: break; default: mode = InsideReturnType; break; } break; default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search]) if (selector == null) selector = scanner.getCurrentTokenString(); else selector += scanner.getCurrentTokenString(); break; } } else { if (declaringType == null) return null; // invalid syntax switch (token) { case TerminalTokens.TokenNameGREATER: case TerminalTokens.TokenNameRIGHT_SHIFT: case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT: argCount--; break; case TerminalTokens.TokenNameLESS: argCount++; break; } declaringType += scanner.getCurrentTokenString(); } break; // read type arguments case InsideTypeArguments: if (typeArgumentsString == null) return null; // invalid syntax typeArgumentsString += scanner.getCurrentTokenString(); switch (token) { case TerminalTokens.TokenNameGREATER: case TerminalTokens.TokenNameRIGHT_SHIFT: case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT: argCount--; if (argCount == 0) { String pseudoType = "Type" + typeArgumentsString; //$NON-NLS-1$ typeArguments = Signature .getTypeArguments(Signature.createTypeSignature(pseudoType, false).toCharArray()); mode = InsideSelector; } break; case TerminalTokens.TokenNameLESS: argCount++; break; } break; // read parameter types case InsideParameter: if (argCount == 0) { switch (token) { case TerminalTokens.TokenNameWHITESPACE: break; case TerminalTokens.TokenNameCOMMA: if (parameterType == null) return null; if (parameterTypes != null) { if (parameterTypes.length == parameterCount) System.arraycopy(parameterTypes, 0, parameterTypes = new String[parameterCount * 2], 0, parameterCount); parameterTypes[parameterCount++] = parameterType; } parameterType = null; break; case TerminalTokens.TokenNameRPAREN: foundClosingParenthesis = true; if (parameterType != null && parameterTypes != null) { if (parameterTypes.length == parameterCount) System.arraycopy(parameterTypes, 0, parameterTypes = new String[parameterCount * 2], 0, parameterCount); parameterTypes[parameterCount++] = parameterType; } mode = isConstructor ? InsideTypeArguments : InsideReturnType; break; case TerminalTokens.TokenNameLESS: argCount++; if (parameterType == null) return null; // invalid syntax // $FALL-THROUGH$ - fall through next case to add token default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search]) if (parameterType == null) parameterType = scanner.getCurrentTokenString(); else parameterType += scanner.getCurrentTokenString(); } } else { if (parameterType == null) return null; // invalid syntax switch (token) { case TerminalTokens.TokenNameGREATER: case TerminalTokens.TokenNameRIGHT_SHIFT: case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT: argCount--; break; case TerminalTokens.TokenNameLESS: argCount++; break; } parameterType += scanner.getCurrentTokenString(); } break; // read return type case InsideReturnType: if (argCount == 0) { switch (token) { case TerminalTokens.TokenNameWHITESPACE: break; case TerminalTokens.TokenNameLPAREN: parameterTypes = new String[5]; parameterCount = 0; mode = InsideParameter; break; case TerminalTokens.TokenNameLESS: argCount++; if (returnType == null) return null; // invalid syntax // $FALL-THROUGH$ - fall through next case to add token default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search]) if (returnType == null) returnType = scanner.getCurrentTokenString(); else returnType += scanner.getCurrentTokenString(); } } else { if (returnType == null) return null; // invalid syntax switch (token) { case TerminalTokens.TokenNameGREATER: case TerminalTokens.TokenNameRIGHT_SHIFT: case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT: argCount--; break; case TerminalTokens.TokenNameLESS: argCount++; break; } returnType += scanner.getCurrentTokenString(); } break; } lastToken = token; try { token = scanner.getNextToken(); } catch (InvalidInputException e) { return null; } } // parenthesis mismatch if (parameterCount > 0 && !foundClosingParenthesis) return null; // type arguments mismatch if (argCount > 0) return null; char[] selectorChars = null; if (isConstructor) { // retrieve type for constructor patterns if (declaringType == null) declaringType = selector; else if (selector != null) declaringType += '.' + selector; } else { // get selector chars if (selector == null) return null; selectorChars = selector.toCharArray(); if (selectorChars.length == 1 && selectorChars[0] == '*') selectorChars = null; } char[] declaringTypeQualification = null, declaringTypeSimpleName = null; char[] returnTypeQualification = null, returnTypeSimpleName = null; char[][] parameterTypeQualifications = null, parameterTypeSimpleNames = null; // Signatures String declaringTypeSignature = null; String returnTypeSignature = null; String[] parameterTypeSignatures = null; // extract declaring type infos if (declaringType != null) { // get declaring type part and signature char[] declaringTypePart = null; try { declaringTypeSignature = Signature.createTypeSignature(declaringType, false); if (declaringTypeSignature.indexOf(Signature.C_GENERIC_START) < 0) { declaringTypePart = declaringType.toCharArray(); } else { declaringTypePart = Signature .toCharArray(Signature.getTypeErasure(declaringTypeSignature.toCharArray())); } } catch (IllegalArgumentException iae) { // declaring type is invalid return null; } int lastDotPosition = CharOperation.lastIndexOf('.', declaringTypePart); if (lastDotPosition >= 0) { declaringTypeQualification = CharOperation.subarray(declaringTypePart, 0, lastDotPosition); if (declaringTypeQualification.length == 1 && declaringTypeQualification[0] == '*') declaringTypeQualification = null; declaringTypeSimpleName = CharOperation.subarray(declaringTypePart, lastDotPosition + 1, declaringTypePart.length); } else { declaringTypeSimpleName = declaringTypePart; } if (declaringTypeSimpleName.length == 1 && declaringTypeSimpleName[0] == '*') declaringTypeSimpleName = null; } // extract parameter types infos if (parameterCount >= 0) { parameterTypeQualifications = new char[parameterCount][]; parameterTypeSimpleNames = new char[parameterCount][]; parameterTypeSignatures = new String[parameterCount]; for (int i = 0; i < parameterCount; i++) { // get parameter type part and signature char[] parameterTypePart = null; try { if (parameterTypes != null) { parameterTypeSignatures[i] = Signature.createTypeSignature(parameterTypes[i], false); if (parameterTypeSignatures[i].indexOf(Signature.C_GENERIC_START) < 0) { parameterTypePart = parameterTypes[i].toCharArray(); } else { parameterTypePart = Signature.toCharArray( Signature.getTypeErasure(parameterTypeSignatures[i].toCharArray())); } } } catch (IllegalArgumentException iae) { // string is not a valid type syntax return null; } int lastDotPosition = parameterTypePart == null ? -1 : CharOperation.lastIndexOf('.', parameterTypePart); if (parameterTypePart != null && lastDotPosition >= 0) { parameterTypeQualifications[i] = CharOperation.subarray(parameterTypePart, 0, lastDotPosition); if (parameterTypeQualifications[i].length == 1 && parameterTypeQualifications[i][0] == '*') { parameterTypeQualifications[i] = null; } else { // prefix with a '*' as the full qualification could be bigger (because of an import) parameterTypeQualifications[i] = CharOperation.concat(IIndexConstants.ONE_STAR, parameterTypeQualifications[i]); } parameterTypeSimpleNames[i] = CharOperation.subarray(parameterTypePart, lastDotPosition + 1, parameterTypePart.length); } else { parameterTypeQualifications[i] = null; parameterTypeSimpleNames[i] = parameterTypePart; } if (parameterTypeSimpleNames[i].length == 1 && parameterTypeSimpleNames[i][0] == '*') parameterTypeSimpleNames[i] = null; } } // extract return type infos if (returnType != null) { // get return type part and signature char[] returnTypePart = null; try { returnTypeSignature = Signature.createTypeSignature(returnType, false); if (returnTypeSignature.indexOf(Signature.C_GENERIC_START) < 0) { returnTypePart = returnType.toCharArray(); } else { returnTypePart = Signature .toCharArray(Signature.getTypeErasure(returnTypeSignature.toCharArray())); } } catch (IllegalArgumentException iae) { // declaring type is invalid return null; } int lastDotPosition = CharOperation.lastIndexOf('.', returnTypePart); if (lastDotPosition >= 0) { returnTypeQualification = CharOperation.subarray(returnTypePart, 0, lastDotPosition); if (returnTypeQualification.length == 1 && returnTypeQualification[0] == '*') { returnTypeQualification = null; } else { // because of an import returnTypeQualification = CharOperation.concat(IIndexConstants.ONE_STAR, returnTypeQualification); } returnTypeSimpleName = CharOperation.subarray(returnTypePart, lastDotPosition + 1, returnTypePart.length); } else { returnTypeSimpleName = returnTypePart; } if (returnTypeSimpleName.length == 1 && returnTypeSimpleName[0] == '*') returnTypeSimpleName = null; } // Create method/constructor pattern if (isConstructor) { return new ConstructorPattern(declaringTypeSimpleName, declaringTypeQualification, declaringTypeSignature, parameterTypeQualifications, parameterTypeSimpleNames, parameterTypeSignatures, typeArguments, limitTo, matchRule); } else { return new MethodPattern(selectorChars, declaringTypeQualification, declaringTypeSimpleName, declaringTypeSignature, returnTypeQualification, returnTypeSimpleName, returnTypeSignature, parameterTypeQualifications, parameterTypeSimpleNames, parameterTypeSignatures, typeArguments, limitTo, matchRule); } }
From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java
License:Open Source License
/** * Get all type arguments from an array of signatures. * <p/>/* ww w . jav a 2 s . com*/ * Example: For following type X<Y<Z>,V<W>,U>.A<B> signatures is: [ * ['L','X','<' * ,'L','Y','<','L','Z',';'>',';','L','V','<','L','W',';'>',';','L' * ,'U',';',>',';'], ['L','A','<','L','B',';','>',';'] ] * * @param typeSignatures * Array of signatures (one per each type levels) * @return char[][][] Array of type arguments for each signature * @throws IllegalArgumentException * If one of provided signature is malformed * @see #splitTypeLevelsSignature(String) Then, this method returns: [ [ * ['L','Y','<','L','Z',';'>',';'], ['L','V','<','L','W',';'>',';'], * ['L','U',';'] ], [ ['L','B',';'] ] ] */ public final static char[][][] getAllTypeArguments(char[][] typeSignatures) { if (typeSignatures == null) return null; int length = typeSignatures.length; char[][][] typeArguments = new char[length][][]; for (int i = 0; i < length; i++) { typeArguments[i] = Signature.getTypeArguments(typeSignatures[i]); } return typeArguments; }
From source file:com.codenvy.ide.ext.java.server.SourcesFromBytecodeGenerator.java
License:Open Source License
protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags, StringBuilder builder) {/* w ww . ja v a 2 s. co m*/ int sigKind = Signature.getTypeSignatureKind(typeSig); switch (sigKind) { case Signature.BASE_TYPE_SIGNATURE: builder.append(Signature.toString(typeSig)); break; case Signature.ARRAY_TYPE_SIGNATURE: appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags, builder); for (int dim = Signature.getArrayCount(typeSig); dim > 0; dim--) { builder.append('[').append(']'); } break; case Signature.CLASS_TYPE_SIGNATURE: String baseType = getSimpleTypeName(enclosingElement, typeSig); builder.append(baseType); String[] typeArguments = Signature.getTypeArguments(typeSig); appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags, builder); break; case Signature.TYPE_VARIABLE_SIGNATURE: builder.append(getSimpleTypeName(enclosingElement, typeSig)); break; case Signature.WILDCARD_TYPE_SIGNATURE: char ch = typeSig.charAt(0); if (ch == Signature.C_STAR) { //workaround for bug 85713 builder.append('?'); } else { if (ch == Signature.C_EXTENDS) { builder.append("? extends "); //$NON-NLS-1$ appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags, builder); } else if (ch == Signature.C_SUPER) { builder.append("? super "); //$NON-NLS-1$ appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags, builder); } } break; case Signature.CAPTURE_TYPE_SIGNATURE: appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags, builder); break; case Signature.INTERSECTION_TYPE_SIGNATURE: String[] typeBounds = Signature.getIntersectionTypeBounds(typeSig); appendTypeBoundsSignaturesLabel(enclosingElement, typeBounds, flags, builder); break; default: // unknown } }
From source file:com.google.gdt.eclipse.appengine.rpc.util.JavaUtils.java
License:Open Source License
private static List<String> getElementSignatures(String typeName) { List<String> list = new ArrayList<String>(); if (Signature.getTypeSignatureKind(typeName) == Signature.ARRAY_TYPE_SIGNATURE) { list.add(Signature.getElementType(typeName)); } else {//from w ww . j a v a 2 s .c o m String[] names = Signature.getTypeArguments(typeName); list.add(Signature.getTypeErasure(typeName)); if (names.length > 0) { list.add(names[0]); } } return list; }
From source file:com.google.gdt.eclipse.appengine.rpc.wizards.helpers.RpcServiceLayerCreator.java
License:Open Source License
private String[] getElementSignatures(String typeName) { if (Signature.getTypeSignatureKind(typeName) == Signature.ARRAY_TYPE_SIGNATURE) { return new String[] { Signature.getElementType(typeName) }; } else {//from w ww.ja v a 2s. com String[] names = Signature.getTypeArguments(typeName); List<String> list = new ArrayList<String>(); list.add(Signature.getTypeErasure(typeName)); if (names.length > 0) { list.add(names[0]); } return list.toArray(new String[list.size()]); } }