Example usage for org.eclipse.jdt.core ITypeParameter exists

List of usage examples for org.eclipse.jdt.core ITypeParameter exists

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. ITypeParameter
  6. exists

Introduction

In this page you can find the example usage for org.eclipse.jdt.core ITypeParameter exists.

Prototype

boolean exists();

Source Link

Document

Returns whether this Java element exists in the model.

Usage

From source file:at.bestsolution.fxide.jdt.text.viewersupport.JavaElementLabelComposer.java

License:Open Source License

private void appendTypeParameterWithBounds(ITypeParameter typeParameter, long flags) throws JavaModelException {
    fBuffer.append(getElementName(typeParameter));

    if (typeParameter.exists()) {
        String[] bounds = typeParameter.getBoundsSignatures();
        if (bounds.length > 0 && !(bounds.length == 1 && "Ljava.lang.Object;".equals(bounds[0]))) { //$NON-NLS-1$
            fBuffer.append(" extends "); //$NON-NLS-1$
            for (int j = 0; j < bounds.length; j++) {
                if (j > 0) {
                    fBuffer.append(" & "); //$NON-NLS-1$
                }/*from w ww  .ja va2  s.c om*/
                appendTypeSignatureLabel(typeParameter, bounds[j], flags);
            }
        }
    }
}

From source file:com.codenvy.ide.ext.java.server.SourcesFromBytecodeGenerator.java

License:Open Source License

private void appendTypeParameterWithBounds(ITypeParameter typeParameter, long flags, StringBuilder builder)
        throws JavaModelException {
    builder.append(getElementName(typeParameter));

    if (typeParameter.exists()) {
        String[] bounds = typeParameter.getBoundsSignatures();
        if (bounds.length > 0 && !(bounds.length == 1 && "Ljava.lang.Object;".equals(bounds[0]))) { //$NON-NLS-1$
            builder.append(" extends "); //$NON-NLS-1$
            for (int j = 0; j < bounds.length; j++) {
                if (j > 0) {
                    builder.append(" & "); //$NON-NLS-1$
                }/*from w  w w. j  a v  a  2s .c o  m*/
                appendTypeSignatureLabel(typeParameter, bounds[j], flags, builder);
            }
        }
    }
}

From source file:de.loskutov.bco.ui.JdtUtils.java

License:Open Source License

private static void appendGenericType(StringBuffer sb, IMethod iMethod, String unresolvedType)
        throws JavaModelException {
    IType declaringType = iMethod.getDeclaringType();

    // unresolvedType is here like "QA;" => we remove "Q" and ";"
    if (unresolvedType.length() < 3) {
        // ???? something wrong here ....
        sb.append(unresolvedType);/*from  w w w.ja va  2 s.c o m*/
        return;
    }
    unresolvedType = unresolvedType.substring(1, unresolvedType.length() - 1);

    ITypeParameter typeParameter = iMethod.getTypeParameter(unresolvedType);
    if (typeParameter == null || !typeParameter.exists()) {
        typeParameter = declaringType.getTypeParameter(unresolvedType);
    }

    String[] bounds = typeParameter.getBounds();
    if (bounds.length == 0) {
        sb.append("Ljava/lang/Object;");
    } else {
        for (int i = 0; i < bounds.length; i++) {
            String simplyName = bounds[i];
            simplyName = Signature.C_UNRESOLVED + simplyName + Signature.C_NAME_END;
            String resolvedType = getResolvedType(simplyName, declaringType);
            sb.append(resolvedType);
        }
    }
}

From source file:org.eclim.plugin.jdt.util.TypeUtils.java

License:Open Source License

/**
 * Converts the supplied type signature with generic information to the most
 * basic type that it supports./*from www .j a  v a  2s  .  c  o  m*/
 *
 * @param type The parent IType.
 * @param typeSignature The type signature.
 * @return The base type.
 */
public static String getBaseTypeFromGeneric(IType type, String typeSignature) throws Exception {
    int arrayCount = Signature.getArrayCount(typeSignature);
    if (arrayCount > 0) {
        for (int ii = 0; ii < arrayCount; ii++) {
            typeSignature = Signature.getElementType(typeSignature);
        }
    }

    String result = null;
    ITypeParameter param = type.getTypeParameter(Signature.getSignatureSimpleName(typeSignature));
    if (param.exists()) {
        result = param.getBounds()[0];
    } else {
        result = Signature.getSignatureSimpleName(Signature.getTypeErasure(typeSignature));
    }

    if (arrayCount > 0) {
        for (int ii = 0; ii < arrayCount; ii++) {
            result = result + "[]";
        }
    }
    return result;
}

From source file:org.eclipse.e4.demo.simpleide.jdt.internal.editor.viewer.JavaElementLabelComposer.java

License:Open Source License

/**
 * Appends the styled label for a type parameter.
 * /*from   ww  w  .j a  va2  s  .c  o m*/
 * @param typeParameter
 *            the element to render
 * @param flags
 *            the rendering flags. Flags with names starting with 'T_' are
 *            considered.
 */
