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

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

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

Introduction

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

Prototype

int COMPILATION_UNIT

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

Click Source Link

Document

Constant representing a Java compilation unit.

Usage

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

License:Open Source License

/**
 * @see org.eclipse.jdt.internal.compiler.ISourceElementRequestor
 *//* w w  w . java2  s.  c o m*/
public void acceptPackage(ImportReference importReference) {

    Object parentInfo = this.infoStack.peek();
    JavaElement parentHandle = (JavaElement) this.handleStack.peek();
    PackageDeclaration handle = null;

    if (parentHandle.getElementType() == IJavaElement.COMPILATION_UNIT) {
        char[] name = CharOperation.concatWith(importReference.getImportName(), '.');
        handle = createPackageDeclaration(parentHandle, new String(name));
    } else {
        Assert.isTrue(false); // Should not happen
    }
    resolveDuplicates(handle);

    AnnotatableInfo info = new AnnotatableInfo();
    info.setSourceRangeStart(importReference.declarationSourceStart);
    info.setSourceRangeEnd(importReference.declarationSourceEnd);
    info.setNameSourceStart(importReference.sourceStart);
    info.setNameSourceEnd(importReference.sourceEnd);

    addToChildren(parentInfo, handle);
    this.newElements.put(handle, info);

    if (importReference.annotations != null) {
        for (int i = 0, length = importReference.annotations.length; i < length; i++) {
            org.eclipse.jdt.internal.compiler.ast.Annotation annotation = importReference.annotations[i];
            acceptAnnotation(annotation, info, handle);
        }
    }
}

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

License:Open Source License

private void contentChanged(Openable element) {

    boolean isPrimary = false;
    boolean isPrimaryWorkingCopy = false;
    if (element.getElementType() == IJavaElement.COMPILATION_UNIT) {
        CompilationUnit cu = (CompilationUnit) element;
        isPrimary = cu.isPrimary();/*  ww w  .  jav a2  s  .c  o  m*/
        isPrimaryWorkingCopy = isPrimary && cu.isWorkingCopy();
    }
    if (isPrimaryWorkingCopy) {
        // 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 {
        close(element);
        int flags = IJavaElementDelta.F_CONTENT;
        if (element instanceof JarPackageFragmentRoot) {
            flags |= IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED;
            // need also to reset project cache otherwise it will be out-of-date
            // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=162621
            this.projectCachesToReset.add(element.getJavaProject());
        }
        if (isPrimary) {
            flags |= IJavaElementDelta.F_PRIMARY_RESOURCE;
        }
        currentDelta().changed(element, flags);
    }
}

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

License:Open Source License

private Openable createElement(File resource, int elementType, RootInfo rootInfo) {
    if (resource == null)
        return null;

    IPath path = new Path(resource.getPath());
    IJavaElement element = null;/*from   ww w  .j  a va 2s  .  c  om*/
    switch (elementType) {
    //
    //         case IJavaElement.JAVA_PROJECT:
    //
    //            // note that non-java resources rooted at the project level will also enter this code with
    //            // an elementType JAVA_PROJECT (see #elementType(...)).
    //            if (resource instanceof IProject){
    //
    //               popUntilPrefixOf(path);
    //
    //               if (this.currentElement != null
    //                  && this.currentElement.getElementType() == IJavaElement.JAVA_PROJECT
    //                  && ((IJavaProject)this.currentElement).getProject().equals(resource)) {
    //                  return this.currentElement;
    //               }
    //               if  (rootInfo != null && rootInfo.project.getProject().equals(resource)){
    //                  element = rootInfo.project;
    //                  break;
    //               }
    //               IProject proj = (IProject)resource;
    //               if (JavaProject.hasJavaNature(proj)) {
    //                  element = JavaCore.create(proj);
    //               } else {
    //                  // java project may have been been closed or removed (look for
    //                  // element amongst old java project s list).
    //                  element =  this.state.findJavaProject(proj.getName());
    //               }
    //            }
    //            break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        element = rootInfo == null ? JavaModelManager.create(resource, manager.getJavaProject())
                : rootInfo.getPackageFragmentRoot(resource);
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        if (rootInfo != null) {
            if (rootInfo.project.contains(resource)) {
                PackageFragmentRoot root = (PackageFragmentRoot) rootInfo.getPackageFragmentRoot(null);
                // create package handle
                IPath pkgPath = path.removeFirstSegments(root.resource().toPath().getNameCount());
                String[] pkgName = pkgPath.segments();
                element = root.getPackageFragment(pkgName);
            }
        } else {
            // find the element that encloses the resource
            popUntilPrefixOf(path);

            if (this.currentElement == null) {
                element = JavaCore.create(resource);
            } else {
                // find the root
                PackageFragmentRoot root = this.currentElement.getPackageFragmentRoot();
                if (root == null) {
                    element = JavaCore.create(resource);
                } else if (((JavaProject) root.getJavaProject()).contains(resource)) {
                    // create package handle
                    IPath pkgPath = path.removeFirstSegments(root.getPath().segmentCount());
                    String[] pkgName = pkgPath.segments();
                    element = root.getPackageFragment(pkgName);
                }
            }
        }
        break;
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        // find the element that encloses the resource
        popUntilPrefixOf(path);

        if (this.currentElement == null) {
            element = rootInfo == null ? JavaModelManager.create(resource, manager.getJavaProject())
                    : JavaModelManager.create(resource, rootInfo.project);
        } else {
            // find the package
            IPackageFragment pkgFragment = null;
            switch (this.currentElement.getElementType()) {
            case IJavaElement.PACKAGE_FRAGMENT_ROOT:
                PackageFragmentRoot root = (PackageFragmentRoot) this.currentElement;
                IPath rootPath = root.getPath();
                IPath pkgPath = path.removeLastSegments(1);
                String[] pkgName = pkgPath.removeFirstSegments(rootPath.segmentCount()).segments();
                pkgFragment = root.getPackageFragment(pkgName);
                break;
            case IJavaElement.PACKAGE_FRAGMENT:
                Openable pkg = this.currentElement;
                if (pkg.getPath().equals(path.removeLastSegments(1))) {
                    pkgFragment = (IPackageFragment) pkg;
                } // else case of package x which is a prefix of x.y
                break;
            case IJavaElement.COMPILATION_UNIT:
            case IJavaElement.CLASS_FILE:
                pkgFragment = (IPackageFragment) this.currentElement.getParent();
                break;
            }
            if (pkgFragment == null) {
                element = rootInfo == null ? JavaCore.create(resource)
                        : JavaModelManager.create(resource, rootInfo.project);
            } else {
                if (elementType == IJavaElement.COMPILATION_UNIT) {
                    // create compilation unit handle
                    // fileName validation has been done in elementType(IResourceDelta, int, boolean)
                    String fileName = path.lastSegment();
                    element = pkgFragment.getCompilationUnit(fileName);
                } else {
                    // create class file handle
                    // fileName validation has been done in elementType(IResourceDelta, int, boolean)
                    String fileName = path.lastSegment();
                    element = pkgFragment.getClassFile(fileName);
                }
            }
        }
        break;
    }
    if (element == null)
        return null;
    this.currentElement = (Openable) element;
    return this.currentElement;
}

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  w w  w  .jav  a  2  s  .com
        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

