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

Introduction

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

Prototype

char C_ARRAY

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

Click Source Link

Document

Character constant indicating an array type in a signature.

Usage

From source file:ca.mcgill.cs.swevo.jayfx.FastConverter.java

License:Open Source License

public String resolveType(String pType, final IType pEnclosingType) throws ConversionException {
    String lReturn = "";
    int lDepth = 0;
    int lIndex = 0;
    while (pType.charAt(lIndex) == Signature.C_ARRAY) {
        lDepth++;/*w w w.ja v  a 2  s  . co  m*/
        lIndex++;
    }

    if (pType.charAt(lIndex) == Signature.C_BYTE || pType.charAt(lIndex) == Signature.C_CHAR
            || pType.charAt(lIndex) == Signature.C_DOUBLE || pType.charAt(lIndex) == Signature.C_FLOAT
            || pType.charAt(lIndex) == Signature.C_INT || pType.charAt(lIndex) == Signature.C_LONG
            || pType.charAt(lIndex) == Signature.C_SHORT || pType.charAt(lIndex) == Signature.C_VOID
            || pType.charAt(lIndex) == Signature.C_BOOLEAN || pType.charAt(lIndex) == Signature.C_RESOLVED)
        lReturn = pType;
    else
        try {
            pType = Signature.getTypeErasure(pType);
            final int lIndex2 = pType.indexOf(Signature.C_NAME_END);
            final String lType = pType.substring(lIndex + 1, lIndex2);
            final String[][] lTypes = pEnclosingType.resolveType(lType);
            if (lTypes == null)
                throw new ConversionException("Cannot convert type " + lType + " in " + pEnclosingType);
            if (lTypes.length != 1)
                throw new ConversionException("Cannot convert type " + lType + " in " + pEnclosingType);
            for (int i = 0; i < lDepth; i++)
                lReturn += "[";
            lReturn += "L" + lTypes[0][0] + "." + lTypes[0][1].replace('.', '$') + ";";
        } catch (final JavaModelException pException) {
            throw new ConversionException(pException);
        }
    return lReturn;
}

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

License:Open Source License

