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

List of usage examples for org.eclipse.jdt.core Signature CLASS_TYPE_SIGNATURE

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. Signature
  6. CLASS_TYPE_SIGNATURE

Introduction

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

Prototype

int CLASS_TYPE_SIGNATURE

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

Click Source Link

Document

Kind constant for a class type signature.

Usage

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  w  w.j a  v  a2 s.  c o 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.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  av a2  s. c  om
    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:ca.uvic.chisel.javasketch.internal.JavaSearchUtils.java

License:Open Source License

public static boolean isSimilar(IMethod method1, IMethod method2) {
    String[] myParams = method1.getParameterTypes();
    String[] theirParams = method2.getParameterTypes();
    int myParamsLength = myParams.length;
    String[] simpleNames = new String[myParamsLength];
    for (int i = 0; i < myParamsLength; i++) {
        String erasure = Signature.getTypeErasure(myParams[i]);
        simpleNames[i] = Signature.getSimpleName(Signature.toString(erasure));
    }//from   w ww.jav a 2 s .c  o  m
    String name = method1.getElementName();
    if (name.equals(method2.getElementName())) {

        if (myParamsLength == theirParams.length) {
            for (int i = 0; i < myParamsLength; i++) {

                String mySimpleName = simpleNames[i];
                String simpleName2 = Signature
                        .getSimpleName(Signature.toString(Signature.getTypeErasure(theirParams[i])));
                //first, check for generics. If my param is not generic,
                //but theirs is, it is a match.
                int myTypeKind = Signature.getTypeSignatureKind(myParams[i]);
                int theirTypeKind = Signature.getTypeSignatureKind(theirParams[i]);
                switch (theirTypeKind) {
                case Signature.TYPE_VARIABLE_SIGNATURE:
                case Signature.WILDCARD_TYPE_SIGNATURE:
                case Signature.CAPTURE_TYPE_SIGNATURE:
                    switch (myTypeKind) {
                    case Signature.CLASS_TYPE_SIGNATURE:
                    case Signature.ARRAY_TYPE_SIGNATURE:
                        continue;
                    }
                }
                //otherwise, try and match exactly
                if (!mySimpleName.equals(simpleName2)) {
                    return false;
                }
            }
            return true;
        }
    }
    return false;
}

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 w w  . java2 s .c  o  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.CompilationUnitCreator.java

License:Open Source License

private boolean addImport(Set<String> names, List<String> entityNameList,
        IImportDeclaration[] importDeclarations, ImportsManager imports) {
    boolean addedImport = false;
    for (String name : names) {
        if (Signature.getTypeSignatureKind(name) == Signature.CLASS_TYPE_SIGNATURE) {
            if (entityNameList.contains(Signature.toString(name))) {
                addedImport = true;/*  w ww  .j  ava  2  s . com*/
            } else {
                for (IImportDeclaration imp : importDeclarations) {
                    if (imp.getElementName().contains(Signature.toString(name))) {
                        imports.addImport(imp.getElementName());
                    }
                }
            }
        }
    }
    return addedImport;
}

From source file:com.google.gdt.eclipse.appengine.rpc.wizards.helpers.RpcServiceLayerCreator.java

License:Open Source License

private boolean addImport(List<String> names, List<String> entityNameList,
        IImportDeclaration[] importDeclarations, ImportsManager imports) {
    boolean addedImport = false;
    for (String name : names) {
        if (Signature.getTypeSignatureKind(name) == Signature.CLASS_TYPE_SIGNATURE) {
            if (entityNameList.contains(Signature.toString(name))) {
                addedImport = true;/*from  w w w .ja v a  2s.  c  om*/
            } else {
                for (IImportDeclaration imp : importDeclarations) {
                    if (imp.getElementName().contains(Signature.toString(name))) {
                        imports.addImport(imp.getElementName());
                    }
                }
            }
        }
    }
    return addedImport;
}

From source file:com.google.gwt.eclipse.core.search.JsniJavaRefParamType.java

License:Open Source License

public static JsniJavaRefParamType parse(IPath source, int offset, String paramTypeString) {
    // Minimal class type signature is of form "LClassName;"
    if (paramTypeString.length() < 3 || !paramTypeString.endsWith(";")) {
        return null;
    }//ww  w.  j av a  2s  .  c  o  m

    // We only consider class types (no primitives)
    if (Signature.getTypeSignatureKind(paramTypeString) != Signature.CLASS_TYPE_SIGNATURE) {
        return null;
    }

    return new JsniJavaRefParamType(source, offset, paramTypeString);
}

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  ww w.j a  v  a  2  s .  c o  m*/
 * 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.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * @param owningType -- type relative to which typeSignature will be resolved
 * @param typeSignature -- non-array type signature
 * @return the resolved type signature if possible or typeSignature if not
 *//* w  ww .  ja  v a  2  s  . co m*/
