Example usage for org.eclipse.jdt.core IJavaElement getPath

List of usage examples for org.eclipse.jdt.core IJavaElement getPath

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaElement
  6. getPath

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaElement getPath.

Prototype

IPath getPath();

Source Link

Document

Returns the path to the innermost resource enclosing this element.

Usage

From source file:org.eclipse.che.jdt.internal.core.search.BasicSearchEngine.java

License:Open Source License

public void searchDeclarations(IJavaElement enclosingElement, SearchRequestor requestor, SearchPattern pattern,
        IProgressMonitor monitor) throws JavaModelException {
    if (VERBOSE) {
        Util.verbose("   - java element: " + enclosingElement); //$NON-NLS-1$
    }/* w w  w  .j av a  2  s .c  o m*/
    IJavaSearchScope scope = createJavaSearchScope(new IJavaElement[] { enclosingElement });
    IResource resource = ((JavaElement) enclosingElement).resource();
    if (enclosingElement instanceof IMember) {
        IMember member = (IMember) enclosingElement;
        ICompilationUnit cu = member.getCompilationUnit();
        if (cu != null) {
            resource = cu.getResource();
        } else if (member.isBinary()) {
            // binary member resource cannot be used as this
            // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=148215
            resource = null;
        }
    }
    try {
        if (resource instanceof IFile) {
            try {
                requestor.beginReporting();
                if (VERBOSE) {
                    Util.verbose("Searching for " + pattern + " in " + resource.getFullPath()); //$NON-NLS-1$//$NON-NLS-2$
                }
                SearchParticipant participant = getDefaultSearchParticipant(indexManager, javaProject);
                SearchDocument[] documents = MatchLocator.addWorkingCopies(pattern,
                        new SearchDocument[] {
                                new JavaSearchDocument(enclosingElement.getPath().toString(), participant) },
                        getWorkingCopies(enclosingElement), participant);
                participant.locateMatches(documents, pattern, scope, requestor, monitor);
            } finally {
                requestor.endReporting();
            }
        } else {
            search(pattern, new SearchParticipant[] { getDefaultSearchParticipant(indexManager, javaProject) },
                    scope, requestor, monitor);
        }
    } catch (CoreException e) {
        if (e instanceof JavaModelException)
            throw (JavaModelException) e;
        throw new JavaModelException(e);
    }
}

From source file:org.eclipse.che.jdt.internal.core.search.IndexSelector.java

License:Open Source License

private static int canSeeFocus(IJavaElement focus, JavaProject javaProject, char[][][] focusQualifiedNames) {
    try {/*  w  w w . j ava2  s  . co m*/
        if (focus == null)
            return PROJECT_CAN_NOT_SEE_FOCUS;
        if (focus.equals(javaProject))
            return PROJECT_CAN_SEE_FOCUS;

        if (focus instanceof JarPackageFragmentRoot) {
            // focus is part of a jar
            IPath focusPath = focus.getPath();
            IClasspathEntry[] entries = javaProject.getExpandedClasspath();
            for (int i = 0, length = entries.length; i < length; i++) {
                IClasspathEntry entry = entries[i];
                if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY && entry.getPath().equals(focusPath))
                    return PROJECT_CAN_SEE_FOCUS;
            }
            return PROJECT_CAN_NOT_SEE_FOCUS;
        }
        // look for dependent projects
        IPath focusPath = ((JavaProject) focus).getProject().getFullPath();
        IClasspathEntry[] entries = javaProject.getExpandedClasspath();
        for (int i = 0, length = entries.length; i < length; i++) {
            IClasspathEntry entry = entries[i];
            if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT && entry.getPath().equals(focusPath)) {
                if (focusQualifiedNames != null) { // builder state is usable, hence use it to try to reduce project which can see the focus...
                    State projectState = (State) JavaModelManager.getJavaModelManager()
                            .getLastBuiltState(javaProject.getProject(), null);
                    if (projectState != null) {
                        Object[] values = projectState.getReferences().valueTable;
                        int vLength = values.length;
                        for (int j = 0; j < vLength; j++) {
                            if (values[j] == null)
                                continue;
                            ReferenceCollection references = (ReferenceCollection) values[j];
                            if (references.includes(focusQualifiedNames, null, null)) {
                                return PROJECT_CAN_SEE_FOCUS;
                            }
                        }
                        return PROJECT_SOURCE_CAN_NOT_SEE_FOCUS;
                    }
                }
                return PROJECT_CAN_SEE_FOCUS;
            }
        }
        return PROJECT_CAN_NOT_SEE_FOCUS;
    } catch (JavaModelException e) {
        return PROJECT_CAN_NOT_SEE_FOCUS;
    }
}