public void appendTypeParameterLabel(ITypeParameter typeParameter, long flags) {
    try {
        fBuffer.append(getElementName(typeParameter));

        if (typeParameter.exists()) {
            String[] bounds = typeParameter.getBoundsSignatures();
            if (bounds.length > 0 && !(bounds.length == 1 && "Ljava.lang.Object;".equals(bounds[0]))) { //$NON-NLS-1$
                fBuffer.append(" extends "); //$NON-NLS-1$
                for (int j = 0; j < bounds.length; j++) {
                    if (j > 0) {
                        fBuffer.append(JavaElementLabels.COMMA_STRING);
                    }
                    appendTypeSignatureLabel(typeParameter, bounds[j], flags);
                }
            }
        }

        // post qualification
        if (getFlag(flags, JavaElementLabels.TP_POST_QUALIFIED)) {
            fBuffer.append(JavaElementLabels.CONCAT_STRING);
            IMember declaringMember = typeParameter.getDeclaringMember();
            appendElementLabel(declaringMember,
                    JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.M_FULLY_QUALIFIED
                            | JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS));
        }

    } catch (JavaModelException e) {
        logger.error(e);
    }
}

From source file:org.eclipse.modisco.java.discoverer.internal.io.library.ClassFileParser.java

License:Open Source License

/**
 * Finds the type variable associated with the currently visited Java
 * element (type or method) or with it's parent.
 * //from   w w  w .  java 2s . c o  m
 * @param name
 *            the name of the type variable
 * @return the {@code ITypeParameter}
 */
public ITypeParameter findTypeParameter(final String name) {
    IMember member = this.currentlyVisitedJavaElement;
    ITypeParameter typeParameter = null;
    while (member != null) {
        if (member.getElementType() == IJavaElement.METHOD) {
            typeParameter = ((IMethod) member).getTypeParameter(name);
        } else {
            typeParameter = ((IType) member).getTypeParameter(name);
        }
        if (typeParameter.exists()) {
            break;
        }
        member = member.getDeclaringType();
    }
    return typeParameter;
}

From source file:org.eclipse.objectteams.otdt.debug.ui.internal.actions.OTToggleBreakpointAdapter.java

License:Open Source License

/**
 * Returns the resolved type signature for the given signature in the given
 * method, or <code>null</code> if unable to resolve.
 * // w  w  w . ja va  2  s .c  om
 * @param method method containing the type signature
 * @param typeSignature the type signature to resolve
 * @return the resolved type signature
 * @throws JavaModelException
 */
private static String resolveTypeSignature(IMethod method, String typeSignature) throws JavaModelException {
    int count = Signature.getArrayCount(typeSignature);
    String elementTypeSignature = Signature.getElementType(typeSignature);
    if (elementTypeSignature.length() == 1) {
        // no need to resolve primitive types
        return typeSignature;
    }
    String elementTypeName = Signature.toString(elementTypeSignature);
    IType type = method.getDeclaringType();
    String[][] resolvedElementTypeNames = type.resolveType(elementTypeName);
    if (resolvedElementTypeNames == null || resolvedElementTypeNames.length != 1) {
        // check if type parameter
        ITypeParameter typeParameter = method.getTypeParameter(elementTypeName);
        if (!typeParameter.exists()) {
            typeParameter = type.getTypeParameter(elementTypeName);
        }
        if (typeParameter.exists()) {
            String[] bounds = typeParameter.getBounds();
            if (bounds.length == 0) {
                return "Ljava/lang/Object;"; //$NON-NLS-1$
            }
            String bound = Signature.createTypeSignature(bounds[0], false);
            return Signature.createArraySignature(resolveTypeSignature(method, bound), count);
        }
        // the type name cannot be resolved
        return null;
    }

    String[] types = resolvedElementTypeNames[0];
    types[1] = types[1].replace('.', '$');

    String resolvedElementTypeName = Signature.toQualifiedName(types);
    String resolvedElementTypeSignature = EMPTY_STRING;
    if (types[0].equals(EMPTY_STRING)) {
        resolvedElementTypeName = resolvedElementTypeName.substring(1);
        resolvedElementTypeSignature = Signature.createTypeSignature(resolvedElementTypeName, true);
    } else {
        resolvedElementTypeSignature = Signature.createTypeSignature(resolvedElementTypeName, true).replace('.',
                '/');
    }

    return Signature.createArraySignature(resolvedElementTypeSignature, count);
}

From source file:org.eclipse.recommenders.jdt.JavaElementsFinder.java

License:Open Source License

/**
 *
 * @param typeSignature/*from  www.j  a  v  a2  s.  c om*/
 *            e.g., QList;
 * @param enclosing
 * @return
 */
