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_CAPTURE.

Prototype

char C_CAPTURE

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

Click Source Link

Document

Character constant indicating a capture of a wildcard type in a signature.

Usage

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 w w w.java2 s  .  com
    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 appendCaptureTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
    // need a minimum 2 char
    if (start >= string.length - 1) {
        throw new IllegalArgumentException();
    }/*from   w w  w. ja  v  a2  s . c  o  m*/
    char c = string[start];
    if (c != Signature.C_CAPTURE) {
        throw new IllegalArgumentException();
    }
    return appendTypeArgumentSignatureForAnchor(string, start + 1, buffer);
}

From source file:com.sabre.buildergenerator.eclipsejavamodel.ModelHelper.java

License:Open Source License

public String getTypeParameterSignature(String resolvedTypeSignature) {
    String[] typeArguments = Signature.getTypeArguments(resolvedTypeSignature);

    if (typeArguments != null && typeArguments.length == 1) {
        String fieldTypeArgumentSignature = typeArguments[0];

        return fieldTypeArgumentSignature.charAt(0) == Signature.C_EXTENDS
                || fieldTypeArgumentSignature.charAt(0) == Signature.C_SUPER
                || fieldTypeArgumentSignature.charAt(0) == Signature.C_CAPTURE
                        ? fieldTypeArgumentSignature.substring(1)
                        : fieldTypeArgumentSignature.equals(String.valueOf(Signature.C_STAR)) ? OBJECT_SIGNATURE
                                : fieldTypeArgumentSignature;
    }//from  w ww. j ava  2 s .com

    return OBJECT_SIGNATURE;
}

From source file:org.eclipse.recommenders.calls.rcp.ProposalMatcher.java

License:Open Source License

private boolean isWildcardCapture(String param) {
    return param.charAt(0) == Signature.C_CAPTURE;
}

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);//from w  w w . j  av  a  2  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;
}

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

Introduction

Prototype

Document

Usage