public IJavaElement getHandleFromMemento(String token, MementoTokenizer memento,
        WorkingCopyOwner workingCopyOwner) {
    switch (token.charAt(0)) {
    case JEM_COUNT:
        return getHandleUpdatingCountFromMemento(memento, workingCopyOwner);
    case JEM_FIELD:
        if (!memento.hasMoreTokens())
            return this;
        String fieldName = memento.nextToken();
        JavaElement field = (JavaElement) getField(fieldName);
        return field.getHandleFromMemento(memento, workingCopyOwner);
    case JEM_INITIALIZER:
        if (!memento.hasMoreTokens())
            return this;
        String count = memento.nextToken();
        JavaElement initializer = (JavaElement) getInitializer(Integer.parseInt(count));
        return initializer.getHandleFromMemento(memento, workingCopyOwner);
    case JEM_METHOD:
        if (!memento.hasMoreTokens())
            return this;
        String selector = memento.nextToken();
        ArrayList params = new ArrayList();
        nextParam: while (memento.hasMoreTokens()) {
            token = memento.nextToken();
            switch (token.charAt(0)) {
            case JEM_TYPE:
            case JEM_TYPE_PARAMETER:
            case JEM_ANNOTATION:
                break nextParam;
            case JEM_METHOD:
                if (!memento.hasMoreTokens())
                    return this;
                String param = memento.nextToken();
                StringBuffer buffer = new StringBuffer();
                while (param.length() == 1 && Signature.C_ARRAY == param.charAt(0)) { // backward compatible with 3.0 mementos
                    buffer.append(Signature.C_ARRAY);
                    if (!memento.hasMoreTokens())
                        return this;
                    param = memento.nextToken();
                }//from w w  w.  j a va2 s. co m
                params.add(buffer.toString() + param);
                break;
            default:
                break nextParam;
            }
        }
        String[] parameters = new String[params.size()];
        params.toArray(parameters);
        JavaElement method = (JavaElement) getMethod(selector, parameters);
        switch (token.charAt(0)) {
        case JEM_LAMBDA_EXPRESSION:
        case JEM_TYPE:
        case JEM_TYPE_PARAMETER:
        case JEM_LOCALVARIABLE:
        case JEM_ANNOTATION:
            return method.getHandleFromMemento(token, memento, workingCopyOwner);
        default:
            return method;
        }
    case JEM_TYPE:
        String typeName;
        if (memento.hasMoreTokens()) {
            typeName = memento.nextToken();
            char firstChar = typeName.charAt(0);
            if (firstChar == JEM_FIELD || firstChar == JEM_INITIALIZER || firstChar == JEM_METHOD
                    || firstChar == JEM_TYPE || firstChar == JEM_COUNT) {
                token = typeName;
                typeName = ""; //$NON-NLS-1$
            } else {
                token = null;
            }
        } else {
            typeName = ""; //$NON-NLS-1$
            token = null;
        }
        JavaElement type = (JavaElement) getType(typeName);
        if (token == null) {
            return type.getHandleFromMemento(memento, workingCopyOwner);
        } else {
            return type.getHandleFromMemento(token, memento, workingCopyOwner);
        }
    case JEM_TYPE_PARAMETER:
        //         if (!memento.hasMoreTokens()) return this;
        //         String typeParameterName = memento.nextToken();
        //         JavaElement typeParameter = new TypeParameter(this, typeParameterName);
        //         return typeParameter.getHandleFromMemento(memento, workingCopyOwner);
        throw new UnsupportedOperationException();
    case JEM_ANNOTATION:
        //         if (!memento.hasMoreTokens()) return this;
        //         String annotationName = memento.nextToken();
        //         JavaElement annotation = new Annotation(this, annotationName);
        //         return annotation.getHandleFromMemento(memento, workingCopyOwner);
        throw new UnsupportedOperationException();
    }
    return null;
}

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;/*from w  w w  .ja  v  a2 s  .  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.SourceType.java

License:Open Source License

public IJavaElement getHandleFromMemento(String token, MementoTokenizer memento,
        WorkingCopyOwner workingCopyOwner) {
    switch (token.charAt(0)) {
    case JEM_COUNT:
        return getHandleUpdatingCountFromMemento(memento, workingCopyOwner);
    case JEM_FIELD:
        if (!memento.hasMoreTokens())
            return this;
        String fieldName = memento.nextToken();
        JavaElement field = (JavaElement) getField(fieldName);
        return field.getHandleFromMemento(memento, workingCopyOwner);
    case JEM_INITIALIZER:
        if (!memento.hasMoreTokens())
            return this;
        String count = memento.nextToken();
        JavaElement initializer = (JavaElement) getInitializer(Integer.parseInt(count));
        return initializer.getHandleFromMemento(memento, workingCopyOwner);
    case JEM_METHOD:
        if (!memento.hasMoreTokens())
            return this;
        String selector = memento.nextToken();
        ArrayList params = new ArrayList();
        nextParam: while (memento.hasMoreTokens()) {
            token = memento.nextToken();
            switch (token.charAt(0)) {
            case JEM_TYPE:
            case JEM_TYPE_PARAMETER:
            case JEM_ANNOTATION:
                break nextParam;
            case JEM_METHOD:
                if (!memento.hasMoreTokens())
                    return this;
                String param = memento.nextToken();
                StringBuffer buffer = new StringBuffer();
                while (param.length() == 1 && Signature.C_ARRAY == param.charAt(0)) { // backward compatible with 3.0 mementos
                    buffer.append(Signature.C_ARRAY);
                    if (!memento.hasMoreTokens())
                        return this;
                    param = memento.nextToken();
                }/*  w w w  . ja v  a 2 s  . c om*/
                params.add(buffer.toString() + param);
                break;
            default:
                break nextParam;
            }
        }
        String[] parameters = new String[params.size()];
        params.toArray(parameters);
        JavaElement method = (JavaElement) getMethod(selector, parameters);
        switch (token.charAt(0)) {
        case JEM_LAMBDA_EXPRESSION:
        case JEM_TYPE:
        case JEM_TYPE_PARAMETER:
        case JEM_LOCALVARIABLE:
        case JEM_ANNOTATION:
            return method.getHandleFromMemento(token, memento, workingCopyOwner);
        default:
            return method;
        }
    case JEM_TYPE:
        String typeName;
        if (memento.hasMoreTokens()) {
            typeName = memento.nextToken();
            char firstChar = typeName.charAt(0);
            if (firstChar == JEM_FIELD || firstChar == JEM_INITIALIZER || firstChar == JEM_METHOD
                    || firstChar == JEM_TYPE || firstChar == JEM_COUNT) {
                token = typeName;
                typeName = ""; //$NON-NLS-1$
            } else {
                token = null;
            }
        } else {
            typeName = ""; //$NON-NLS-1$
            token = null;
        }
        JavaElement type = (JavaElement) getType(typeName);
        if (token == null) {
            return type.getHandleFromMemento(memento, workingCopyOwner);
        } else {
            return type.getHandleFromMemento(token, memento, workingCopyOwner);
        }
    case JEM_TYPE_PARAMETER:
        if (!memento.hasMoreTokens())
            return this;
        String typeParameterName = memento.nextToken();
        JavaElement typeParameter = new TypeParameter(this, manager, typeParameterName);
        return typeParameter.getHandleFromMemento(memento, workingCopyOwner);
    case JEM_ANNOTATION:
        if (!memento.hasMoreTokens())
            return this;
        String annotationName = memento.nextToken();
        JavaElement annotation = new Annotation(this, manager, annotationName);
        return annotation.getHandleFromMemento(memento, workingCopyOwner);
    }
    return null;
}

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