From source file:org.eclipse.che.jdt.internal.core.search.JavaSearchScope.java

License:Open Source License

private IPath getPath(IJavaElement element, boolean relativeToRoot) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        return Path.EMPTY;
    case IJavaElement.JAVA_PROJECT:
        return element.getPath();
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        if (relativeToRoot)
            return Path.EMPTY;
        return element.getPath();
    case IJavaElement.PACKAGE_FRAGMENT:
        String relativePath = org.eclipse.jdt.internal.core.util.Util
                .concatWith(((PackageFragment) element).names, '/');
        return getPath(element.getParent(), relativeToRoot).append(new Path(relativePath));
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        return getPath(element.getParent(), relativeToRoot).append(new Path(element.getElementName()));
    default:/*from   w ww  . ja v  a 2s.co  m*/
        return getPath(element.getParent(), relativeToRoot);
    }
}

From source file:org.eclipse.jdt.internal.core.JavaProject.java

License:Open Source License

public boolean isOnClasspath(IJavaElement element) {
    IClasspathEntry[] rawClasspath;//  w  ww.j  a v  a  2s. co m
    try {
        rawClasspath = getRawClasspath();
    } catch (JavaModelException e) {
        return false; // not a Java project
    }
    int elementType = element.getElementType();
    boolean isPackageFragmentRoot = false;
    boolean isFolderPath = false;
    boolean isSource = false;
    switch (elementType) {
    case IJavaElement.JAVA_MODEL:
        return false;
    case IJavaElement.JAVA_PROJECT:
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        isPackageFragmentRoot = true;
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        isFolderPath = !((IPackageFragmentRoot) element.getParent()).isArchive();
        break;
    case IJavaElement.COMPILATION_UNIT:
        isSource = true;
        break;
    default:
        isSource = element.getAncestor(IJavaElement.COMPILATION_UNIT) != null;
        break;
    }
    IPath elementPath = element.getPath();

    // first look at unresolved entries
    int length = rawClasspath.length;
    for (int i = 0; i < length; i++) {
        IClasspathEntry entry = rawClasspath[i];
        switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_LIBRARY:
        case IClasspathEntry.CPE_PROJECT:
        case IClasspathEntry.CPE_SOURCE:
            if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, entry))
                return true;
            break;
        }
    }

    // no need to go further for compilation units and elements inside a compilation unit
    // it can only be in a source folder, thus on the raw classpath
    if (isSource)
        return false;

    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081
    // All the resolved classpath entries need to be considered, including the referenced classpath entries
    IClasspathEntry[] resolvedClasspath = null;
    try {
        resolvedClasspath = getResolvedClasspath();
    } catch (JavaModelException e) {
        return false; // Perhaps, not a Java project
    }

    for (int index = 0; index < resolvedClasspath.length; index++) {
        if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedClasspath[index]))
            return true;
    }

    return false;
}

From source file:org.eclipse.jst.j2ee.refactor.listeners.J2EEElementChangedListener.java

License:Open Source License

