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

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

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

Introduction

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

Prototype

public static String getSignatureQualifier(String typeSignature)

Source Link

Document

Returns package fragment of a type signature.

Usage

From source file:at.bestsolution.fxide.jdt.editor.internal.SignatureUtil.java

License:Open Source License

/**
 * Returns the qualified signature corresponding to
 * <code>signature</code>.//from   w w w. ja  v a  2  s .c o m
 *
 * @param signature the signature to qualify
 * @param context the type inside which an unqualified type will be
 *        resolved to find the qualifier, or <code>null</code> if no
 *        context is available
 * @return the qualified signature
 */
public static String qualifySignature(final String signature, final IType context) {
    if (context == null)
        return signature;

    String qualifier = Signature.getSignatureQualifier(signature);
    if (qualifier.length() > 0)
        return signature;

    String elementType = Signature.getElementType(signature);
    String erasure = Signature.getTypeErasure(elementType);
    String simpleName = Signature.getSignatureSimpleName(erasure);
    String genericSimpleName = Signature.getSignatureSimpleName(elementType);

    int dim = Signature.getArrayCount(signature);

    try {
        String[][] strings = context.resolveType(simpleName);
        if (strings != null && strings.length > 0)
            qualifier = strings[0][0];
    } catch (JavaModelException e) {
        // ignore - not found
    }

    if (qualifier.length() == 0)
        return signature;

    String qualifiedType = Signature.toQualifiedName(new String[] { qualifier, genericSimpleName });
    String qualifiedSignature = Signature.createTypeSignature(qualifiedType, true);
    String newSignature = Signature.createArraySignature(qualifiedSignature, dim);

    return newSignature;
}

From source file:com.aqua.wikiwizard.JavaModelUtils.java

License:Apache License

/**
 * Returns the method return type//from ww w  . j  av a  2 s  . c o m
 * @param method
 *          The given method
 * @return
 *          String
 * @throws JavaModelException
 */
public static String getMethodReturnTypeFullName(IMethod method) throws JavaModelException {
    String signature = method.getReturnType();
    String packageName = Signature.getSignatureQualifier(signature);
    return (packageName.trim().equals("") ? "" : packageName + ".")
            + Signature.getSignatureSimpleName(signature);
}

From source file:com.google.gdt.eclipse.core.java.JavaModelSearch.java

License:Open Source License

/**
 * Extract the fully-qualified type name out of a type signature, with dots as
 * package separators./* www. j av  a  2  s . c  o m*/
 */
public static String getQualifiedTypeName(String typeSignature) {
    // Make sure we're using dots for package separator, not /'s
    typeSignature = typeSignature.replace('/', '.');

    String pckg = Signature.getSignatureQualifier(typeSignature);
    String typeName = Signature.getSignatureSimpleName(typeSignature);

    if (pckg == null || pckg.length() == 0) {
        return typeName;
    }

    return pckg + "." + typeName;
}

From source file:com.google.gwt.eclipse.core.uibinder.contentassist.computers.SetterAttributeProposalComputer.java

License:Open Source License

/**
 * Determines whether a setter's parameter signature can be parsed from an
 * attribute based on the GWT AttributeParsers implementation.
 *///from   w  w w  . j  a va 2  s  .co  m
private boolean isParsableSetter(IMethod method) {
    StringBuffer signature = new StringBuffer();

    for (String paramType : method.getParameterTypes()) {
        if (signature.length() > 0) {
            signature.append(',');
        }

        String qualifier = Signature.getSignatureQualifier(paramType);
        if (qualifier.length() > 0) {
            signature.append(qualifier);
            signature.append('.');
        }

        signature.append(Signature.getSignatureSimpleName(paramType));
    }

    return PARSABLE_ARGS.contains(signature.toString());
}

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

License:Open Source License

/**
 * @param typeSignature     // w  ww.  ja va  2  s  . c om
 * @return a fully qualified Java class name from a type signature
 * i.e. Ljava.lang.String; -> java.lang.String
 */
public static String getFullyQualifiedName(final String typeSignature) {
    final String packageName = Signature.getSignatureQualifier(typeSignature);
    final String typeName = Signature.getSignatureSimpleName(typeSignature);
    return "".equals(packageName) ? typeName : packageName + "." + typeName; //$NON-NLS-1$//$NON-NLS-2$
}

From source file:com.halware.nakedide.eclipse.core.util.TypeUtils.java