License:Open Source License

private static void appendArrayTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
    int length = string.length;
    // need a minimum 2 char
    if (start >= length - 1) {
        throw new IllegalArgumentException();
    }/* ww w.j  ava 2s.com*/
    char c = string[start];
    if (c != Signature.C_ARRAY) {
        throw new IllegalArgumentException();
    }

    int index = start;
    c = string[++index];
    while (c == Signature.C_ARRAY) {
        // need a minimum 2 char
        if (index >= length - 1) {
            throw new IllegalArgumentException();
        }
        c = string[++index];
    }

    appendTypeSignature(string, index, buffer, compact);

    for (int i = 0, dims = index - start; i < dims; i++) {
        buffer.append('[').append(']');
    }
}

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

License:Open Source License

static void appendTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
    char c = string[start];
    switch (c) {//from   w ww .  jav a2s.c  o  m
    case Signature.C_ARRAY:
        appendArrayTypeSignature(string, start, buffer, compact);
        break;
    case Signature.C_RESOLVED:
        appendClassTypeSignature(string, start, buffer, compact);
        break;
    case Signature.C_TYPE_VARIABLE:
        int e = org.eclipse.jdt.internal.compiler.util.Util.scanTypeVariableSignature(string, start);
        buffer.append(string, start + 1, e - start - 1);
        break;
    case Signature.C_BOOLEAN:
        buffer.append(BOOLEAN);
        break;
    case Signature.C_BYTE:
        buffer.append(BYTE);
        break;
    case Signature.C_CHAR:
        buffer.append(CHAR);
        break;
    case Signature.C_DOUBLE:
        buffer.append(DOUBLE);
        break;
    case Signature.C_FLOAT:
        buffer.append(FLOAT);
        break;
    case Signature.C_INT:
        buffer.append(INT);
        break;
    case Signature.C_LONG:
        buffer.append(LONG);
        break;
    case Signature.C_SHORT:
        buffer.append(SHORT);
        break;
    case Signature.C_VOID:
        buffer.append(VOID);
        break;
    }
}

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

License:Open Source License

private static int appendTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer,
        boolean isVarArgs) {
    // need a minimum 1 char
    if (start >= string.length) {
        throw new IllegalArgumentException();
    }/*from ww w.  ja v  a 2 s  . c o m*/
    char c = string[start];
    if (isVarArgs) {
        switch (c) {
        case Signature.C_ARRAY:
            return appendArrayTypeSignatureForAnchor(string, start, buffer, true);
        case Signature.C_RESOLVED:
        case Signature.C_TYPE_VARIABLE:
        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:
        case Signature.C_VOID:
        case Signature.C_STAR:
        case Signature.C_EXTENDS:
        case Signature.C_SUPER:
        case Signature.C_CAPTURE:
        default:
            throw new IllegalArgumentException(); // a var args is an array type
        }
    } else {
        switch (c) {
        case Signature.C_ARRAY:
            return appendArrayTypeSignatureForAnchor(string, start, buffer, false);
        case Signature.C_RESOLVED:
            return appendClassTypeSignatureForAnchor(string, start, buffer);
        case Signature.C_TYPE_VARIABLE:
            int e = org.eclipse.jdt.internal.compiler.util.Util.scanTypeVariableSignature(string, start);
            buffer.append(string, start + 1, e - start - 1);
            return e;
        case Signature.C_BOOLEAN:
            buffer.append(BOOLEAN);
            return start;
        case Signature.C_BYTE:
            buffer.append(BYTE);
            return start;
        case Signature.C_CHAR:
            buffer.append(CHAR);
            return start;
        case Signature.C_DOUBLE:
            buffer.append(DOUBLE);
            return start;
        case Signature.C_FLOAT:
            buffer.append(FLOAT);
            return start;
        case Signature.C_INT:
            buffer.append(INT);
            return start;
        case Signature.C_LONG:
            buffer.append(LONG);
            return start;
        case Signature.C_SHORT:
            buffer.append(SHORT);
            return start;
        case Signature.C_VOID:
            buffer.append(VOID);
            return start;
        case Signature.C_CAPTURE:
            return appendCaptureTypeSignatureForAnchor(string, start, buffer);
        case Signature.C_STAR:
        case Signature.C_EXTENDS:
        case Signature.C_SUPER:
            return appendTypeArgumentSignatureForAnchor(string, start, buffer);
        default:
            throw new IllegalArgumentException();
        }
    }
}

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