public static Optional<ITypeName> resolveType(char[] typeSignature, @Nullable IJavaElement enclosing) {
    typeSignature = CharOperation.replaceOnCopy(typeSignature, '.', '/');
    VmTypeName res = null;
    try {
        int dimensions = Signature.getArrayCount(typeSignature);
        outer: switch (typeSignature[dimensions]) {

        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:
            // take the whole string including any arrays
            res = VmTypeName.get(new String(typeSignature, 0, typeSignature.length));
            break;
        case Signature.C_RESOLVED:
            // take the whole string including any arrays but remove the trailing ';'
            res = VmTypeName.get(new String(typeSignature, 0, typeSignature.length - 1 /* ';' */));
            break;
        case Signature.C_UNRESOLVED:
            if (enclosing == null) {
                break;
            }
            // take the whole string (e.g. QList; or [QList;)
            String unresolved = new String(typeSignature, dimensions + 1,
                    typeSignature.length - (dimensions + 2 /* 'Q' + ';' */));
            IType ancestor = (IType) enclosing.getAncestor(IJavaElement.TYPE);
            if (ancestor == null) {
                break;
            }
            final String[][] resolvedNames = ancestor.resolveType(unresolved);
            if (isEmpty(resolvedNames)) {
                break;
            }
            String array = repeat('[', dimensions);
            final String pkg = resolvedNames[0][0].replace('.', '/');
            final String name = resolvedNames[0][1].replace('.', '$');
            res = VmTypeName.get(array + 'L' + pkg + '/' + name);
            break;
        case Signature.C_TYPE_VARIABLE:
            String varName = new String(typeSignature, dimensions + 1,
                    typeSignature.length - (dimensions + 2 /* 'Q' + ';' */));
            array = repeat('[', dimensions);

            for (IJavaElement cur = enclosing; cur instanceof IType
                    || cur instanceof IMethod; cur = cur.getParent()) {
                switch (cur.getElementType()) {
                case TYPE: {
                    IType type = (IType) cur;
                    ITypeParameter param = type.getTypeParameter(varName);
                    if (param.exists()) {
                        String[] signatures = getBoundSignatures(param);
                        if (isEmpty(signatures)) {
                            res = VmTypeName.OBJECT;
                            break outer;
                        }
                        // XXX we only consider the first type.
                        char[] append = array.concat(signatures[0]).toCharArray();
                        return resolveType(append, type);
                    }
                }
                case METHOD: {
                    IMethod method = (IMethod) cur;
                    ITypeParameter param = method.getTypeParameter(varName);
                    if (param.exists()) {
                        String[] signatures = getBoundSignatures(param);
                        if (isEmpty(signatures)) {
                            res = dimensions == 0 ? OBJECT
                                    : VmTypeName.get(repeat('[', dimensions) + OBJECT.getIdentifier());
                            break outer;
                        }
                        // XXX we only consider the first type.
                        char[] append = array.concat(signatures[0]).toCharArray();
                        return resolveType(append, method);
                    }
                }
                }
            }

            break;
        default:
            break;
        }
    } catch (Exception e) {
        Logs.log(LogMessages.ERROR_FAILED_TO_CREATE_TYPENAME, e,
                charToString(typeSignature) + (enclosing != null ? " in " + enclosing.getElementName() : ""));
    }
    return Optional.<ITypeName>fromNullable(res);
}

From source file:org.eclipse.wb.internal.core.utils.jdt.core.CodeUtils.java

License:Open Source License

/**
 * If given name is name of generic {@link TypeVariable}, returns its bounds.
 *//*from  ww w .  j a va2 s  .  c o m*/
private static String getResolvedTypeName_resolveTypeVariable(IType context, String name)
        throws JavaModelException {
    ITypeParameter typeParameter = context.getTypeParameter(name);
    if (typeParameter.exists()) {
        String[] bounds = typeParameter.getBounds();
        if (bounds.length != 0) {
            name = bounds[0];
        } else {
            name = "java.lang.Object";
        }
    }
    return name;
}

From source file:spechelper.MethodSelector.java

License:Apache License

private String generateAnnotation(boolean shortOnly, IMethod method) {
    String[] ptypes = method.getParameterTypes();
    String param = "";
    for (int i = 0; i < ptypes.length; i++) {
        String ptype = ptypes[i];
        String sig = Signature.toString(ptype);
        // kind of a hack: convert all Generic Type args to Object, or to
        // its bound Type
        if (sig.length() == 1) {
            ITypeParameter tps = method.getTypeParameter(sig);
            sig = "Object";

            if (tps != null && tps.exists()) {
                try {
                    String[] bounds = tps.getBounds();
                    if (bounds.length > 0) {
                        sig = bounds[0];
                    }/*  w w  w. j a va 2  s .c  om*/
                } catch (JavaModelException e) {
                    e.printStackTrace();
                }

            }
        }
        // omit type signature
        sig = sig.replaceAll("<.*>", "");
        param += (i > 0 ? ", " : "") + sig + ".class";
    }
    String IND = "    ";

    String targ = "@TestTarget(\n" + IND + "      methodName = \"" + method.getElementName() + "\",\n" + IND
            + "      methodArgs = {" + param + "}\n" + IND + "    )\n";

    String s;
    if (shortOnly) {
        s = targ;
    } else {

        s = "@TestInfo(\n" + IND + "  status = TestStatus.TBR,\n" + IND + "  notes = \"\",\n" + IND
                + "  targets = {\n" + IND + "    " + targ + IND + "})";
    }
    return s;
}