License:Open Source License

/**
 * @param type/*from   w  ww  .  j  av  a2  s .  c  o  m*/
 * @return
 * @throws JavaModelException
 */
public static List<IType> findSuperTypeCandidates(IType type) throws JavaModelException {
    List<IType> candidates = new ArrayList<IType>();
    String superclassTypeSignature = type.getSuperclassTypeSignature();
    if (superclassTypeSignature != null) {
        String qualifier = Signature.getSignatureQualifier(superclassTypeSignature);
        String simpleName = Signature.getSignatureSimpleName(superclassTypeSignature);
        String superclassName = ((qualifier != null && qualifier.length() > 0) ? qualifier + "." : "")
                + simpleName;
        String[][] superclassCandidates = type.resolveType(superclassName);
        if (superclassCandidates != null) {
            for (int i = 0; i < superclassCandidates.length; i++) {
                String superclassCandidatePackageName = superclassCandidates[i][0];
                String superclassCandidateClassName = superclassCandidates[i][1];
                IType findType = type.getJavaProject().findType(superclassCandidatePackageName,
                        superclassCandidateClassName);
                if (findType != null) {
                    candidates.add(findType);
                }
            }
        }
    }
    return candidates;
}

From source file:com.siteview.mde.internal.ui.search.dependencies.CalculateUsesOperation.java

License:Open Source License

protected final void addPackage(String typeSignature, Set pkgs, IType type, boolean binary)
        throws JavaModelException {
    if (typeSignature == null)
        return;//from  ww w.  j a  v a2  s. c o m
    if (binary)
        typeSignature = typeSignature.replace('/', '.');
    // if typeSignature contains a '.', test to see if it is a subClass first.  If not, assume it is a fully qualified name
    if (typeSignature.indexOf('.') != -1) {
        try {
            String[][] temp = type.resolveType(new String(Signature.toCharArray(typeSignature.toCharArray())));
            if (temp != null) {
                pkgs.add(temp[0][0]);
                return;
            }
        } catch (IllegalArgumentException e) {
        }
        String pkg = Signature.getSignatureQualifier(typeSignature);
        if (pkg.length() > 0) {
            pkgs.add(pkg);
            return;
        }
        // if typeSignature does not contain a '.', then assume the package name is in an import statement and try to resolve through the type object
    } else {
        String typeName = Signature.getSignatureSimpleName(typeSignature);
        String[][] result = type.resolveType(typeName);
        if (result != null)
            pkgs.add(result[0][0]);
    }
}

From source file:edu.uci.ics.sourcerer.extractor.ast.ClassFileExtractor.java

License:Open Source License