License:Open Source License

private static int appendArrayTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer,
        boolean isVarArgs) {
    int length = string.length;
    // need a minimum 2 char
    if (start >= length - 1) {
        throw new IllegalArgumentException();
    }//  w ww .  j  a v a2 s .  co m
    char c = string[start];
    if (c != Signature.C_ARRAY) {
        throw new IllegalArgumentException();
    }

    int index = start;
    c = string[++index];
    while (c == Signature.C_ARRAY) {
        // need a minimum 2 char
        if (index >= length - 1) {
            throw new IllegalArgumentException();
        }
        c = string[++index];
    }

    int e = appendTypeSignatureForAnchor(string, index, buffer, false);

    for (int i = 1, dims = index - start; i < dims; i++) {
        buffer.append('[').append(']');
    }

    if (isVarArgs) {
        buffer.append('.').append('.').append('.');
    } else {
        buffer.append('[').append(']');
    }
    return e;
}

From source file:com.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * Resolve typeSignature in the context of owningType.  This method will return 
 * a type erased signture if eraseTypeParameters == true and will attempt to
 * resolve and include parameters if eraseTypeParamters == false
 * /*from   w  ww. j  a  va 2  s .  com*/
 * NOTE: special rules apply to the way unresolved type parameters and wildcards
 * are resolved:
 * 
 * 1) If a fully unresolved type parameter is found, then it will be replaced with Ljava.lang.Object;
 * 
 * i.e.  List<T>  -> Ljava.util.List<Ljava.lang.Object;>;  for any unresolved T.
 * 
 * 2) Any bounded wildcard will be replaced by the bound:
 * 
 * i.e. List<? extends String> -> Ljava.util.List<Ljava.lang.String;>;
 * i.e. List<? super String> -> Ljava.util.List<Ljava.lang.String;>;
 * 
 * Note limitation here: bounds that use 'super' will take the "best case" scenario that the list
 * type is of that type.
 * 
 * 3) The unbounded wildcard will be replaced by Ljava.lang.Object;
 * 
 * i.e. List<?> -> Ljava.util.List<Ljava.lang.Object;>;
 * 
 * 
 * The reason for this substition is to return the most accurate reasonable approximation
 * of the type within what is known by owningType
 * 
 * @param owningType
 * @param typeSignature
 * @param eraseTypeParameters if set to false, type parameters are resolved included
 * in the signature
 * @return the resolved type signature for typeSignature in owningType or
 * typeSignature unchanged if cannot resolve.
 */
public static String resolveTypeSignature(final IType owningType, final String typeSignature,
        boolean eraseTypeParameters) {
    final int sigKind = Signature.getTypeSignatureKind(typeSignature);

    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        return typeSignature;

    case Signature.ARRAY_TYPE_SIGNATURE: {
        final String elementType = Signature.getElementType(typeSignature);

        if (Signature.getTypeSignatureKind(elementType) == Signature.BASE_TYPE_SIGNATURE) {
            return typeSignature;
        }

        final String resolvedElementType = resolveSignatureRelative(owningType, elementType,
                eraseTypeParameters);
        String resultType = ""; //$NON-NLS-1$
        for (int i = 0; i < Signature.getArrayCount(typeSignature); i++) {
            resultType += Signature.C_ARRAY;
        }

        return resultType + resolvedElementType;
    }

    case Signature.TYPE_VARIABLE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.CLASS_TYPE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.WILDCARD_TYPE_SIGNATURE:
        // strip the wildcard and try again.  Too bad Signature doesn't seem to have a method
        // for this
        if (typeSignature.charAt(0) == Signature.C_STAR) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }
        return resolveTypeSignature(owningType, typeSignature.substring(1), eraseTypeParameters);

    case Signature.CAPTURE_TYPE_SIGNATURE:
        // strip the capture and try again
        return resolveTypeSignature(owningType, Signature.removeCapture(typeSignature), eraseTypeParameters);
    //      case Signature.TYPE_VARIABLE_SIGNATURE:
    //      resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    default:
        return typeSignature;
    }
}

From source file:com.mountainminds.eclemma.internal.core.analysis.SignatureResolver.java

License:Open Source License

private static final void resolveArrayParameterType(final IMethod method, final String parameterType,
        final StringBuffer result) throws JavaModelException {
    final int arrayCount = Signature.getArrayCount(parameterType);
    for (int i = 0; i < arrayCount; i++) {
        result.append(Signature.C_ARRAY);
    }//from  w  ww  .j a va  2 s  .  c  o m
    resolveParameterType(method, parameterType.substring(arrayCount), result);
}

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

Introduction

Prototype

Document

Usage