private boolean isPrimaryWorkingCopy(IJavaElement element, int elementType) {
    if (elementType == IJavaElement.COMPILATION_UNIT) {
        CompilationUnit cu = (CompilationUnit) element;
        return cu.isPrimary() && cu.isWorkingCopy();
    }/* w  w w  .  ja  va  2 s .  c  o  m*/
    return false;
}

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

License:Open Source License

private IJavaElementDelta processResourceDelta(IResourceDelta changes) {

    try {/*from   w w w  .j a v  a2  s .  c om*/
        IJavaModel model = this.manager.getJavaModel();
        if (!model.isOpen()) {
            // force opening of java model so that java element delta are reported
            try {
                model.open(null);
            } catch (JavaModelException e) {
                if (VERBOSE) {
                    e.printStackTrace();
                }
                return null;
            }
        }
        this.state.initializeRoots(false/*not initiAfterLoad*/);
        this.currentElement = null;

        // get the workspace delta, and start processing there.
        //         IResourceDelta[] deltas = (IResourceDelta[])changes.getAffectedChildren(IResourceDelta.ADDED | IResourceDelta.REMOVED | IResourceDelta.CHANGED, IContainer.INCLUDE_HIDDEN);
        //         for (int i = 0; i < deltas.length; i++) {
        //            IResourceDelta delta = deltas[i];
        //            File res = delta.getFile();
        //
        //            // find out the element type
        //            RootInfo rootInfo = null;
        //            int elementType;
        //            IProject proj = (IProject)res;
        //            boolean wasJavaProject = this.state.findJavaProject(proj.getName()) != null;
        //            boolean isJavaProject = JavaProject.hasJavaNature(proj);
        //            if (!wasJavaProject && !isJavaProject) {
        //               elementType = NON_JAVA_RESOURCE;
        //            } else {
        //               IPath rootPath = externalPath(res);
        //               rootInfo = enclosingRootInfo(rootPath, delta.getKind());
        //               if (rootInfo != null && rootInfo.isRootOfProject(rootPath)) {
        //                  elementType = IJavaElement.PACKAGE_FRAGMENT_ROOT;
        //               } else {
        //                  elementType = IJavaElement.JAVA_PROJECT;
        //               }
        //            }
        //
        //            // traverse delta
        //            traverseDelta(changes, IJavaElement.JAVA_PROJECT, null, null);
        updateCurrentDeltaAndIndex(changes, IJavaElement.COMPILATION_UNIT, null);
        //
        //            if (elementType == NON_JAVA_RESOURCE
        //                  || (wasJavaProject != isJavaProject && (delta.getKind()) == IResourceDelta.CHANGED)) { // project has changed nature (description or open/closed)
        //               try {
        //                  // add child as non java resource
        //                  nonJavaResourcesChanged((JavaModel)model, delta);
        //               } catch (JavaModelException e) {
        //                  // java model could not be opened
        //               }
        //            }
        //
        //         }
        resetProjectCaches();

        return this.currentDelta;
    } finally {
        this.currentDelta = null;
    }
}

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 www  . ja  va 2  s.c  o m*/

    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.JavaElementDelta.java