private void getJavaSrcMappings(final IJavaElementDelta[] children, final boolean cpChanged,
        final IJavaProject jproject, final List pathsToAdd, final List pathsToRemove, final List changedPaths)
        throws CoreException {

    IVirtualComponent c = ComponentCore.createComponent(jproject.getProject());
    if (c == null)
        return;//www .j  a  va2 s .c  o m
    // get the default destination folder
    final IVirtualFolder defaultDestFolder = getDestinationFolder(c);

    for (int i = 0; i < children.length; i++) {
        final IJavaElementDelta delta = children[i];
        final IJavaElement element = delta.getElement();
        if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
            final IPackageFragmentRoot root = (IPackageFragmentRoot) element;
            int cpeKind = IPackageFragmentRoot.K_SOURCE;
            boolean abortAdd = false;
            try {
                cpeKind = root.getKind();
            } catch (JavaModelException jme) {
                // this is thrown if the folder corresponding to the CPE has been deleted
                // since it could represent another error, we need to abort adding. 
                abortAdd = true;
            }
            // only update if we know it is a src folder
            if (cpeKind == IPackageFragmentRoot.K_SOURCE) {
                final int kind = delta.getKind();
                if (!cpChanged) {
                    // if the classpath is not changed, save modifications to the Java src path
                    if (kind == IJavaElementDelta.CHANGED || kind == IJavaElementDelta.REMOVED) {
                        changedPaths.add(root.getPath().removeFirstSegments(1));
                    }
                } else {

                    // kind and flags for CP additions are somewhat sporadic; either:
                    // -kind is ADDED and flags are 0
                    //   or
                    // -kind is CHANGED and flags are F_ADDED_TO_CLASSPATH
                    final int flags = delta.getFlags();

                    if (kind == IJavaElementDelta.ADDED || (flags
                            & IJavaElementDelta.F_ADDED_TO_CLASSPATH) == IJavaElementDelta.F_ADDED_TO_CLASSPATH) {
                        if (!abortAdd) {
                            final IPath pathToAdd = root.getPath().removeFirstSegments(1);
                            pathsToAdd.add(new Object[] { pathToAdd, defaultDestFolder });
                            // if the added src path was moved from another location, remove any mapping for that
                            // location
                            if ((flags & IJavaElementDelta.F_MOVED_FROM) == IJavaElementDelta.F_MOVED_FROM) {
                                final IJavaElement movedFromElement = delta.getMovedFromElement();
                                final IPath pathToRemove = movedFromElement.getPath().removeFirstSegments(1);
                                pathsToRemove.add(new Object[] { pathToRemove, defaultDestFolder });
                            }
                        }
                        // getting a kind = REMOVED and flags = 0 for removal of the folder (w/o removing the CPE), probably
                        // should not be generated
                    } else if (kind == IJavaElementDelta.REMOVED || (flags
                            & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) == IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) {
                        IPath path = root.getPath().removeFirstSegments(1);
                        pathsToRemove.add(new Object[] { path, defaultDestFolder });
                    }
                }
            }
        }
    }
}

From source file:org.eclipse.jst.jsf.common.ui.internal.dialogfield.JavaSearchScope.java

License:Open Source License

public boolean encloses(IJavaElement element) {
    return encloses(element.getPath().toString());
}

From source file:org.eclipse.jst.jsf.common.ui.internal.utils.PathUtil.java

License:Open Source License

/**
 * @param javaProject/*from  w ww. j a  v  a2 s. c o m*/
 * @param parent
 * @return the IPath for a a classpath object (?)
 */
public static IPath getPathOnClasspath(IJavaProject javaProject, Object parent) {
    IPath result = null;
    if (javaProject == null || parent == null) {
        return new Path(""); //$NON-NLS-1$
    }
    IClasspathEntry[] entries = javaProject.readRawClasspath();
    IPath classPath = null;
    if (parent instanceof IResource) {
        if (((javaProject != null) && !javaProject.isOnClasspath((IResource) parent))) {
            return new Path(""); //$NON-NLS-1$
        }
        if (parent instanceof IFile) {
            IPath elementPath = ((IFile) parent).getFullPath();
            if (((IFile) parent).getFileExtension().equalsIgnoreCase(IFileFolderConstants.EXT_PROPERTIES)) {
                int machings = 0;
                try {
                    for (int i = 0; i < entries.length; i++) {
                        // Determine whether on this classentry's path
                        int n = entries[i].getPath().matchingFirstSegments(elementPath);
                        if (n > machings) {
                            // Get package name
                            machings = n;
                            classPath = elementPath.removeFirstSegments(machings).removeLastSegments(1);
                        }
                    }

                    // Not on the classpath?
                    if (classPath == null) {
                        return null;
                    } else if (classPath.segmentCount() > 0) {
                        IJavaElement element = javaProject.findElement(classPath);
                        if (element != null) {
                            IPath path = element.getPath();
                            if (path != null) {
                                IPath path1 = path.removeFirstSegments(machings);

                                String fileName = ((IFile) parent).getName();
                                if (fileName != null) {
                                    result = path1.append(fileName);
                                }
                            }
                        }

                    } else {
                        result = ((IFile) parent).getFullPath().removeFirstSegments(machings);
                    }
                } catch (Exception e) {
                    return null;
                }
            }
        }
    } else if (parent instanceof IJarEntryResource) {
        IPath elementPath = ((IJarEntryResource) parent).getFullPath();
        if (elementPath.getFileExtension().equalsIgnoreCase(IFileFolderConstants.EXT_PROPERTIES)) {
            result = elementPath;
        }
    }
    if (result != null) {
        return result;
    }
    return new Path(""); //$NON-NLS-1$
}

