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

Introduction

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

Prototype

char C_UNION

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

Click Source Link

Document

Character constant indicating a union type in a signature.

Usage

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  a  2s  . 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;
}

---