License:Open Source License

/**
 * Adds the child delta to the collection of affected children.  If the
 * child is already in the collection, walk down the hierarchy.
 *///from  w w  w .j a va2 s  .  c o  m
protected void addAffectedChild(JavaElementDelta child) {
    switch (this.kind) {
    case ADDED:
    case REMOVED:
        // no need to add a child if this parent is added or removed
        return;
    case CHANGED:
        this.changeFlags |= F_CHILDREN;
        break;
    default:
        this.kind = CHANGED;
        this.changeFlags |= F_CHILDREN;
    }

    // if a child delta is added to a compilation unit delta or below,
    // it's a fine grained delta
    if (this.changedElement.getElementType() >= IJavaElement.COMPILATION_UNIT) {
        fineGrained();
    }

    if (this.affectedChildren == null || this.affectedChildren.length == 0) {
        this.affectedChildren = new IJavaElementDelta[] { child };
        return;
    }
    JavaElementDelta existingChild = null;
    int existingChildIndex = -1;
    for (int i = 0; i < this.affectedChildren.length; i++) {
        if (equalsAndSameParent(this.affectedChildren[i].getElement(), child.getElement())) { // handle case of two jars that can be equals but not in the same project
            existingChild = (JavaElementDelta) this.affectedChildren[i];
            existingChildIndex = i;
            break;
        }
    }
    if (existingChild == null) { //new affected child
        this.affectedChildren = growAndAddToArray(this.affectedChildren, child);
    } else {
        switch (existingChild.getKind()) {
        case ADDED:
            switch (child.getKind()) {
            case ADDED: // child was added then added -> it is added
            case CHANGED: // child was added then changed -> it is added
                return;
            case REMOVED: // child was added then removed -> noop
                this.affectedChildren = removeAndShrinkArray(this.affectedChildren, existingChildIndex);
                return;
            }
            break;
        case REMOVED:
            switch (child.getKind()) {
            case ADDED: // child was removed then added -> it is changed
                child.kind = CHANGED;
                this.affectedChildren[existingChildIndex] = child;
                return;
            case CHANGED: // child was removed then changed -> it is removed
            case REMOVED: // child was removed then removed -> it is removed
                return;
            }
            break;
        case CHANGED:
            switch (child.getKind()) {
            case ADDED: // child was changed then added -> it is added
            case REMOVED: // child was changed then removed -> it is removed
                this.affectedChildren[existingChildIndex] = child;
                return;
            case CHANGED: // child was changed then changed -> it is changed
                IJavaElementDelta[] children = child.getAffectedChildren();
                for (int i = 0; i < children.length; i++) {
                    JavaElementDelta childsChild = (JavaElementDelta) children[i];
                    existingChild.addAffectedChild(childsChild);
                }

                // update flags
                boolean childHadContentFlag = (child.changeFlags & F_CONTENT) != 0;
                boolean existingChildHadChildrenFlag = (existingChild.changeFlags & F_CHILDREN) != 0;
                existingChild.changeFlags |= child.changeFlags;

                // remove F_CONTENT flag if existing child had F_CHILDREN flag set
                // (case of fine grained delta (existing child) and delta coming from
                // DeltaProcessor (child))
                if (childHadContentFlag && existingChildHadChildrenFlag) {
                    existingChild.changeFlags &= ~F_CONTENT;
                }

                // add the non-java resource deltas if needed
                // note that the child delta always takes precedence over this existing child delta
                // as non-java resource deltas are always created last (by the DeltaProcessor)
                IResourceDelta[] resDeltas = child.getResourceDeltas();
                if (resDeltas != null) {
                    existingChild.resourceDeltas = resDeltas;
                    existingChild.resourceDeltasCounter = child.resourceDeltasCounter;
                }

                return;
            }
            break;
        default:
            // unknown -> existing child becomes the child with the existing child's flags
            int flags = existingChild.getFlags();
            this.affectedChildren[existingChildIndex] = child;
            child.changeFlags |= flags;
        }
    }
}

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

License:Open Source License

/**
 * Builds the java element deltas between the old content of the compilation
 * unit and its new content./*from w w w  .  j  a  v  a  2s .com*/
 */
public void buildDeltas() {
    this.delta = new JavaElementDelta(this.javaElement);
    // if building a delta on a compilation unit or below,
    // it's a fine grained delta
    if (this.javaElement.getElementType() >= IJavaElement.COMPILATION_UNIT) {
        this.delta.fineGrained();
    }
    recordNewPositions(this.javaElement, 0);
    findAdditions(this.javaElement, 0);
    findDeletions();
    findChangesInPositioning(this.javaElement, 0);
    trimDelta(this.delta);
    if (this.delta.getAffectedChildren().length == 0) {
        // this is a fine grained but not children affected -> mark as content changed
        this.delta.contentChanged();
    }
}

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 va 2  s  .c o  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);
    }
}