private static String typeSignatureToFqn(String signature) {
    try {/*from w w w . j  a  v a2 s. co m*/
        switch (Signature.getTypeSignatureKind(signature)) {
        case Signature.ARRAY_TYPE_SIGNATURE:
            return typeSignatureToFqn(Signature.getElementType(signature))
                    + brackets.substring(0, 2 * Signature.getArrayCount(signature));
        case Signature.CLASS_TYPE_SIGNATURE:
            String args[] = Signature.getTypeArguments(signature);
            if (args.length == 0) {
                int firstDollar = signature.indexOf('$');
                if (firstDollar == -1) {
                    return Signature.getSignatureQualifier(signature) + "."
                            + Signature.getSignatureSimpleName(signature);
                } else {
                    String shortSig = signature.substring(0, firstDollar) + ";";
                    return Signature.getSignatureQualifier(shortSig) + "."
                            + Signature.getSignatureSimpleName(shortSig)
                            + signature.substring(firstDollar, signature.length() - 1);
                }
            } else {
                StringBuilder fqnBuilder = new StringBuilder(
                        typeSignatureToFqn(Signature.getTypeErasure(signature)));
                fqnBuilder.append('<');
                boolean first = true;
                for (String arg : args) {
                    if (first) {
                        first = false;
                    } else {
                        fqnBuilder.append(',');
                    }
                    fqnBuilder.append(typeSignatureToFqn(arg));
                }
                fqnBuilder.append('>');
                return fqnBuilder.toString();
            }
        case Signature.BASE_TYPE_SIGNATURE:
            return Signature.getSignatureSimpleName(signature);
        case Signature.TYPE_VARIABLE_SIGNATURE:
            return "<" + Signature.getSignatureSimpleName(signature) + ">";
        case Signature.WILDCARD_TYPE_SIGNATURE:
            if (signature.startsWith("+")) {
                return "<?+" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else if (signature.startsWith("-")) {
                return "<?-" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else {
                return "<?>";
            }
        case Signature.CAPTURE_TYPE_SIGNATURE:
            System.out.println("eek");
            return "";
        default:
            throw new IllegalArgumentException("Not a valid type signature");
        }
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("bad");
        return null;
    }
}

From source file:edu.uci.ics.sourcerer.tools.java.extractor.eclipse.ClassFileExtractor.java

License:Open Source License

private static String typeSignatureToFqn(String signature) {
    try {//  w  ww.  jav  a  2  s .  co m
        switch (Signature.getTypeSignatureKind(signature)) {
        case Signature.ARRAY_TYPE_SIGNATURE:
            return typeSignatureToFqn(Signature.getElementType(signature))
                    + brackets.substring(0, 2 * Signature.getArrayCount(signature));
        case Signature.CLASS_TYPE_SIGNATURE:
            if (signature.indexOf('<') == -1) {
                int firstDollar = signature.indexOf('$');
                if (firstDollar == -1) {
                    return Signature.getSignatureQualifier(signature) + "."
                            + Signature.getSignatureSimpleName(signature);
                } else {
                    String shortSig = signature.substring(0, firstDollar) + ";";
                    return Signature.getSignatureQualifier(shortSig) + "."
                            + Signature.getSignatureSimpleName(shortSig)
                            + signature.substring(firstDollar, signature.length() - 1);
                }
            } else {
                StringBuilder fqnBuilder = new StringBuilder();
                StringBuilder current = new StringBuilder();
                int depth = 0;
                boolean dollar = false;
                for (char c : signature.toCharArray()) {
                    switch (c) {
                    case '<':
                        if (fqnBuilder.length() == 0) {
                            current.append(';');
                            fqnBuilder.append(typeSignatureToFqn(current.toString()));
                            current.setLength(current.length() - 1);
                        }
                        current.append(c);
                        depth++;
                        break;
                    case '>':
                        current.append(c);
                        if (--depth == 0) {
                            dollar = true;
                            fqnBuilder.append('<');
                            boolean first = true;
                            current.append(";");
                            for (String arg : Signature.getTypeArguments(current.toString())) {
                                if (first) {
                                    first = false;
                                } else {
                                    fqnBuilder.append(',');
                                }
                                fqnBuilder.append(typeSignatureToFqn(arg));
                            }
                            current.setLength(current.length() - 1);
                            fqnBuilder.append('>');
                        }
                        break;
                    case '.':
                        if (dollar && depth == 0) {
                            fqnBuilder.append('$');
                        }
                        current.append(c);
                        break;
                    default:
                        if (dollar && depth == 0) {
                            fqnBuilder.append(c);
                        }
                        current.append(c);
                        break;
                    }
                }
                fqnBuilder.setLength(fqnBuilder.length() - 1);
                return fqnBuilder.toString();
            }
        case Signature.BASE_TYPE_SIGNATURE:
            return Signature.getSignatureSimpleName(signature);
        case Signature.TYPE_VARIABLE_SIGNATURE:
            return "<" + Signature.getSignatureSimpleName(signature) + ">";
        case Signature.WILDCARD_TYPE_SIGNATURE:
            if (signature.startsWith("+")) {
                return "<?+" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else if (signature.startsWith("-")) {
                return "<?-" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else {
                return "<?>";
            }
        case Signature.CAPTURE_TYPE_SIGNATURE:
            System.out.println("eek");
            return "";
        default:
            throw new IllegalArgumentException("Not a valid type signature");
        }
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("bad");
        return null;
    }
}

From source file:fr.atelechev.buildergen.generator.JavaType.java

License:Open Source License

/**
 * /*  w  ww .  ja va2s  .c  o m*/
 * @param qualifiedTypeName
 * @throws IllegalArgumentException if the arg is null or empty
 */
public JavaType(String qualifiedTypeName) {
    if (qualifiedTypeName == null || qualifiedTypeName.trim().isEmpty()) {
        throw new IllegalArgumentException("qualifiedTypeName must not be null");
    }
    this.name = Signature.getSignatureSimpleName(qualifiedTypeName);
    this.packageName = cleanPackageName(Signature.getSignatureQualifier(qualifiedTypeName));
}