private static String resolveSignatureRelative(final IType owningType, final String typeSignature,
        final boolean eraseTypeParameters) {
    // if already fully resolved, return the input
    if (typeSignature.charAt(0) == Signature.C_RESOLVED) {
        return typeSignature;
    }

    List<String> typeParameters = new ArrayList<String>();

    IType resolvedType = resolveTypeRelative(owningType, typeSignature);

    if (resolvedType != null) {
        if (!eraseTypeParameters) {
            // ensure that type parameters are resolved recursively
            for (String typeParam : Signature.getTypeArguments(typeSignature)) {
                typeParam = Signature.removeCapture(typeParam);
                // check and remove bound wildcarding (extends/super/?)
                if (Signature.getTypeSignatureKind(typeParam) == Signature.WILDCARD_TYPE_SIGNATURE) {
                    // convert ? to Object, strip extends/super
                    if (typeParam.charAt(0) == Signature.C_STAR) {
                        typeParam = TypeConstants.TYPE_JAVAOBJECT;
                    } else {
                        typeParam = typeParam.substring(1);
                    }
                }
                final String resolvedParameter = resolveSignatureRelative(
                        // use the enclosing type, 
                        // *not* the resolved type because 
                        // we need to resolve in that context
                        owningType, typeParam, eraseTypeParameters);
                typeParameters.add(resolvedParameter);
            }
        }

        final String resolvedTypeSignature = Signature.createTypeSignature(resolvedType.getFullyQualifiedName(),
                true);

        if (typeParameters.size() > 0 && !eraseTypeParameters) {
            StringBuffer sb = new StringBuffer(resolvedTypeSignature);

            if (sb.charAt(sb.length() - 1) == ';') {
                sb = sb.delete(sb.length() - 1, sb.length());
            }

            sb.append("<"); //$NON-NLS-1$
            for (String param : typeParameters) {
                //System.out.println("type param: "+resolvedType.getTypeParameter(param));
                sb.append(param);
            }

            // replace the dangling ',' with the closing ">"
            sb.append(">;"); //$NON-NLS-1$
            return sb.toString();
        }

        return resolvedTypeSignature;
    }

    if (Signature.getTypeSignatureKind(typeSignature) == Signature.CLASS_TYPE_SIGNATURE
            || Signature.getTypeSignatureKind(typeSignature) == Signature.TYPE_VARIABLE_SIGNATURE) {
        // if we are unable to resolve, check to see if the owning type has
        // a parameter by this name
        ITypeParameter typeParam = owningType.getTypeParameter(Signature.getSignatureSimpleName(typeSignature));

        // if we have a type parameter and it hasn't been resolved to a type,
        // then assume it is a method template placeholder (i.e. T in ArrayList).
        // at runtime these unresolved parameter variables are effectively 
        // turned into Object's.  For example, think List.add(E o).  At runtime,
        // E will behave exactly like java.lang.Object in that signature
        if (typeParam.exists()) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }
    }

    return typeSignature;
}

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

License:Open Source License

/**
 * @param typeSig1 the type signature of the first enum. Must be non-null, fully resolved enum type.
 * @param typeSig2 the type signature of the second enum.  Must be non-null, fully resolved enum type.
 * /*from   w  ww  .  j  a v  a  2  s. co  m*/
 * @return true if typeSig1.compareTo(typeSig2) is a legal operation (won't throw a CCE)
 */
public static boolean isEnumsCompareCompatible(final String typeSig1, final String typeSig2) {
    if (typeSig1 == null || typeSig2 == null) {
        throw new IllegalArgumentException("args must not be null"); //$NON-NLS-1$
    }

    if (Signature.getTypeSignatureKind(typeSig1) != Signature.CLASS_TYPE_SIGNATURE
            || Signature.getTypeSignatureKind(typeSig2) != Signature.CLASS_TYPE_SIGNATURE) {
        throw new IllegalArgumentException("args must be resolved class types"); //$NON-NLS-1$
    }

    // if one or the other is the raw enum type, then they *may* be comparable; we don't know
    if (TypeConstants.TYPE_ENUM_BASE.equals(typeSig1) || TypeConstants.TYPE_ENUM_BASE.equals(typeSig2)) {
        return true;
    }

    // only comparable if is the same class
    return typeSig1.equals(typeSig2);
}