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

Introduction

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

Prototype

int PACKAGE_FRAGMENT

To view the source code for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT.

Click Source Link

Document

Constant representing a package fragment.

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private void elementAdded(Openable element, IResourceDelta delta, RootInfo rootInfo) {
    int elementType = element.getElementType();

    if (elementType == IJavaElement.JAVA_PROJECT) {
        // project add is handled by JavaProject.configure() because
        // when a project is created, it does not yet have a Java nature
        IProject project;/*w w  w . ja  v  a 2  s. c  o m*/
        if (delta != null && JavaProject.hasJavaNature(project = (IProject) delta.getResource())) {
            addToParentInfo(element);
            this.manager.getPerProjectInfo(true /*create info if needed*/).rememberExternalLibTimestamps();
            if ((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
                Openable movedFromElement = (Openable) element.getJavaModel()
                        .getJavaProject(delta.getMovedFromPath().lastSegment());
                currentDelta().movedTo(element, movedFromElement);
            } else {
                // Force the project to be closed as it might have been opened
                // before the resource modification came in and it might have a new child
                // For example, in an IWorkspaceRunnable:
                // 1. create a Java project P (where P=src)
                // 2. open project P
                // 3. add folder f in P's pkg fragment root
                // When the resource delta comes in, only the addition of P is notified,
                // but the pkg fragment root of project P is already opened, thus its children are not recomputed
                // and it appears to contain only the default package.
                close(element);

                currentDelta().added(element);
            }
            this.state.updateRoots(element.getPath(), delta, this);

            // remember that the project's cache must be reset
            this.projectCachesToReset.add(element);
        }
    } else {
        if (delta == null || (delta.getFlags() & IResourceDelta.MOVED_FROM) == 0) {
            // regular element addition
            if (isPrimaryWorkingCopy(element, elementType)) {
                // filter out changes to primary compilation unit in working copy mode
                // just report a change to the resource (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59500)
                currentDelta().changed(element, IJavaElementDelta.F_PRIMARY_RESOURCE);
            } else {
                addToParentInfo(element);

                // Force the element to be closed as it might have been opened
                // before the resource modification came in and it might have a new child
                // For example, in an IWorkspaceRunnable:
                // 1. create a package fragment p using a java model operation
                // 2. open package p
                // 3. add file X.java in folder p
                // When the resource delta comes in, only the addition of p is notified,
                // but the package p is already opened, thus its children are not recomputed
                // and it appears empty.
                close(element);

                currentDelta().added(element);
            }
        } else {
            // element is moved
            addToParentInfo(element);
            close(element);

            IPath movedFromPath = delta.getMovedFromPath();
            File res = delta.getFile();
            File movedFromRes;
            if (res.isFile()) {
                movedFromRes = movedFromPath.toFile();
            } else {
                movedFromRes = movedFromPath.toFile();
            }

            // find the element type of the moved from element
            IPath rootPath = externalPath(movedFromRes);
            RootInfo movedFromInfo = enclosingRootInfo(rootPath, IResourceDelta.REMOVED);
            int movedFromType = elementType(movedFromRes, IResourceDelta.REMOVED,
                    element.getParent().getElementType(), movedFromInfo);

            // reset current element as it might be inside a nested root (popUntilPrefixOf() may use the outer root)
            this.currentElement = null;

            // create the moved from element
            Openable movedFromElement = elementType != IJavaElement.JAVA_PROJECT
                    && movedFromType == IJavaElement.JAVA_PROJECT ? null : // outside classpath
                            createElement(movedFromRes, movedFromType, movedFromInfo);
            if (movedFromElement == null) {
                // moved from outside classpath
                currentDelta().added(element);
            } else {
                currentDelta().movedTo(element, movedFromElement);
            }
        }

        switch (elementType) {
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            // when a root is added, and is on the classpath, the project must be updated
            JavaProject project = (JavaProject) element.getJavaProject();

            // remember that the project's cache must be reset
            this.projectCachesToReset.add(project);

            break;
        case IJavaElement.PACKAGE_FRAGMENT:
            // reset project's package fragment cache
            project = (JavaProject) element.getJavaProject();
            this.projectCachesToReset.add(project);

            break;
        }
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private void elementRemoved(Openable element, IResourceDelta delta, RootInfo rootInfo) {

    int elementType = element.getElementType();
    if (delta == null || (delta.getFlags() & IResourceDelta.MOVED_TO) == 0) {
        // regular element removal
        if (isPrimaryWorkingCopy(element, elementType)) {
            // filter out changes to primary compilation unit in working copy mode
            // just report a change to the resource (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59500)
            currentDelta().changed(element, IJavaElementDelta.F_PRIMARY_RESOURCE);
        } else {/*  w w  w.ja  va  2s .c om*/
            close(element);
            removeFromParentInfo(element);
            currentDelta().removed(element);
        }
    } else {
        // element is moved
        close(element);
        removeFromParentInfo(element);
        IPath movedToPath = delta.getMovedToPath();
        File res = delta.getFile();
        File movedToRes;
        movedToRes = movedToPath.toFile();
        //         switch (res.getType()) {
        //            case IResource.PROJECT:
        //               movedToRes = res.getWorkspace().getRoot().getProject(movedToPath.lastSegment());
        //               break;
        //            case IResource.FOLDER:
        //               movedToRes = res.getWorkspace().getRoot().getFolder(movedToPath);
        //               break;
        //            case IResource.FILE:
        //               movedToRes = res.getWorkspace().getRoot().getFile(movedToPath);
        //               break;
        //            default:
        //               return;
        //         }

        // find the element type of the moved from element
        IPath rootPath = externalPath(movedToRes);
        RootInfo movedToInfo = enclosingRootInfo(rootPath, IResourceDelta.ADDED);
        int movedToType = elementType(movedToRes, IResourceDelta.ADDED, element.getParent().getElementType(),
                movedToInfo);

        // reset current element as it might be inside a nested root (popUntilPrefixOf() may use the outer root)
        this.currentElement = null;

        // create the moved To element
        Openable movedToElement = elementType != IJavaElement.JAVA_PROJECT
                && movedToType == IJavaElement.JAVA_PROJECT ? null : // outside classpath
                        createElement(movedToRes, movedToType, movedToInfo);
        if (movedToElement == null) {
            // moved outside classpath
            currentDelta().removed(element);
        } else {
            currentDelta().movedFrom(element, movedToElement);
        }
    }

    switch (elementType) {
    case IJavaElement.JAVA_MODEL:
        this.manager.indexManager.reset();
        break;
    case IJavaElement.JAVA_PROJECT:
        this.state.updateRoots(element.getPath(), delta, this);

        // remember that the project's cache must be reset
        this.projectCachesToReset.add(element);

        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        JavaProject project = (JavaProject) element.getJavaProject();

        // remember that the project's cache must be reset
        this.projectCachesToReset.add(project);

        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        // reset package fragment cache
        project = (JavaProject) element.getJavaProject();
        this.projectCachesToReset.add(project);

        break;
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private int elementType(File res, int kind, int parentType, RootInfo rootInfo) {
    Path path = new Path(res.getAbsolutePath());
    switch (parentType) {
    case IJavaElement.JAVA_MODEL:
        // case of a movedTo or movedFrom project (other cases are handled in processResourceDelta(...)
        return IJavaElement.JAVA_PROJECT;

    case NON_JAVA_RESOURCE:
    case IJavaElement.JAVA_PROJECT:
        if (rootInfo == null) {
            rootInfo = enclosingRootInfo(path, kind);
        }/*from  www .  j  a v a  2s  . c  om*/
        if (rootInfo != null && rootInfo.isRootOfProject(path)) {
            return IJavaElement.PACKAGE_FRAGMENT_ROOT;
        }
        // not yet in a package fragment root or root of another project
        // or package fragment to be included (see below)
        // $FALL-THROUGH$

    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
    case IJavaElement.PACKAGE_FRAGMENT:
        if (rootInfo == null) {
            IPath rootPath = externalPath(res);
            rootInfo = enclosingRootInfo(rootPath, kind);
        }
        if (rootInfo == null) {
            return NON_JAVA_RESOURCE;
        }
        if (Util.isExcluded(path, rootInfo.inclusionPatterns, rootInfo.exclusionPatterns, false)) {
            return NON_JAVA_RESOURCE;
        }
        if (res.isDirectory()) {
            if (parentType == NON_JAVA_RESOURCE && !Util.isExcluded(new Path(res.getParent()),
                    rootInfo.inclusionPatterns, rootInfo.exclusionPatterns, false)) {
                // parent is a non-Java resource because it doesn't have a valid package name (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=130982)
                return NON_JAVA_RESOURCE;
            }
            String sourceLevel = rootInfo.project == null ? null
                    : rootInfo.project.getOption(JavaCore.COMPILER_SOURCE, true);
            String complianceLevel = rootInfo.project == null ? null
                    : rootInfo.project.getOption(JavaCore.COMPILER_COMPLIANCE, true);
            if (Util.isValidFolderNameForPackage(res.getName(), sourceLevel, complianceLevel)) {
                return IJavaElement.PACKAGE_FRAGMENT;
            }
            return NON_JAVA_RESOURCE;
        }
        String fileName = res.getName();
        String sourceLevel = rootInfo.project == null ? null
                : rootInfo.project.getOption(JavaCore.COMPILER_SOURCE, true);
        String complianceLevel = rootInfo.project == null ? null
                : rootInfo.project.getOption(JavaCore.COMPILER_COMPLIANCE, true);
        if (Util.isValidCompilationUnitName(fileName, sourceLevel, complianceLevel)) {
            return IJavaElement.COMPILATION_UNIT;
        } else if (Util.isValidClassFileName(fileName, sourceLevel, complianceLevel)) {
            return IJavaElement.CLASS_FILE;
        } else {
            IPath rootPath = externalPath(res);
            if ((rootInfo = rootInfo(rootPath, kind)) != null
                    && rootInfo.project.getProject().getFullPath().isPrefixOf(
                            rootPath) /*ensure root is a root of its project (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=185310) */) {
                // case of proj=src=bin and resource is a jar file on the classpath
                return IJavaElement.PACKAGE_FRAGMENT_ROOT;
            } else {
                return NON_JAVA_RESOURCE;
            }
        }

    default:
        return NON_JAVA_RESOURCE;
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

public boolean updateCurrentDeltaAndIndex(IResourceDelta delta, int elementType, RootInfo rootInfo) {
    Openable element;/*from  w w  w.  j a v  a  2  s .  com*/
    switch (delta.getKind()) {
    case IResourceDelta.ADDED:
        File deltaRes = delta.getFile();
        element = createElement(deltaRes, elementType, rootInfo);
        if (element == null) {
            // resource might be containing shared roots (see bug 19058)
            this.state.updateRoots(new Path(deltaRes.getAbsolutePath()), delta, this);
            return rootInfo != null && rootInfo.inclusionPatterns != null;
        }
        updateIndex(element, delta);
        elementAdded(element, delta, rootInfo);
        //            if (elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT)
        //               this.state.addClasspathValidation(rootInfo.project);
        return elementType == IJavaElement.PACKAGE_FRAGMENT;
    case IResourceDelta.REMOVED:
        deltaRes = delta.getFile();
        element = createElement(deltaRes, elementType, rootInfo);
        if (element == null) {
            // resource might be containing shared roots (see bug 19058)
            this.state.updateRoots(new Path(deltaRes.getAbsolutePath()), delta, this);
            return rootInfo != null && rootInfo.inclusionPatterns != null;
        }
        updateIndex(element, delta);
        elementRemoved(element, delta, rootInfo);
        if (elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT)
            //               this.state.addClasspathValidation(rootInfo.project);

            //            if (deltaRes.getType() == IResource.PROJECT){
            //               // reset the corresponding project built state, since cannot reuse if added back
            //               if (JavaBuilder.DEBUG)
            //                  System.out.println("Clearing last state for removed project : " + deltaRes); //$NON-NLS-1$
            //               this.manager.setLastBuiltState((IProject)deltaRes, null /*no state*/);
            //
            //               // clean up previous session containers (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=89850)
            //               this.manager.previousSessionContainers.remove(element);
            //            }
            return elementType == IJavaElement.PACKAGE_FRAGMENT;
    case IResourceDelta.CHANGED:
        int flags = delta.getFlags();
        if (elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT && (flags & IResourceDelta.LOCAL_CHANGED) != 0) {
            // external folder added or removed
            if (oldRootInfo(rootInfo.rootPath, rootInfo.project) == null) {
                // root just added to the classpath
                break;
            }
            deltaRes = delta.getFile();
            Object target = JavaModel.getExternalTarget(new Path(deltaRes.getAbsolutePath()),
                    true/*check resource existence*/);
            element = createElement(deltaRes, elementType, rootInfo);
            updateIndex(element, delta);
            if (target != null) {
                // external folder added
                elementAdded(element, delta, rootInfo);
            } else {
                // external folder removed
                elementRemoved(element, delta, rootInfo);
            }
            //               this.state.addClasspathValidation(rootInfo.project);
        } else if ((flags & IResourceDelta.CONTENT) != 0 || (flags & IResourceDelta.ENCODING) != 0) {
            // content or encoding has changed
            element = createElement(delta.getFile(), elementType, rootInfo);
            if (element == null)
                return false;
            updateIndex(element, delta);
            contentChanged(element);
        } else if (elementType == IJavaElement.JAVA_PROJECT) {
            //               if ((flags & IResourceDelta.OPEN) != 0) {
            //                  // project has been opened or closed
            //                  IProject res = (IProject)delta.getResource();
            //                  element = createElement(res, elementType, rootInfo);
            //                  if (element == null) {
            //                     // resource might be containing shared roots (see bug 19058)
            //                     this.state.updateRoots(res.getFullPath(), delta, this);
            //                     return false;
            //                  }
            //                  if (res.isOpen()) {
            //                     if (JavaProject.hasJavaNature(res)) {
            //                        addToParentInfo(element);
            //                        currentDelta().opened(element);
            //                        this.state.updateRoots(element.getPath(), delta, this);
            //
            //                        // remember that the project's cache must be reset
            //                        this.projectCachesToReset.add(element);
            //
            //                        this.manager.indexManager.indexAll(res);
            //                     }
            //                  } else {
            //                     boolean wasJavaProject = this.state.findJavaProject(res.getName()) != null;
            //                     if (wasJavaProject) {
            //                        close(element);
            //                        removeFromParentInfo(element);
            //                        currentDelta().closed(element);
            //                        this.manager.indexManager.discardJobs(element.getElementName());
            //                        this.manager.indexManager.removeIndexFamily(res.getFullPath());
            //                     }
            //                  }
            //                  return false; // when a project is open/closed don't process children
            //               }
            //               if ((flags & IResourceDelta.DESCRIPTION) != 0) {
            //                  IProject res = (IProject)delta.getResource();
            //                  boolean wasJavaProject = this.state.findJavaProject(res.getName()) != null;
            //                  boolean isJavaProject = JavaProject.hasJavaNature(res);
            //                  if (wasJavaProject != isJavaProject) {
            //                     // project's nature has been added or removed
            //                     element = createElement(res, elementType, rootInfo);
            //                     if (element == null) return false; // note its resources are still visible as roots to other projects
            //                     if (isJavaProject) {
            //                        elementAdded(element, delta, rootInfo);
            //                        this.manager.indexManager.indexAll(res);
            //                     } else {
            //                        elementRemoved(element, delta, rootInfo);
            //                        this.manager.indexManager.discardJobs(element.getElementName());
            //                        this.manager.indexManager.removeIndexFamily(res.getFullPath());
            //                        // reset the corresponding project built state, since cannot reuse if added back
            //                        if (JavaBuilder.DEBUG)
            //                           System.out.println("Clearing last state for project loosing Java nature: " + res); //$NON-NLS-1$
            //                        this.manager.setLastBuiltState(res, null /*no state*/);
            //                     }
            //                     return false; // when a project's nature is added/removed don't process children
            //                  }
            //               }
        }
        return true;
    }
    return true;
}

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private void updateIndex(Openable element, IResourceDelta delta) {

    IndexManager indexManager = this.manager.indexManager;
    if (indexManager == null)
        return;/*from   w ww .ja va2 s.c  om*/

    switch (element.getElementType()) {
    case IJavaElement.JAVA_PROJECT:
        switch (delta.getKind()) {
        case IResourceDelta.ADDED:
            indexManager.indexAll((JavaProject) element.getJavaProject());
            break;
        case IResourceDelta.REMOVED:
            indexManager.removeIndexFamily(element.getJavaProject().getProject().getFullPath());
            // NB: Discarding index jobs belonging to this project was done during PRE_DELETE
            break;
        // NB: Update of index if project is opened, closed, or its java nature is added or removed
        //     is done in updateCurrentDeltaAndIndex
        }
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        if (element instanceof JarPackageFragmentRoot) {
            JarPackageFragmentRoot root = (JarPackageFragmentRoot) element;
            // index jar file only once (if the root is in its declaring project)
            IPath jarPath = root.getPath();
            switch (delta.getKind()) {
            case IResourceDelta.ADDED:
                // index the new jar
                indexManager.indexLibrary(jarPath, root.getIndexPath());
                break;
            case IResourceDelta.CHANGED:
                // first remove the index so that it is forced to be re-indexed
                indexManager.removeIndex(jarPath);
                // then index the jar
                indexManager.indexLibrary(jarPath, root.getIndexPath());
                break;
            case IResourceDelta.REMOVED:
                // the jar was physically removed: remove the index
                indexManager.discardJobs(jarPath.toString());
                indexManager.removeIndex(jarPath);
                break;
            }
            break;
        }
        int kind = delta.getKind();
        if (kind == IResourceDelta.ADDED || kind == IResourceDelta.REMOVED
                || (kind == IResourceDelta.CHANGED && (delta.getFlags() & IResourceDelta.LOCAL_CHANGED) != 0)) {
            PackageFragmentRoot root = (PackageFragmentRoot) element;
            updateRootIndex(root, CharOperation.NO_STRINGS, delta);
            break;
        }
        // don't break as packages of the package fragment root can be indexed below
        // $FALL-THROUGH$
    case IJavaElement.PACKAGE_FRAGMENT:
        switch (delta.getKind()) {
        case IResourceDelta.CHANGED:
            if ((delta.getFlags() & IResourceDelta.LOCAL_CHANGED) == 0)
                break;
            // $FALL-THROUGH$
        case IResourceDelta.ADDED:
        case IResourceDelta.REMOVED:
            IPackageFragment pkg = null;
            if (element instanceof IPackageFragmentRoot) {
                PackageFragmentRoot root = (PackageFragmentRoot) element;
                pkg = root.getPackageFragment(CharOperation.NO_STRINGS);
            } else {
                pkg = (IPackageFragment) element;
            }
            RootInfo rootInfo = rootInfo(pkg.getParent().getPath(), delta.getKind());
            boolean isSource = rootInfo == null // if null, defaults to source
                    || rootInfo.entryKind == IClasspathEntry.CPE_SOURCE;
            IResourceDelta[] children = (IResourceDelta[]) delta.getAffectedChildren();
            for (int i = 0, length = children.length; i < length; i++) {
                IResourceDelta child = children[i];
                IResource resource = child.getResource();
                // TODO (philippe) Why do this? Every child is added anyway as the delta is walked
                if (resource instanceof IFile) {
                    String name = resource.getName();
                    if (isSource) {
                        if (org.eclipse.jdt.internal.core.util.Util.isJavaLikeFileName(name)) {
                            Openable cu = (Openable) pkg.getCompilationUnit(name);
                            updateIndex(cu, child);
                        }
                    } else if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(name)) {
                        Openable classFile = (Openable) pkg.getClassFile(name);
                        updateIndex(classFile, child);
                    }
                }
            }
            break;
        }
        break;
    case IJavaElement.CLASS_FILE:
        //            IFile file = (IFile) delta.getResource();
        //            IJavaProject project = element.getJavaProject();
        //            PackageFragmentRoot root = element.getPackageFragmentRoot();
        //            IPath binaryFolderPath = root.isExternal() && !root.isArchive() ? root.resource().getFullPath() : root.getPath();
        //            // if the class file is part of the binary output, it has been created by
        //            // the java builder -> ignore
        //            try {
        //               if (binaryFolderPath.equals(project.getOutputLocation())) {
        //                  break;
        //               }
        //            } catch (JavaModelException e) {
        //               // project doesn't exist: ignore
        //            }
        //            switch (delta.getKind()) {
        //               case IResourceDelta.CHANGED :
        //                  // no need to index if the content has not changed
        //                  int flags = delta.getFlags();
        //                  if ((flags & IResourceDelta.CONTENT) == 0 && (flags & IResourceDelta.ENCODING) == 0)
        //                     break;
        //                  // $FALL-THROUGH$
        //               case IResourceDelta.ADDED :
        //                  indexManager.addBinary(file, binaryFolderPath);
        //                  break;
        //               case IResourceDelta.REMOVED :
        //                  String containerRelativePath = Util.relativePath(file.getFullPath(), binaryFolderPath.segmentCount());
        //                  indexManager.remove(containerRelativePath, binaryFolderPath);
        //                  break;
        //            }
        break;
    case IJavaElement.COMPILATION_UNIT:
        File file = delta.getFile();
        switch (delta.getKind()) {
        case IResourceDelta.CHANGED:
            // no need to index if the content has not changed
            int flags = delta.getFlags();
            if ((flags & IResourceDelta.CONTENT) == 0 && (flags & IResourceDelta.ENCODING) == 0)
                break;
            // $FALL-THROUGH$
        case IResourceDelta.ADDED:
            indexManager.addSource(file.toPath(), element.getJavaProject().getPath(),
                    getSourceElementParser(element));
            // Clean file from secondary types cache but do not update indexing secondary type cache as it will be updated through indexing itself
            this.manager.secondaryTypesRemoving(file, false);
            break;
        case IResourceDelta.REMOVED:
            indexManager.remove(
                    file.getPath().substring(element.getJavaProject().getPath().toOSString().length()),
                    element.getJavaProject().getPath());
            // Clean file from secondary types cache and update indexing secondary type cache as indexing cannot remove secondary types from cache
            this.manager.secondaryTypesRemoving(file, true);
            break;
        }
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

/**
 *  Returns the info for the element./*from ww w . ja  v  a  2 s . co m*/
 */
public Object getInfo(IJavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        return this.modelInfo;
    case IJavaElement.JAVA_PROJECT:
        return this.projectCache.get(element);
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        return this.rootCache.get(element);
    case IJavaElement.PACKAGE_FRAGMENT:
        return this.pkgCache.get(element);
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        return this.openableCache.get(element);
    case IJavaElement.TYPE:
        Object result = this.jarTypeCache.get(element);
        if (result != null)
            return result;
        else
            return this.childrenCache.get(element);
    default:
        return this.childrenCache.get(element);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

public IJavaElement getExistingElement(IJavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        return element;
    case IJavaElement.JAVA_PROJECT:
        return element; // projectCache is a Hashtable and Hashtables don't support getKey(...)
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        return (IJavaElement) this.rootCache.getKey(element);
    case IJavaElement.PACKAGE_FRAGMENT:
        return (IJavaElement) this.pkgCache.getKey(element);
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        return (IJavaElement) this.openableCache.getKey(element);
    case IJavaElement.TYPE:
        return element; // jarTypeCache or childrenCache are Hashtables and Hashtables don't support getKey(...)
    default://from ww  w .j a  v a  2  s.co m
        return element; // childrenCache is a Hashtable and Hashtables don't support getKey(...)
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

/**
 *  Returns the info for this element without
 *  disturbing the cache ordering./*  w  w  w.ja  va2s  .  c  o  m*/
 */
protected Object peekAtInfo(IJavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        return this.modelInfo;
    case IJavaElement.JAVA_PROJECT:
        return this.projectCache.get(element);
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        return this.rootCache.peek(element);
    case IJavaElement.PACKAGE_FRAGMENT:
        return this.pkgCache.peek(element);
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        return this.openableCache.peek(element);
    case IJavaElement.TYPE:
        Object result = this.jarTypeCache.peek(element);
        if (result != null)
            return result;
        else
            return this.childrenCache.get(element);
    default:
        return this.childrenCache.get(element);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

/**
 * Remember the info for the element.//from ww  w .j  a v a2 s  . c  o  m
 */
protected void putInfo(IJavaElement element, Object info) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        this.modelInfo = info;
        break;
    case IJavaElement.JAVA_PROJECT:
        this.projectCache.put(element, info);
        this.rootCache.ensureSpaceLimit(info, element);
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        this.rootCache.put(element, info);
        this.pkgCache.ensureSpaceLimit(info, element);
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        this.pkgCache.put(element, info);
        this.openableCache.ensureSpaceLimit(info, element);
        break;
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        this.openableCache.put(element, info);
        break;
    default:
        this.childrenCache.put(element, info);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

/**
 * Removes the info of the element from the cache.
 *//*from  w w  w.j a  v a2 s. c  om*/
protected void removeInfo(JavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        this.modelInfo = null;
        break;
    case IJavaElement.JAVA_PROJECT:
        this.projectCache.remove(element);
        this.rootCache.resetSpaceLimit((int) (DEFAULT_ROOT_SIZE * getMemoryRatio()), element);
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        this.rootCache.remove(element);
        this.pkgCache.resetSpaceLimit((int) (DEFAULT_PKG_SIZE * getMemoryRatio()), element);
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        this.pkgCache.remove(element);
        this.openableCache.resetSpaceLimit(
                (int) (DEFAULT_OPENABLE_SIZE * getMemoryRatio() * getOpenableRatio()), element);
        break;
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        this.openableCache.remove(element);
        break;
    default:
        this.childrenCache.remove(element);
    }
}

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

Introduction

Prototype

Document

Usage