Example usage for org.eclipse.jdt.core Signature C_GENERIC_END

Introduction

In this page you can find the example usage for org.eclipse.jdt.core Signature C_GENERIC_END.

Prototype

char C_GENERIC_END

To view the source code for org.eclipse.jdt.core Signature C_GENERIC_END.

Click Source Link

Document

Character constant indicating the end of a generic type list in a signature.

Usage

From source file:at.bestsolution.fxide.jdt.editor.internal.SignatureUtil.java

License:Open Source License

private static int typeEnd(char[] signature, int pos) {
    int depth = 0;
    while (pos < signature.length) {
        switch (signature[pos]) {
        case Signature.C_GENERIC_START:
            depth++;//from   w w  w.j a va2s .c  om
            break;
        case Signature.C_GENERIC_END:
            if (depth == 0)
                return pos;
            depth--;
            break;
        case Signature.C_SEMICOLON:
            if (depth == 0)
                return pos + 1;
            break;
        }
        pos++;
    }
    return pos + 1;
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.SourceMapper.java

License:Open Source License

private int findMatchingGenericEnd(char[] sig, int start) {
    int nesting = 0;
    int length = sig.length;
    for (int i = start; i < length; i++) {
        switch (sig[i]) {
        case Signature.C_GENERIC_START:
            nesting++;/*from  www  .j a  va 2 s .c  o  m*/
            break;
        case Signature.C_GENERIC_END:
            if (nesting == 0)
                return i;
            nesting--;
            break;
        }
    }
    return -1;
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.SourceMapper.java

License:Open Source License

private int getUnqualifiedTypeSignature(String qualifiedTypeSig, int start, int length,
        StringBuffer unqualifiedTypeSig, boolean noDollar) {
    char firstChar = qualifiedTypeSig.charAt(start);
    int end = start + 1;
    boolean sigStart = false;
    firstPass: for (int i = start; i < length; i++) {
        char current = qualifiedTypeSig.charAt(i);
        switch (current) {
        case Signature.C_ARRAY:
        case Signature.C_SUPER:
        case Signature.C_EXTENDS:
            unqualifiedTypeSig.append(current);
            start = i + 1;// w  ww  .j  a  v a  2s  .  co  m
            end = start + 1;
            firstChar = qualifiedTypeSig.charAt(start);
            break;
        case Signature.C_RESOLVED:
        case Signature.C_UNRESOLVED:
        case Signature.C_TYPE_VARIABLE:
            if (!sigStart) {
                start = ++i;
                sigStart = true;
            }
            break;
        case Signature.C_NAME_END:
        case Signature.C_GENERIC_START:
            end = i;
            break firstPass;
        case Signature.C_STAR:
            unqualifiedTypeSig.append(current);
            start = i + 1;
            end = start + 1;
            firstChar = qualifiedTypeSig.charAt(start);
            break;
        case Signature.C_GENERIC_END:
            return i;
        case Signature.C_DOT:
            start = ++i;
            break;
        case Signature.C_BOOLEAN:
        case Signature.C_BYTE:
        case Signature.C_CHAR:
        case Signature.C_DOUBLE:
        case Signature.C_FLOAT:
        case Signature.C_INT:
        case Signature.C_LONG:
        case Signature.C_SHORT:
            if (!sigStart) {
                unqualifiedTypeSig.append(current);
                return i + 1;
            }
        }
    }
    switch (firstChar) {
    case Signature.C_RESOLVED:
    case Signature.C_UNRESOLVED:
    case Signature.C_TYPE_VARIABLE:
        unqualifiedTypeSig.append(Signature.C_UNRESOLVED);
        if (noDollar) {
            int lastDollar = qualifiedTypeSig.lastIndexOf('$', end);
            if (lastDollar > start)
                start = lastDollar + 1;
        }
        for (int i = start; i < length; i++) {
            char current = qualifiedTypeSig.charAt(i);
            switch (current) {
            case Signature.C_GENERIC_START:
                unqualifiedTypeSig.append(current);
                i++;
                do {
                    i = getUnqualifiedTypeSignature(qualifiedTypeSig, i, length, unqualifiedTypeSig, noDollar);
                } while (qualifiedTypeSig.charAt(i) != Signature.C_GENERIC_END);
                unqualifiedTypeSig.append(Signature.C_GENERIC_END);
                break;
            case Signature.C_NAME_END:
                unqualifiedTypeSig.append(current);
                return i + 1;
            default:
                unqualifiedTypeSig.append(current);
                break;
            }
        }
        return length;
    default:
        // primitive type or wildcard
        unqualifiedTypeSig.append(qualifiedTypeSig.substring(start, end));
        return end;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

private static int scanGenericEnd(char[] string, int start) {
    if (string[start] == Signature.C_GENERIC_END) {
        return start;
    }/*from  w  ww. ja  v a2s.  c  o  m*/
    int length = string.length;
    int balance = 1;
    start++;
    while (start <= length) {
        switch (string[start]) {
        case Signature.C_GENERIC_END:
            balance--;
            if (balance == 0) {
                return start;
            }
            break;
        case Signature.C_GENERIC_START:
            balance++;
            break;
        }
        start++;
    }
    return start;
}

---

From source file:de.gebit.integrity.ui.utils.IntegrityDSLUIUtil.java

License:Open Source License

/**
 * Determines the fully qualified class name from a type signature and a type where that type signature is declared.
 * //from   w  w  w .j  a va2s .  co  m
 * @param aTypeSignature
 *            the type signature
 * @param aDeclaringType
 *            the type in which the type signature was found
 * @return the fully qualified class name, packaged up with generics parameter information
 * @throws JavaModelException
 */
public static ResolvedTypeName getResolvedTypeName(String aTypeSignature, IType aDeclaringType)
        throws JavaModelException {
    int tempArrayCount = Signature.getArrayCount(aTypeSignature);
    char tempType = aTypeSignature.charAt(tempArrayCount);
    if (tempType == Signature.C_UNRESOLVED) {
        String tempName = "";
        int tempBracketOpenPosition = aTypeSignature.indexOf(Signature.C_GENERIC_START, tempArrayCount + 1);
        if (tempBracketOpenPosition > 0) {
            tempName = aTypeSignature.substring(tempArrayCount + 1, tempBracketOpenPosition);
        } else {
            int tempSemicolonPosition = aTypeSignature.indexOf(Signature.C_SEMICOLON, tempArrayCount + 1);
            if (tempSemicolonPosition == -1) {
                throw new IllegalArgumentException();
            }
            tempName = aTypeSignature.substring(tempArrayCount + 1, tempSemicolonPosition);
        }
        String[][] tempResolvedNames = aDeclaringType.resolveType(tempName);
        if (tempResolvedNames != null && tempResolvedNames.length > 0) {
            StringBuffer tempBuffer = new StringBuffer();
            if (tempResolvedNames[0][0] != null && tempResolvedNames[0][0].length() > 0) {
                tempBuffer.append(tempResolvedNames[0][0]);
            }
            if (tempResolvedNames[0][1] != null && tempResolvedNames[0][1].length() > 0) {
                if (tempBuffer.length() > 0) {
                    tempBuffer.append('.');
                }
                tempBuffer.append(tempResolvedNames[0][1]);
            }
            String tempRawTypeName = tempBuffer.toString();

            // Now on to the generic parameters
            if (tempBracketOpenPosition > 0) {
                int tempBracketClosePosition = aTypeSignature.lastIndexOf(Signature.C_GENERIC_END);
                if (tempBracketClosePosition == -1) {
                    throw new IllegalArgumentException();
                }

                String tempParameterNamesSignature = aTypeSignature.substring(tempBracketOpenPosition + 1,
                        tempBracketClosePosition);

                // This one must be splitted now
                List<String> tempParameterNameSignatures = new ArrayList<String>();
                int tempGenericStackSize = 0;
                int tempStart = 0;
                for (int i = 0; i < tempParameterNamesSignature.length(); i++) {
                    char tempChar = tempParameterNamesSignature.charAt(i);
                    if (tempChar == Signature.C_GENERIC_START) {
                        tempGenericStackSize++;
                    } else if (tempChar == Signature.C_GENERIC_END) {
                        tempGenericStackSize--;
                    } else if (tempChar == Signature.C_SEMICOLON) {
                        if (tempGenericStackSize == 0) {
                            // this is a valid splitting point
                            tempParameterNameSignatures
                                    .add(tempParameterNamesSignature.substring(tempStart, i + 1));
                            tempStart = i + 1;
                        }
                    }
                }

                ResolvedTypeName[] tempGenericParameterTypes = new ResolvedTypeName[tempParameterNameSignatures
                        .size()];
                for (int i = 0; i < tempParameterNameSignatures.size(); i++) {
                    tempGenericParameterTypes[i] = getResolvedTypeName(tempParameterNameSignatures.get(i),
                            aDeclaringType);
                }

                return new ResolvedTypeName(tempRawTypeName, tempGenericParameterTypes);
            } else {
                return new ResolvedTypeName(tempRawTypeName);
            }
        }
        return null;
    } else {
        return new ResolvedTypeName(
                Signature.toString(aTypeSignature.substring(tempArrayCount)).replace('/', '.'));
    }
}

---

From source file:dynamicrefactoring.integration.TypeConversor.java

License:Open Source License

/**
 * Realiza la conversin entre la convencin utilizada por Eclipse para la
 * representacin de las signaturas de los tipos y la utilizada por el modelo
 * MOON./*from  w  w w  .  j a  va2s  .c  om*/
 * 
 * @param type la cadena de caracteres con el tipo representado segn la 
 * convencin utilizada por Eclipse.
 * 
 * @return la cadena de caracteres con la representacin del tipo segn la
 * convencin utilizada en MOON.
 * 
 * @see org.eclipse.jdt.core.Signature
 */
public String convertType(String type) {
    if (primitiveConversionTable.containsKey(type))
        return primitiveConversionTable.get(type);
    if (type.startsWith(Character.valueOf(Signature.C_ARRAY).toString()))
        return convertType(type.substring(1)) + "[]"; //$NON-NLS-1$

    if (type.contains(Character.valueOf(Signature.C_GENERIC_START).toString())
            && type.endsWith(Character.valueOf(Signature.C_GENERIC_END).toString() + Signature.C_SEMICOLON)) {

        // MOON no incluye los tipos paramtricos en el nombre nico.
        // Solo se incluye el nombre del tipo genrico, la clase.
        String parametricType = convertType(type.substring(0, type.indexOf(Signature.C_GENERIC_START)));

        return parametricType;
    }

    if (type.startsWith(Character.valueOf(Signature.C_UNRESOLVED).toString()))
        return convertNonPrimitiveType(type.substring(1));
    return null;

}

---

From source file:org.eclipse.recommenders.completion.rcp.utils.ProposalUtils.java

License:Open Source License

/**
 * Ensures that the separator of inner and outer types is always a dollar sign.
 *
 * <p>/*from  w  w  w  .j  a  v  a2  s  .  c om*/
 * This is necessary, as JDT uses a dot rather than dollar sign to separate inner and outer type <em>if</em> the
 * outer type is parameterized.
 * </p>
 *
 * <p>
 * Examples:
 * </p>
 *
 * <ul>
 * <li><code>org.example.Outer$Inner&lt:java.lang.String&gt;</code> ->
 * <code>org.example.Outer$Inner&lt:java.lang.String&gt;</code></li>
 * <li><code>org.example.Outer&lt:java.lang.String&gt;.Inner</code> ->
 * <code>org.example.Outer&lt:java.lang.String&gt;$Inner</code></li>
 * <ul>
 */
private static char[] getBinaryTypeSignatureCopy(char[] parameterizedTypeSignature) {
    char[] binaryTypeSignature = Arrays.copyOf(parameterizedTypeSignature, parameterizedTypeSignature.length);
    int nextDot = -1;
    while ((nextDot = CharOperation.indexOf(Signature.C_DOT, binaryTypeSignature, nextDot + 1)) > 0) {
        if (binaryTypeSignature[nextDot - 1] == Signature.C_GENERIC_END) {
            binaryTypeSignature[nextDot] = Signature.C_DOLLAR;
        }
    }
    return binaryTypeSignature;
}

---

From source file:org.jboss.tools.common.java.ParametedType.java

License:Open Source License

public String resolveParameters(String typeSignature) {
    if (typeSignature == null) {
        return typeSignature;
    }//from  w  w w.j  ava  2  s.  co  m
    int i = typeSignature.indexOf(Signature.C_GENERIC_START);
    if (i < 0) {
        char c = typeSignature.length() == 0 ? '\0' : typeSignature.charAt(0);
        char e = typeSignature.length() == 0 ? '\0' : typeSignature.charAt(typeSignature.length() - 1);
        if ((c == Signature.C_TYPE_VARIABLE || c == Signature.C_UNRESOLVED || c == Signature.C_RESOLVED)
                && e == Signature.C_SEMICOLON) {
            String param = typeSignature.substring(1, typeSignature.length() - 1);
            String s = findParameterSignature(param);
            return s == null ? typeSignature : s;
        }
        return typeSignature;
    }
    int j = typeSignature.lastIndexOf(Signature.C_GENERIC_END);
    if (j < i) {
        return typeSignature;
    }
    boolean replaced = false;
    StringBuffer newParams = new StringBuffer();
    String[] ps = Signature.getTypeArguments(typeSignature);
    for (String param : ps) {
        String newParam = resolveParameters(param);
        if (!param.equals(newParam))
            replaced = true;
        newParams.append(newParam);
    }
    if (replaced) {
        typeSignature = typeSignature.substring(0, i) + Signature.C_GENERIC_START + newParams.toString()
                + Signature.C_GENERIC_END + Signature.C_SEMICOLON;
    }
    return typeSignature;
}

---

From source file:org.jboss.tools.common.java.ParametedTypeFactory.java

License:Open Source License

public ParametedType getParametedType(IMember context, IParametedType basetype, String typeSignature)
        throws JavaModelException {
    if (typeSignature == null)
        return null;
    if (basetype != null) {
        ParametedType param = ((ParametedType) basetype).findParameter(typeSignature);
        if (param != null)
            return param;
    }//  www  .ja v a2 s . c  om

    IType contextType = context instanceof IType ? (IType) context : context.getDeclaringType();

    String key = context == null || context.isBinary() || OBJECT.equals(typeSignature) ? typeSignature
            : contextType.getFullyQualifiedName() + "+" + typeSignature;
    if (cache.containsKey(key))
        return cache.get(key);
    ParametedType result = new ParametedType();
    result.setFactory(this);
    result.setSignature(typeSignature);

    typeSignature = typeSignature.substring(result.getArrayIndex());

    char c = typeSignature.length() == 0 ? '\0' : typeSignature.charAt(0);
    if (primitives.containsKey(c) && typeSignature.length() == 1) {
        typeSignature = primitives.get(c);
        result.setSignature(result.getArrayPrefix() + typeSignature);
        result.setPrimitive(true);
    } else if (c == Signature.C_EXTENDS) {
        typeSignature = typeSignature.substring(1);
        result.setUpper(true);
    } else if (c == Signature.C_SUPER) {
        typeSignature = typeSignature.substring(1);
        result.setLower(true);
    } else if (c == Signature.C_STAR && typeSignature.length() == 1) {
        result.setUpper(true);
        return result;
    }

    int startToken = typeSignature.indexOf(Signature.C_GENERIC_START);
    if (startToken < 0) {
        String resovedTypeName = EclipseJavaUtil.resolveTypeAsString(contextType, typeSignature);
        if (resovedTypeName == null)
            return null;
        if (!context.isBinary() || typeSignature.charAt(0) == Signature.C_TYPE_VARIABLE) {
            StringBuffer ns = new StringBuffer();
            ns.append(result.getArrayPrefix());
            if (result.isLower())
                ns.append(Signature.C_SUPER);
            if (result.isUpper())
                ns.append(Signature.C_EXTENDS);
            ns.append(Signature.C_RESOLVED).append(resovedTypeName).append(Signature.C_SEMICOLON);
            result.setSignature(ns.toString());
        }
        IType type = EclipseJavaUtil.findType(context.getJavaProject(), resovedTypeName);
        if (type != null) {
            result.setType(type);
            cache.put(key, result);
            return result;
        }
        if (context instanceof IMethod) {
            String[] ps = ((IMethod) context).getTypeParameterSignatures();
            for (int i = 0; i < ps.length; i++) {
                ParametedType st = getParametedTypeForParameter(context, ps[i], result);
                if (st != null) {
                    if (st.getSignature().indexOf(Signature.C_COLON) >= 0) {
                        CommonCorePlugin.getDefault().logWarning("Wrong signature=" + st.getSignature());
                    }
                    return st;
                }
            }
        }
        String[] ps = contextType.getTypeParameterSignatures();
        for (int i = 0; i < ps.length; i++) {
            ParametedType st = getParametedTypeForParameter(contextType, ps[i], result);
            if (st != null)
                return st;
        }
    } else {
        int endToken = typeSignature.lastIndexOf(Signature.C_GENERIC_END);
        if (endToken < startToken)
            return null;
        String typeName = typeSignature.substring(0, startToken) + typeSignature.substring(endToken + 1);
        String resovedTypeName = EclipseJavaUtil.resolveTypeAsString(contextType, typeName);
        if (resovedTypeName == null)
            return null;
        IType type = EclipseJavaUtil.findType(context.getJavaProject(), resovedTypeName);
        if (type != null) {
            result.setType(type);
            cache.put(key, result);
            StringBuffer newParams = new StringBuffer();
            String[] paramSignatures = null;
            try {
                paramSignatures = Signature.getTypeArguments(typeSignature);
            } catch (IllegalArgumentException e) {
                CommonCorePlugin.getDefault().logError(e);
            }
            if (paramSignatures != null)
                for (String paramSignature : paramSignatures) {
                    ParametedType param = getParametedType(context, basetype, paramSignature);
                    if (param == null) {
                        param = new ParametedType();
                        param.setSignature(paramSignature);
                    }
                    result.addParameter(param);
                    newParams.append(param.getSignature());
                }
            if (!context.isBinary()) {
                StringBuffer ns = new StringBuffer();
                ns.append(result.getArrayPrefix());
                if (result.isLower())
                    ns.append(Signature.C_SUPER);
                if (result.isUpper())
                    ns.append(Signature.C_EXTENDS);
                ns.append(Signature.C_RESOLVED).append(resovedTypeName).append(Signature.C_GENERIC_START)
                        .append(newParams).append(Signature.C_GENERIC_END).append(Signature.C_SEMICOLON);
                result.setSignature(ns.toString());
            }
            return result;
        }
    }
    return null;
}

---

From source file:org.springframework.tooling.jdt.ls.commons.java.JavaData.java

License:Open Source License

private JavaTypeData createFromSignature(IType type, String signature) {
    JavaTypeData data = new JavaTypeData();
    data.setName(signature);/*  w  w w  .  ja v a2  s.c  o  m*/

    char[] typeSignature = signature.toCharArray();

    String[] typeArguments = Signature.getTypeArguments(signature);
    if (typeArguments != null && typeArguments.length > 0) {
        JavaTypeData[] javaTypeArguments = new JavaTypeData[typeArguments.length];
        for (int i = 0; i < typeArguments.length; i++) {
            javaTypeArguments[i] = createFromSignature(type, typeArguments[i]);
            // In case binding key is unresolved replace each argument with resolved one.
            data.setName(data.getName().replace(typeArguments[i], javaTypeArguments[i].getName()));
        }
        data.setKind(JavaTypeKind.PARAMETERIZED);
        LinkedHashMap<String, Object> extras = new LinkedHashMap<>();
        String typeErasure = Signature.getTypeErasure(signature);
        JavaTypeData owner = createFromSignature(type, typeErasure);
        extras.put("owner", owner);
        extras.put("arguments", javaTypeArguments);
        data.setExtras(extras);
        // In case binding key is unresolved replace owner. Trim trailing ; from type erasure string and from the replacement
        data.setName(data.getName().replace(typeErasure.substring(0, typeErasure.length() - 1),
                owner.getName().substring(0, owner.getName().length() - 1)));

    } else {
        // need a minimum 1 char
        if (typeSignature.length < 1) {
            throw new IllegalArgumentException();
        }
        char c = typeSignature[0];
        if (c == Signature.C_GENERIC_START) {
            int count = 1;
            for (int i = 1, length = typeSignature.length; i < length; i++) {
                switch (typeSignature[i]) {
                case Signature.C_GENERIC_START:
                    count++;
                    break;
                case Signature.C_GENERIC_END:
                    count--;
                    break;
                }
                if (count == 0) {
                    if (i + 1 < length)
                        c = typeSignature[i + 1];
                    break;
                }
            }
        }
        switch (c) {
        case Signature.C_ARRAY:
            data.setKind(JavaTypeKind.ARRAY);
            LinkedHashMap<String, Object> extras = new LinkedHashMap<>();
            extras.put("component", createFromSignature(type, Signature.getElementType(signature)));
            extras.put("dimensions", Signature.getArrayCount(typeSignature));
            data.setExtras(extras);
            break;
        case Signature.C_RESOLVED:
            data.setKind(JavaTypeKind.CLASS);
            break;
        case Signature.C_TYPE_VARIABLE:
            data.setKind(JavaTypeKind.TYPE_VARIABLE);
            break;
        case Signature.C_BOOLEAN:
            data.setKind(JavaTypeKind.BOOLEAN);
            break;
        case Signature.C_BYTE:
            data.setKind(JavaTypeKind.BYTE);
            break;
        case Signature.C_CHAR:
            data.setKind(JavaTypeKind.CHAR);
            break;
        case Signature.C_DOUBLE:
            data.setKind(JavaTypeKind.DOUBLE);
            break;
        case Signature.C_FLOAT:
            data.setKind(JavaTypeKind.FLOAT);
            break;
        case Signature.C_INT:
            data.setKind(JavaTypeKind.INT);
            break;
        case Signature.C_LONG:
            data.setKind(JavaTypeKind.LONG);
            break;
        case Signature.C_SHORT:
            data.setKind(JavaTypeKind.SHORT);
            break;
        case Signature.C_VOID:
            data.setKind(JavaTypeKind.VOID);
            break;
        case Signature.C_STAR:
        case Signature.C_SUPER:
        case Signature.C_EXTENDS:
            data.setKind(JavaTypeKind.WILDCARD);
            break;
        case Signature.C_UNRESOLVED:
            if (type != null) {
                // Attempt to resolve type. For some reason JDT has them unresolved for type members
                try {
                    String signatureSimpleName = Signature.getSignatureSimpleName(signature);
                    String resolvedType = resolveFQName(type, signatureSimpleName);
                    if (resolvedType != null) {
                        data.setKind(JavaTypeKind.CLASS);
                        data.setName("L" + resolvedType.replace('.', '/') + ";");
                        break;
                    }
                } catch (JavaModelException e) {
                    data.setKind(JavaTypeKind.UNRESOLVED);
                }
            }
        case Signature.C_CAPTURE:
        case Signature.C_INTERSECTION:
        case Signature.C_UNION:
        default:
            data.setKind(JavaTypeKind.UNRESOLVED);
            break;
        }
    }

    return data;
}

---