From source file:org.eclipse.jst.jsp.core.taglib.ProjectDescription.java

License:Open Source License

void handleElementChanged(IJavaElementDelta delta) {
    if (fBuildPathIsDirty) {
        return;//from  w  ww.j  a va  2 s.c  om
    }

    // Logger.log(Logger.INFO_DEBUG, "IJavaElementDelta: " + delta);
    IJavaElement element = delta.getElement();
    if (element.getElementType() == IJavaElement.JAVA_PROJECT) {
        IJavaElementDelta[] affectedChildren = delta.getAffectedChildren();
        for (int i = 0; i < affectedChildren.length; i++) {
            handleElementChanged(affectedChildren[i]);
        }
    }
    if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
            && ((IPackageFragmentRoot) element).isArchive()) {
        time0 = System.currentTimeMillis();
        if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
                && ((IPackageFragmentRoot) element).isExternal()) {
        }
        String libLocation = null;
        int taglibRecordEventKind = -1;
        if ((delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) > 0
                || (delta.getFlags() & IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED) > 0
                || (delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) > 0) {
            taglibRecordEventKind = ITaglibIndexDelta.CHANGED;
            if ((delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) > 0) {
                taglibRecordEventKind = ITaglibIndexDelta.ADDED;
            } else if ((delta.getFlags() & IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED) > 0) {
                taglibRecordEventKind = ITaglibIndexDelta.CHANGED;
            } else if ((delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) > 0) {
                taglibRecordEventKind = ITaglibIndexDelta.REMOVED;
            }
            IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(element.getPath());
            if (file.isAccessible() && file.getLocation() != null)
                libLocation = file.getLocation().toString();
            else
                libLocation = element.getPath().toString();
        }
        if (libLocation != null) {
            boolean fragmentisExported = true;
            try {
                IClasspathEntry rawClasspathEntry = ((IPackageFragmentRoot) element).getRawClasspathEntry();
                /*
                 * null may also be returned for deletions depending on
                 * resource/build path notification order. If it's null,
                 * it's been deleted and whether it's exported won't
                 * really matter
                 */
                if (rawClasspathEntry != null) {
                    fragmentisExported = rawClasspathEntry.isExported();
                }
            } catch (JavaModelException e) {
                // IPackageFragmentRoot not part of the build path
            }
            if ((delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) > 0) {
                fBuildPathEntryCount++;
            } else if ((delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) > 0) {
                fBuildPathEntryCount--;
            }
            updateClasspathLibrary(libLocation, taglibRecordEventKind, fragmentisExported);
        }
        if (_debugIndexTime)
            Logger.log(Logger.INFO, "processed build path delta for " + fProject.getName() + "(" //$NON-NLS-1$//$NON-NLS-2$
                    + element.getPath() + ") in " + (System.currentTimeMillis() - time0) + "ms"); //$NON-NLS-1$
    }
}

From source file:org.eclipse.jst.jsp.core.taglib.ProjectDescription.java

License:Open Source License

void queueElementChanged(IJavaElementDelta delta) {
    try {/*from   w  w w  . j  a  v a  2 s.  c  o  m*/
        LOCK.acquire();
        IJavaElement element = delta.getElement();
        if (element.getElementType() == IJavaElement.JAVA_PROJECT) {
            IJavaElementDelta[] affectedChildren = delta.getAffectedChildren();
            for (int i = 0; i < affectedChildren.length; i++) {
                queueElementChanged(affectedChildren[i]);
            }
        }
        if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
                && ((IPackageFragmentRoot) element).isArchive()) {
            IPath path = element.getPath();
            boolean fragmentisExported = true;
            try {
                IClasspathEntry rawClasspathEntry = ((IPackageFragmentRoot) element).getRawClasspathEntry();
                /*
                 * null may also be returned for deletions depending on
                 * resource/build path notification order. If it's null,
                 * it's been deleted and whether it's exported won't
                 * really matter
                 */
                if (rawClasspathEntry != null) {
                    fragmentisExported = rawClasspathEntry.isExported();
                }
            } catch (JavaModelException e) {
                // IPackageFragmentRoot not part of the build path
            }
            String key = path.toString();
            if ((delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) > 0) {
                fPackageFragmentRootsAdded.put(key,
                        new PackageFragmentRootDelta(path, ITaglibIndexDelta.ADDED, fragmentisExported));
                fPackageFragmentRootsChanged.remove(key);
                fPackageFragmentRootsRemoved.remove(key);
                fBuildPathEntryCount++;
            } else if ((delta.getFlags() & IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED) > 0) {
                fPackageFragmentRootsChanged.put(key,
                        new PackageFragmentRootDelta(path, ITaglibIndexDelta.CHANGED, fragmentisExported));
            } else if (((delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) > 0)
                    && ((delta.getFlags() & IJavaElementDelta.F_REORDER) == 0)) {
                fPackageFragmentRootsAdded.remove(key);
                fPackageFragmentRootsChanged.remove(key);
                fPackageFragmentRootsRemoved.put(key,
                        new PackageFragmentRootDelta(path, ITaglibIndexDelta.REMOVED, fragmentisExported));
                fBuildPathEntryCount--;
            }
        }
    } finally {
        LOCK.release();
    }

    fBuildPathJob.cancel();
    fBuildPathJob.schedule(2000);
}

From source file:org.eclipse.modisco.java.discoverer.internal.serialization.ElementsToAnalyzeSerializer.java

License:Open Source License

public String serialize(final ElementsToAnalyze elementsToAnalyze) {
    try {/*from  w  w w. java  2 s. c o  m*/
        StringBuilder builder = new StringBuilder();
        IJavaProject javaProject = elementsToAnalyze.getJavaProject();
        if (javaProject == null) {
            return ""; //$NON-NLS-1$
        }

        builder.append(escape(javaProject.getElementName()));
        builder.append(ElementsToAnalyzeSerializer.SEPARATOR1);

        Set<Object> elementsToDiscover = elementsToAnalyze.getElementsToDiscover();
        boolean first = true;
        for (Object object : elementsToDiscover) {
            if (!first) {
                builder.append(ElementsToAnalyzeSerializer.SEPARATOR1);
            }
            first = false;

            if (object instanceof IJavaProject) {
                IJavaProject javaProject2 = (IJavaProject) object;
                builder.append(ElementsToAnalyzeSerializer.PROJECT_PREFIX);
                builder.append(escape(javaProject2.getElementName()));
            } else if (object instanceof IJavaElement) {
                IJavaElement javaElement = (IJavaElement) object;
                builder.append(ElementsToAnalyzeSerializer.ELEMENT_PREFIX);
                builder.append(escape(javaElement.getJavaProject().getElementName()));
                builder.append(ElementsToAnalyzeSerializer.SEPARATOR3);
                builder.append(escape(javaElement.getElementName()));
                builder.append(ElementsToAnalyzeSerializer.SEPARATOR3);
                builder.append(escape(javaElement.getPath().toString()));
            } else {
                MoDiscoLogger.logError("Unexpected element: " + object.getClass().getName(), //$NON-NLS-1$
                        JavaActivator.getDefault());
                continue;
            }

            Map<String, Object> discoveryOptions = elementsToAnalyze.getDiscoveryOptions(object);
            for (Entry<String, Object> entry : discoveryOptions.entrySet()) {

                builder.append(ElementsToAnalyzeSerializer.SEPARATOR2);
                builder.append(escape(entry.getKey()));
                builder.append(ElementsToAnalyzeSerializer.SEPARATOR2);
                ISerializer<?> serializer2 = ISerializationRegistry.INSTANCE
                        .getSerializerFor(entry.getValue().getClass());
                if (serializer2 != null) {
                    String serialized2 = ISerializationService.INSTANCE.serialize(entry.getValue());
                    if (serialized2 != null) {
                        builder.append(escape(serialized2));
                    }
                } else {
                    MoDiscoLogger.logError("No serializer for: " + entry.getValue().getClass().getName(), //$NON-NLS-1$
                            JavaActivator.getDefault());
                }
            }
        }

        return builder.toString();
    } catch (Exception e) {
        MoDiscoLogger.logError(e, "Error serializing elements to analyze", //$NON-NLS-1$
                JavaActivator.getDefault());
        return ""; //$NON-NLS-1$
    }
}