[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / DeltaProcessor.java

/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package net.sourceforge.phpdt.internal.core;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

import net.sourceforge.phpdt.core.ElementChangedEvent;
import net.sourceforge.phpdt.core.IClasspathEntry;
import net.sourceforge.phpdt.core.IElementChangedListener;
import net.sourceforge.phpdt.core.IJavaElement;
import net.sourceforge.phpdt.core.IJavaElementDelta;
import net.sourceforge.phpdt.core.IJavaModel;
import net.sourceforge.phpdt.core.IJavaProject;
import net.sourceforge.phpdt.core.JavaCore;
import net.sourceforge.phpdt.core.JavaModelException;
import net.sourceforge.phpdt.internal.core.builder.PHPBuilder;
import net.sourceforge.phpdt.internal.core.util.Util;
import net.sourceforge.phpdt.internal.core.util.PHPFileUtil;
import net.sourceforge.phpeclipse.PHPeclipsePlugin;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.ISafeRunnable;
//import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.SafeRunner;

/**
 * This class is used by <code>JavaModelManager</code> to convert
 * <code>IResourceDelta</code>s into <code>IJavaElementDelta</code>s. It
 * also does some processing on the <code>JavaElement</code>s involved (e.g.
 * closing them or updating classpaths).
 */
public class DeltaProcessor implements IResourceChangeListener {

        final static int IGNORE = 0;

        final static int SOURCE = 1;

        final static int BINARY = 2;

        final static String EXTERNAL_JAR_ADDED = "external jar added"; //$NON-NLS-1$

        final static String EXTERNAL_JAR_REMOVED = "external jar removed"; //$NON-NLS-1$

        final static String EXTERNAL_JAR_CHANGED = "external jar changed"; //$NON-NLS-1$

        final static String EXTERNAL_JAR_UNCHANGED = "external jar unchanged"; //$NON-NLS-1$

        final static String INTERNAL_JAR_IGNORE = "internal jar ignore"; //$NON-NLS-1$

        private final static int NON_JAVA_RESOURCE = -1;

        public static boolean DEBUG = false;

        public static boolean VERBOSE = false;

        public static final int DEFAULT_CHANGE_EVENT = 0; // must not collide with
                                                                                                                // ElementChangedEvent
                                                                                                                // event masks

        /**
         * The <code>JavaElementDelta</code> corresponding to the
         * <code>IResourceDelta</code> being translated.
         */
        protected JavaElementDelta currentDelta;

        // protected IndexManager indexManager = new IndexManager();

        /* A table from IPath (from a classpath entry) to RootInfo */
        public Map roots;

        /*
         * A table from IPath (from a classpath entry) to ArrayList of RootInfo Used
         * when an IPath corresponds to more than one root
         */
        Map otherRoots;

        /* Whether the roots tables should be recomputed */
        public boolean rootsAreStale = true;

        /*
         * A table from IPath (from a classpath entry) to RootInfo from the last
         * time the delta processor was invoked.
         */
        public Map oldRoots;

        /*
         * A table from IPath (from a classpath entry) to ArrayList of RootInfo from
         * the last time the delta processor was invoked. Used when an IPath
         * corresponds to more than one root
         */
        Map oldOtherRoots;

        /*
         * A table from IPath (a source attachment path from a classpath entry) to
         * IPath (a root path)
         */
        Map sourceAttachments;

        /*
         * The java element that was last created (see createElement(IResource)).
         * This is used as a stack of java elements (using getParent() to pop it,
         * and using the various get*(...) to push it.
         */
        Openable currentElement;

        /*
         * Queue of deltas created explicily by the Java Model that have yet to be
         * fired.
         */
        public ArrayList javaModelDeltas = new ArrayList();

        /*
         * Queue of reconcile deltas on working copies that have yet to be fired.
         * This is a table form IWorkingCopy to IJavaElementDelta
         */
        public HashMap reconcileDeltas = new HashMap();

        /*
         * Turns delta firing on/off. By default it is on.
         */
        private boolean isFiring = true;

        public HashMap externalTimeStamps = new HashMap();

        public HashSet projectsToUpdate = new HashSet();

        // list of root projects which namelookup caches need to be updated for
        // dependents
        // TODO: (jerome) is it needed? projectsToUpdate might be sufficient
        public HashSet projectsForDependentNamelookupRefresh = new HashSet();

        /*
         * The global state of delta processing.
         */
        private DeltaProcessingState state;

        /*
         * The Java model manager
         */
        private JavaModelManager manager;

        /*
         * A table from IJavaProject to an array of IPackageFragmentRoot. This table
         * contains the pkg fragment roots of the project that are being deleted.
         */
        Map removedRoots;

        /*
         * A list of IJavaElement used as a scope for external archives refresh
         * during POST_CHANGE. This is null if no refresh is needed.
         */
        HashSet refreshedElements;

        class OutputsInfo {
                IPath[] paths;

                int[] traverseModes;

                int outputCount;

                OutputsInfo(IPath[] paths, int[] traverseModes, int outputCount) {
                        this.paths = paths;
                        this.traverseModes = traverseModes;
                        this.outputCount = outputCount;
                }

                public String toString() {
                        if (this.paths == null)
                                return "<none>"; //$NON-NLS-1$
                        StringBuffer buffer = new StringBuffer();
                        for (int i = 0; i < this.outputCount; i++) {
                                buffer.append("path="); //$NON-NLS-1$
                                buffer.append(this.paths[i].toString());
                                buffer.append("\n->traverse="); //$NON-NLS-1$
                                switch (this.traverseModes[i]) {
                                case BINARY:
                                        buffer.append("BINARY"); //$NON-NLS-1$
                                        break;
                                case IGNORE:
                                        buffer.append("IGNORE"); //$NON-NLS-1$
                                        break;
                                case SOURCE:
                                        buffer.append("SOURCE"); //$NON-NLS-1$
                                        break;
                                default:
                                        buffer.append("<unknown>"); //$NON-NLS-1$
                                }
                                if (i + 1 < this.outputCount) {
                                        buffer.append('\n');
                                }
                        }
                        return buffer.toString();
                }
        }

        class RootInfo {
                IJavaProject project;

                IPath rootPath;

                char[][] exclusionPatterns;

                RootInfo(IJavaProject project, IPath rootPath,
                                char[][] exclusionPatterns) {
                        this.project = project;
                        this.rootPath = rootPath;
                        this.exclusionPatterns = exclusionPatterns;
                }

                boolean isRootOfProject(IPath path) {
                        return this.rootPath.equals(path)
                                        && this.project.getProject().getFullPath().isPrefixOf(path);
                }

                public String toString() {
                        StringBuffer buffer = new StringBuffer("project="); //$NON-NLS-1$
                        if (this.project == null) {
                                buffer.append("null"); //$NON-NLS-1$
                        } else {
                                buffer.append(this.project.getElementName());
                        }
                        buffer.append("\npath="); //$NON-NLS-1$
                        if (this.rootPath == null) {
                                buffer.append("null"); //$NON-NLS-1$
                        } else {
                                buffer.append(this.rootPath.toString());
                        }
                        buffer.append("\nexcluding="); //$NON-NLS-1$
                        if (this.exclusionPatterns == null) {
                                buffer.append("null"); //$NON-NLS-1$
                        } else {
                                for (int i = 0, length = this.exclusionPatterns.length; i < length; i++) {
                                        buffer.append(new String(this.exclusionPatterns[i]));
                                        if (i < length - 1) {
                                                buffer.append("|"); //$NON-NLS-1$
                                        }
                                }
                        }
                        return buffer.toString();
                }
        }

        // DeltaProcessor(JavaModelManager manager) {
        // this.manager = manager;
        // }

        /*
         * Type of event that should be processed no matter what the real event type
         * is.
         */
        public int overridenEventType = -1;

        public DeltaProcessor(DeltaProcessingState state, JavaModelManager manager) {
                this.state = state;
                this.manager = manager;
        }

        /*
         * Adds the dependents of the given project to the list of the projects to
         * update.
         */
        // void addDependentProjects(IPath projectPath, HashSet result) {
        // try {
        // IJavaProject[] projects = this.manager.getJavaModel().getJavaProjects();
        // for (int i = 0, length = projects.length; i < length; i++) {
        // IJavaProject project = projects[i];
        // IClasspathEntry[] classpath =
        // ((JavaProject)project).getExpandedClasspath(true);
        // for (int j = 0, length2 = classpath.length; j < length2; j++) {
        // IClasspathEntry entry = classpath[j];
        // if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT
        // && entry.getPath().equals(projectPath)) {
        // result.add(project);
        // }
        // }
        // }
        // } catch (JavaModelException e) {
        // }
        // }
        /*
         * Adds the given element to the list of elements used as a scope for
         * external jars refresh.
         */
        public void addForRefresh(IJavaElement element) {
                if (this.refreshedElements == null) {
                        this.refreshedElements = new HashSet();
                }
                this.refreshedElements.add(element);
        }

        /*
         * Adds the given project and its dependents to the list of the projects to
         * update.
         */
        void addToProjectsToUpdateWithDependents(IProject project) {
                this.projectsToUpdate.add(JavaCore.create(project));
                // this.addDependentProjects(project.getFullPath(),
                // this.projectsToUpdate);
        }

        /**
         * Adds the given child handle to its parent's cache of children.
         */
        protected void addToParentInfo(Openable child) {

                Openable parent = (Openable) child.getParent();
                if (parent != null && parent.isOpen()) {
                        try {
                                JavaElementInfo info = (JavaElementInfo) parent
                                                .getElementInfo();
                                info.addChild(child);
                        } catch (JavaModelException e) {
                                // do nothing - we already checked if open
                        }
                }
        }

        /**
         * Check all external archive (referenced by given roots, projects or model)
         * status and issue a corresponding root delta. Also triggers index updates
         */
        // public void checkExternalArchiveChanges(IJavaElement[] refreshedElements,
        // IProgressMonitor monitor) throws JavaModelException {
        // try {
        // for (int i = 0, length = refreshedElements.length; i < length; i++) {
        // this.addForRefresh(refreshedElements[i]);
        // }
        // boolean hasDelta = this.createExternalArchiveDelta(monitor);
        // if (monitor != null && monitor.isCanceled()) return;
        // if (hasDelta){
        // // force classpath marker refresh of affected projects
        // JavaModel.flushExternalFileCache();
        // IJavaElementDelta[] projectDeltas =
        // this.currentDelta.getAffectedChildren();
        // for (int i = 0, length = projectDeltas.length; i < length; i++) {
        // IJavaElementDelta delta = projectDeltas[i];
        // ((JavaProject)delta.getElement()).getResolvedClasspath(
        // true, // ignoreUnresolvedEntry
        // true); // generateMarkerOnError
        // }
        // if (this.currentDelta != null) { // if delta has not been fired while
        // creating markers
        // this.manager.fire(this.currentDelta,
        // JavaModelManager.DEFAULT_CHANGE_EVENT);
        // }
        // }
        // } finally {
        // this.currentDelta = null;
        // if (monitor != null) monitor.done();
        // }
        // }
        /*
         * Check if external archives have changed and create the corresponding
         * deltas. Returns whether at least on delta was created.
         */
        // public boolean createExternalArchiveDelta(IProgressMonitor monitor)
        // throws JavaModelException {
        //              
        // if (this.refreshedElements == null) return false;
        //                      
        // HashMap externalArchivesStatus = new HashMap();
        // boolean hasDelta = false;
        //              
        // // find JARs to refresh
        // HashSet archivePathsToRefresh = new HashSet();
        // try {
        // Iterator iterator = this.refreshedElements.iterator();
        // while (iterator.hasNext()) {
        // IJavaElement element = (IJavaElement)iterator.next();
        // switch(element.getElementType()){
        // case IJavaElement.PACKAGE_FRAGMENT_ROOT :
        // archivePathsToRefresh.add(element.getPath());
        // break;
        // case IJavaElement.JAVA_PROJECT :
        // IJavaProject project = (IJavaProject) element;
        // if (!JavaProject.hasJavaNature(project.getProject())) {
        // // project is not accessible or has lost its Java nature
        // break;
        // }
        // IClasspathEntry[] classpath = project.getResolvedClasspath(true);
        // for (int j = 0, cpLength = classpath.length; j < cpLength; j++){
        // if (classpath[j].getEntryKind() == IClasspathEntry.CPE_LIBRARY){
        // archivePathsToRefresh.add(classpath[j].getPath());
        // }
        // }
        // break;
        // case IJavaElement.JAVA_MODEL :
        // IJavaProject[] projects =
        // manager.getJavaModel().getOldJavaProjectsList();
        // for (int j = 0, projectsLength = projects.length; j < projectsLength;
        // j++){
        // project = projects[j];
        // if (!JavaProject.hasJavaNature(project.getProject())) {
        // // project is not accessible or has lost its Java nature
        // continue;
        // }
        // classpath = project.getResolvedClasspath(true);
        // for (int k = 0, cpLength = classpath.length; k < cpLength; k++){
        // if (classpath[k].getEntryKind() == IClasspathEntry.CPE_LIBRARY){
        // archivePathsToRefresh.add(classpath[k].getPath());
        // }
        // }
        // }
        // break;
        // }
        // }
        // } finally {
        // this.refreshedElements = null;
        // }
        //              
        // // perform refresh
        // IJavaProject[] projects =
        // manager.getJavaModel().getOldJavaProjectsList();
        // IWorkspaceRoot wksRoot = ResourcesPlugin.getWorkspace().getRoot();
        // for (int i = 0, length = projects.length; i < length; i++) {
        //                      
        // if (monitor != null && monitor.isCanceled()) break;
        //                      
        // IJavaProject project = projects[i];
        // if (!JavaProject.hasJavaNature(project.getProject())) {
        // // project is not accessible or has lost its Java nature
        // continue;
        // }
        // IClasspathEntry[] entries = project.getResolvedClasspath(true);
        // for (int j = 0; j < entries.length; j++){
        // if (entries[j].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
        //                                      
        // IPath entryPath = entries[j].getPath();
        //                                      
        // if (!archivePathsToRefresh.contains(entryPath)) continue; // not supposed
        // to be refreshed
        //                                      
        // String status = (String)externalArchivesStatus.get(entryPath);
        // if (status == null){
        //                                              
        // // compute shared status
        // Object targetLibrary = JavaModel.getTarget(wksRoot, entryPath, true);
        //              
        // if (targetLibrary == null){ // missing JAR
        // if (this.externalTimeStamps.containsKey(entryPath)){
        // this.externalTimeStamps.remove(entryPath);
        // externalArchivesStatus.put(entryPath, EXTERNAL_JAR_REMOVED);
        // // the jar was physically removed: remove the index
        // indexManager.removeIndex(entryPath);
        // }
        //              
        // } else if (targetLibrary instanceof File){ // external JAR
        //              
        // File externalFile = (File)targetLibrary;
        //                                                      
        // // check timestamp to figure if JAR has changed in some way
        // Long oldTimestamp =(Long) this.externalTimeStamps.get(entryPath);
        // long newTimeStamp = getTimeStamp(externalFile);
        // if (oldTimestamp != null){
        //              
        // if (newTimeStamp == 0){ // file doesn't exist
        // externalArchivesStatus.put(entryPath, EXTERNAL_JAR_REMOVED);
        // this.externalTimeStamps.remove(entryPath);
        // // remove the index
        // indexManager.removeIndex(entryPath);
        //              
        // } else if (oldTimestamp.longValue() != newTimeStamp){
        // externalArchivesStatus.put(entryPath, EXTERNAL_JAR_CHANGED);
        // this.externalTimeStamps.put(entryPath, new Long(newTimeStamp));
        // // first remove the index so that it is forced to be re-indexed
        // indexManager.removeIndex(entryPath);
        // // then index the jar
        // indexManager.indexLibrary(entryPath, project.getProject());
        // } else {
        // externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);
        // }
        // } else {
        // if (newTimeStamp == 0){ // jar still doesn't exist
        // externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);
        // } else {
        // externalArchivesStatus.put(entryPath, EXTERNAL_JAR_ADDED);
        // this.externalTimeStamps.put(entryPath, new Long(newTimeStamp));
        // // index the new jar
        // indexManager.indexLibrary(entryPath, project.getProject());
        // }
        // }
        // } else { // internal JAR
        // externalArchivesStatus.put(entryPath, INTERNAL_JAR_IGNORE);
        // }
        // }
        // // according to computed status, generate a delta
        // status = (String)externalArchivesStatus.get(entryPath);
        // if (status != null){
        // if (status == EXTERNAL_JAR_ADDED){
        // PackageFragmentRoot root =
        // (PackageFragmentRoot)project.getPackageFragmentRoot(entryPath.toString());
        // if (VERBOSE){
        // System.out.println("- External JAR ADDED, affecting root:
        // "+root.getElementName()); //$NON-NLS-1$
        // }
        // elementAdded(root, null, null);
        // hasDelta = true;
        // } else if (status == EXTERNAL_JAR_CHANGED) {
        // PackageFragmentRoot root =
        // (PackageFragmentRoot)project.getPackageFragmentRoot(entryPath.toString());
        // if (VERBOSE){
        // System.out.println("- External JAR CHANGED, affecting root:
        // "+root.getElementName()); //$NON-NLS-1$
        // }
        // // reset the corresponding project built state, since the builder would
        // miss this change
        // this.manager.setLastBuiltState(project.getProject(), null /*no state*/);
        // contentChanged(root, null);
        // hasDelta = true;
        // } else if (status == EXTERNAL_JAR_REMOVED) {
        // PackageFragmentRoot root =
        // (PackageFragmentRoot)project.getPackageFragmentRoot(entryPath.toString());
        // if (VERBOSE){
        // System.out.println("- External JAR REMOVED, affecting root:
        // "+root.getElementName()); //$NON-NLS-1$
        // }
        // elementRemoved(root, null, null);
        // hasDelta = true;
        // }
        // }
        // }
        // }
        // }
        // return hasDelta;
        // }
        JavaElementDelta currentDelta() {
                if (this.currentDelta == null) {
                        this.currentDelta = new JavaElementDelta(this.manager
                                        .getJavaModel());
                }
                return this.currentDelta;
        }

        /*
         * Process the given delta and look for projects being added, opened, closed
         * or with a java nature being added or removed. Note that projects being
         * deleted are checked in deleting(IProject). In all cases, add the
         * project's dependents to the list of projects to update so that the
         * classpath related markers can be updated.
         */
        // public void checkProjectsBeingAddedOrRemoved(IResourceDelta delta) {
        // IResource resource = delta.getResource();
        // switch (resource.getType()) {
        // case IResource.ROOT :
        // // workaround for bug 15168 circular errors not reported
        // if (this.manager.javaProjectsCache == null) {
        // try {
        // this.manager.javaProjectsCache =
        // this.manager.getJavaModel().getJavaProjects();
        // } catch (JavaModelException e) {
        // }
        // }
        //                              
        // IResourceDelta[] children = delta.getAffectedChildren();
        // for (int i = 0, length = children.length; i < length; i++) {
        // this.checkProjectsBeingAddedOrRemoved(children[i]);
        // }
        // break;
        // case IResource.PROJECT :
        // // NB: No need to check project's nature as if the project is not a java
        // project:
        // // - if the project is added or changed this is a noop for
        // projectsBeingDeleted
        // // - if the project is closed, it has already lost its java nature
        // int deltaKind = delta.getKind();
        // if (deltaKind == IResourceDelta.ADDED) {
        // // remember project and its dependents
        // IProject project = (IProject)resource;
        // this.addToProjectsToUpdateWithDependents(project);
        //                                      
        // // workaround for bug 15168 circular errors not reported
        // if (JavaProject.hasJavaNature(project)) {
        // this.addToParentInfo((JavaProject)JavaCore.create(project));
        // }
        //
        // } else if (deltaKind == IResourceDelta.CHANGED) {
        // IProject project = (IProject)resource;
        // if ((delta.getFlags() & IResourceDelta.OPEN) != 0) {
        // // project opened or closed: remember project and its dependents
        // this.addToProjectsToUpdateWithDependents(project);
        //                                              
        // // workaround for bug 15168 circular errors not reported
        // if (project.isOpen()) {
        // if (JavaProject.hasJavaNature(project)) {
        // this.addToParentInfo((JavaProject)JavaCore.create(project));
        // }
        // } else {
        // JavaProject javaProject =
        // (JavaProject)this.manager.getJavaModel().findJavaProject(project);
        // if (javaProject != null) {
        // try {
        // javaProject.close();
        // } catch (JavaModelException e) {
        // }
        // this.removeFromParentInfo(javaProject);
        // }
        // }
        // } else if ((delta.getFlags() & IResourceDelta.DESCRIPTION) != 0) {
        // boolean wasJavaProject =
        // this.manager.getJavaModel().findJavaProject(project) != null;
        // boolean isJavaProject = JavaProject.hasJavaNature(project);
        // if (wasJavaProject != isJavaProject) {
        // // java nature added or removed: remember project and its dependents
        // this.addToProjectsToUpdateWithDependents(project);
        //
        // // workaround for bug 15168 circular errors not reported
        // if (isJavaProject) {
        // this.addToParentInfo((JavaProject)JavaCore.create(project));
        // } else {
        // JavaProject javaProject = (JavaProject)JavaCore.create(project);
        //                                                              
        // // flush classpath markers
        // javaProject.
        // flushClasspathProblemMarkers(
        // true, // flush cycle markers
        // true //flush classpath format markers
        // );
        //                                                                      
        // // remove problems and tasks created by the builder
        // JavaBuilder.removeProblemsAndTasksFor(project);
        //
        // // close project
        // try {
        // javaProject.close();
        // } catch (JavaModelException e) {
        // }
        // this.removeFromParentInfo(javaProject);
        // }
        // } else {
        // // in case the project was removed then added then changed (see bug
        // 19799)
        // if (JavaProject.hasJavaNature(project)) { // need nature check - 18698
        // this.addToParentInfo((JavaProject)JavaCore.create(project));
        // }
        // }
        // } else {
        // // workaround for bug 15168 circular errors not reported
        // // in case the project was removed then added then changed
        // if (JavaProject.hasJavaNature(project)) { // need nature check - 18698
        // this.addToParentInfo((JavaProject)JavaCore.create(project));
        // }
        // }
        // }
        // break;
        // }
        // }
        // private void checkSourceAttachmentChange(IResourceDelta delta, IResource
        // res) {
        // IPath rootPath = (IPath)this.sourceAttachments.get(res.getFullPath());
        // if (rootPath != null) {
        // RootInfo rootInfo = this.rootInfo(rootPath, delta.getKind());
        // if (rootInfo != null) {
        // IJavaProject projectOfRoot = rootInfo.project;
        // IPackageFragmentRoot root = null;
        // try {
        // // close the root so that source attachement cache is flushed
        // root = projectOfRoot.findPackageFragmentRoot(rootPath);
        // if (root != null) {
        // root.close();
        // }
        // } catch (JavaModelException e) {
        // }
        // if (root == null) return;
        // switch (delta.getKind()) {
        // case IResourceDelta.ADDED:
        // currentDelta().sourceAttached(root);
        // break;
        // case IResourceDelta.CHANGED:
        // currentDelta().sourceDetached(root);
        // currentDelta().sourceAttached(root);
        // break;
        // case IResourceDelta.REMOVED:
        // currentDelta().sourceDetached(root);
        // break;
        // }
        // }
        // }
        // }
        /**
         * Closes the given element, which removes it from the cache of open
         * elements.
         */
        // protected static void close(Openable element) {
        //
        // try {
        // element.close();
        // } catch (JavaModelException e) {
        // // do nothing
        // }
        // }
        /**
         * Generic processing for elements with changed contents:
         * <ul>
         * <li>The element is closed such that any subsequent accesses will re-open
         * the element reflecting its new structure.
         * <li>An entry is made in the delta reporting a content change (K_CHANGE
         * with F_CONTENT flag set).
         * </ul>
         * Delta argument could be null if processing an external JAR change
         */
        // protected void contentChanged(Openable element, IResourceDelta delta) {
        //
        // close(element);
        // int flags = IJavaElementDelta.F_CONTENT;
        // if (element instanceof JarPackageFragmentRoot){
        // flags |= IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED;
        // }
        // currentDelta().changed(element, flags);
        // }
        //      
        /**
         * Creates the openables corresponding to this resource. Returns null if
         * none was found.
         */
        // protected Openable createElement(IResource resource, int elementType,
        // RootInfo rootInfo) {
        // if (resource == null) return null;
        //              
        // IPath path = resource.getFullPath();
        // IJavaElement element = null;
        // 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){
        //
        // this.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 = (Openable)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 = (Openable) manager.getJavaModel().findJavaProject(proj);
        // }
        // }
        // break;
        // case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        // element = rootInfo == null ? JavaCore.create(resource) :
        // rootInfo.project.getPackageFragmentRoot(resource);
        // break;
        // case IJavaElement.PACKAGE_FRAGMENT:
        // // find the element that encloses the resource
        // this.popUntilPrefixOf(path);
        //                              
        // if (this.currentElement == null) {
        // element = rootInfo == null ? JavaCore.create(resource) :
        // JavaModelManager.create(resource, rootInfo.project);
        // } else {
        // // find the root
        // IPackageFragmentRoot root = this.currentElement.getPackageFragmentRoot();
        // if (root == null) {
        // element = rootInfo == null ? JavaCore.create(resource) :
        // JavaModelManager.create(resource, rootInfo.project);
        // } else if (((JavaProject)root.getJavaProject()).contains(resource)) {
        // // create package handle
        // IPath pkgPath = path.removeFirstSegments(root.getPath().segmentCount());
        // String pkg = ProjectPrefUtil.packageName(pkgPath);
        // if (pkg == null) return null;
        // element = root.getPackageFragment(pkg);
        // }
        // }
        // break;
        // case IJavaElement.COMPILATION_UNIT:
        // case IJavaElement.CLASS_FILE:
        // // find the element that encloses the resource
        // this.popUntilPrefixOf(path);
        //                              
        // if (this.currentElement == null) {
        // element = rootInfo == null ? JavaCore.create(resource) :
        // JavaModelManager.create(resource, rootInfo.project);
        // } else {
        // // find the package
        // IPackageFragment pkgFragment = null;
        // switch (this.currentElement.getElementType()) {
        // case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        // IPackageFragmentRoot root = (IPackageFragmentRoot)this.currentElement;
        // IPath rootPath = root.getPath();
        // IPath pkgPath = path.removeLastSegments(1);
        // String pkgName =
        // ProjectPrefUtil.packageName(pkgPath.removeFirstSegments(rootPath.segmentCount()));
        // if (pkgName != null) {
        // pkgFragment = root.getPackageFragment(pkgName);
        // }
        // break;
        // case IJavaElement.PACKAGE_FRAGMENT:
        // Openable pkg = (Openable)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;
        // } else {
        // this.currentElement = (Openable)element;
        // return this.currentElement;
        // }
        // }
        /**
         * Note that the project is about to be deleted.
         */
        // public void deleting(IProject project) {
        //              
        // try {
        // // discard indexing jobs that belong to this project so that the project
        // can be
        // // deleted without interferences from the index manager
        // this.indexManager.discardJobs(project.getName());
        //
        // JavaProject javaProject = (JavaProject)JavaCore.create(project);
        //                      
        // // remember roots of this project
        // if (this.removedRoots == null) {
        // this.removedRoots = new HashMap();
        // }
        // if (javaProject.isOpen()) {
        // this.removedRoots.put(javaProject,
        // javaProject.getPackageFragmentRoots());
        // } else {
        // // compute roots without opening project
        // this.removedRoots.put(
        // javaProject,
        // javaProject.computePackageFragmentRoots(
        // javaProject.getResolvedClasspath(true),
        // false));
        // }
        //                      
        // javaProject.close();
        //
        // // workaround for bug 15168 circular errors not reported
        // if (this.manager.javaProjectsCache == null) {
        // this.manager.javaProjectsCache =
        // this.manager.getJavaModel().getJavaProjects();
        // }
        // this.removeFromParentInfo(javaProject);
        //
        // } catch (JavaModelException e) {
        // }
        //              
        // this.addDependentProjects(project.getFullPath(), this.projectsToUpdate);
        // }

        /**
         * Processing for an element that has been added:
         * <ul>
         * <li>If the element is a project, do nothing, and do not process
         * children, as when a project is created it does not yet have any natures -
         * specifically a java nature.
         * <li>If the elemet is not a project, process it as added (see
         * <code>basicElementAdded</code>.
         * </ul>
         * Delta argument could be null if processing an external JAR change
         */
        // protected 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
        // if (delta != null &&
        // JavaProject.hasJavaNature((IProject)delta.getResource())) {
        // addToParentInfo(element);
        // if ((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
        // Openable movedFromElement =
        // (Openable)element.getJavaModel().getJavaProject(delta.getMovedFromPath().lastSegment());
        // currentDelta().movedTo(element, movedFromElement);
        // } else {
        // currentDelta().added(element);
        // }
        // this.projectsToUpdate.add(element);
        // this.updateRoots(element.getPath(), delta);
        // this.projectsForDependentNamelookupRefresh.add((JavaProject) element);
        // }
        // } 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);
        //                      
        // if (delta != null && (delta.getFlags() & IResourceDelta.MOVED_FROM) != 0)
        // {
        // IPath movedFromPath = delta.getMovedFromPath();
        // IResource res = delta.getResource();
        // IResource movedFromRes;
        // if (res instanceof IFile) {
        // movedFromRes = res.getWorkspace().getRoot().getFile(movedFromPath);
        // } else {
        // movedFromRes = res.getWorkspace().getRoot().getFolder(movedFromPath);
        // }
        //                              
        // // find the element type of the moved from element
        // RootInfo movedFromInfo = this.enclosingRootInfo(movedFromPath,
        // IResourceDelta.REMOVED);
        // int movedFromType =
        // this.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
        // this.createElement(movedFromRes, movedFromType, movedFromInfo);
        // if (movedFromElement == null) {
        // // moved from outside classpath
        // currentDelta().added(element);
        // } else {
        // currentDelta().movedTo(element, movedFromElement);
        // }
        // } else {
        // currentDelta().added(element);
        // }
        //                      
        // 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();
        // this.projectsToUpdate.add(project);
        // this.projectsForDependentNamelookupRefresh.add(project);
        //                                      
        // break;
        // case IJavaElement.PACKAGE_FRAGMENT :
        // // get rid of namelookup since it holds onto obsolete cached info
        // project = (JavaProject) element.getJavaProject();
        // try {
        // project.getJavaProjectElementInfo().setNameLookup(null);
        // this.projectsForDependentNamelookupRefresh.add(project);
        // } catch (JavaModelException e) {
        // }
        // // add subpackages
        // if (delta != null){
        // PackageFragmentRoot root = element.getPackageFragmentRoot();
        // String name = element.getElementName();
        // IResourceDelta[] children = delta.getAffectedChildren();
        // for (int i = 0, length = children.length; i < length; i++) {
        // IResourceDelta child = children[i];
        // IResource resource = child.getResource();
        // if (resource instanceof IFolder) {
        // String folderName = resource.getName();
        // if (ProjectPrefUtil.isValidFolderNameForPackage(folderName)) {
        // String subpkgName =
        // name.length() == 0 ?
        // folderName :
        // name + "." + folderName; //$NON-NLS-1$
        // Openable subpkg = (Openable)root.getPackageFragment(subpkgName);
        // this.updateIndex(subpkg, child);
        // this.elementAdded(subpkg, child, rootInfo);
        // }
        // }
        // }
        // }
        // break;
        // }
        // }
        // }
        /**
         * Generic processing for a removed element:
         * <ul>
         * <li>Close the element, removing its structure from the cache
         * <li>Remove the element from its parent's cache of children
         * <li>Add a REMOVED entry in the delta
         * </ul>
         * Delta argument could be null if processing an external JAR change
         */
        // protected void elementRemoved(Openable element, IResourceDelta delta,
        // RootInfo rootInfo) {
        //              
        // if (element.isOpen()) {
        // close(element);
        // }
        // removeFromParentInfo(element);
        // int elementType = element.getElementType();
        // if (delta != null && (delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
        // IPath movedToPath = delta.getMovedToPath();
        // IResource res = delta.getResource();
        // IResource movedToRes;
        // 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
        // RootInfo movedToInfo = this.enclosingRootInfo(movedToPath,
        // IResourceDelta.ADDED);
        // int movedToType =
        // this.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
        // this.createElement(movedToRes, movedToType, movedToInfo);
        // if (movedToElement == null) {
        // // moved outside classpath
        // currentDelta().removed(element);
        // } else {
        // currentDelta().movedFrom(element, movedToElement);
        // }
        // } else {
        // currentDelta().removed(element);
        // }
        //
        // switch (elementType) {
        // case IJavaElement.JAVA_MODEL :
        // this.indexManager.reset();
        // break;
        // case IJavaElement.JAVA_PROJECT :
        // this.manager.removePerProjectInfo(
        // (JavaProject) element);
        // this.updateRoots(element.getPath(), delta);
        // this.projectsForDependentNamelookupRefresh.add((JavaProject) element);
        // break;
        // case IJavaElement.PACKAGE_FRAGMENT_ROOT :
        // JavaProject project = (JavaProject) element.getJavaProject();
        // this.projectsToUpdate.add(project);
        // this.projectsForDependentNamelookupRefresh.add(project);
        // break;
        // case IJavaElement.PACKAGE_FRAGMENT :
        // //1G1TW2T - get rid of namelookup since it holds onto obsolete cached
        // info
        // project = (JavaProject) element.getJavaProject();
        // try {
        // project.getJavaProjectElementInfo().setNameLookup(null);
        // this.projectsForDependentNamelookupRefresh.add(project);
        // } catch (JavaModelException e) {
        // }
        // // remove subpackages
        // if (delta != null){
        // PackageFragmentRoot root = element.getPackageFragmentRoot();
        // String name = element.getElementName();
        // IResourceDelta[] children = delta.getAffectedChildren();
        // for (int i = 0, length = children.length; i < length; i++) {
        // IResourceDelta child = children[i];
        // IResource resource = child.getResource();
        // if (resource instanceof IFolder) {
        // String folderName = resource.getName();
        // if (ProjectPrefUtil.isValidFolderNameForPackage(folderName)) {
        // String subpkgName =
        // name.length() == 0 ?
        // folderName :
        // name + "." + folderName; //$NON-NLS-1$
        // Openable subpkg = (Openable)root.getPackageFragment(subpkgName);
        // this.updateIndex(subpkg, child);
        // this.elementRemoved(subpkg, child, rootInfo);
        // }
        // }
        // }
        // }
        // break;
        // }
        // }
        /*
         * Returns the type of the java element the given delta matches to. Returns
         * NON_JAVA_RESOURCE if unknown (e.g. a non-java resource or excluded .java
         * file)
         */
        // private int elementType(IResource res, int kind, int parentType, RootInfo
        // rootInfo) {
        // 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 = this.enclosingRootInfo(res.getFullPath(), kind);
        // }
        // if (rootInfo != null && rootInfo.isRootOfProject(res.getFullPath())) {
        // return IJavaElement.PACKAGE_FRAGMENT_ROOT;
        // } else {
        // return NON_JAVA_RESOURCE; // not yet in a package fragment root or root
        // of another project
        // }
        // case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        // case IJavaElement.PACKAGE_FRAGMENT:
        // if (rootInfo == null) {
        // rootInfo = this.enclosingRootInfo(res.getFullPath(), kind);
        // }
        // if (rootInfo == null || ProjectPrefUtil.isExcluded(res,
        // rootInfo.exclusionPatterns)) {
        // return NON_JAVA_RESOURCE;
        // }
        // if (res instanceof IFolder) {
        // if (ProjectPrefUtil.isValidFolderNameForPackage(res.getName())) {
        // return IJavaElement.PACKAGE_FRAGMENT;
        // } else {
        // return NON_JAVA_RESOURCE;
        // }
        // } else {
        // String fileName = res.getName();
        // if (ProjectPrefUtil.isValidCompilationUnitName(fileName)) {
        // return IJavaElement.COMPILATION_UNIT;
        // } else if (ProjectPrefUtil.isValidClassFileName(fileName)) {
        // return IJavaElement.CLASS_FILE;
        // } else if (this.rootInfo(res.getFullPath(), kind) != null) {
        // // 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;
        // }
        // }
        /**
         * Answer a combination of the lastModified stamp and the size. Used for
         * detecting external JAR changes
         */
        public static long getTimeStamp(File file) {
                return file.lastModified() + file.length();
        }

        public void initializeRoots() {
                // remember roots infos as old roots infos
                this.oldRoots = this.roots == null ? new HashMap() : this.roots;
                this.oldOtherRoots = this.otherRoots == null ? new HashMap()
                                : this.otherRoots;

                // recompute root infos only if necessary
                if (!rootsAreStale)
                        return;

                this.roots = new HashMap();
                this.otherRoots = new HashMap();
                this.sourceAttachments = new HashMap();

                IJavaModel model = this.manager.getJavaModel();
                IJavaProject[] projects;
                try {
                        projects = model.getJavaProjects();
                } catch (JavaModelException e) {
                        // nothing can be done
                        return;
                }
                for (int i = 0, length = projects.length; i < length; i++) {
                        IJavaProject project = projects[i];
                        IClasspathEntry[] classpath;
                        try {
                                classpath = project.getResolvedClasspath(true);
                        } catch (JavaModelException e) {
                                // continue with next project
                                continue;
                        }
                        for (int j = 0, classpathLength = classpath.length; j < classpathLength; j++) {
                                IClasspathEntry entry = classpath[j];
                                if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT)
                                        continue;

                                // root path
                                IPath path = entry.getPath();
                                if (this.roots.get(path) == null) {
                                        this.roots.put(path, new RootInfo(project, path,
                                                        ((ClasspathEntry) entry)
                                                                        .fullExclusionPatternChars()));
                                } else {
                                        ArrayList rootList = (ArrayList) this.otherRoots.get(path);
                                        if (rootList == null) {
                                                rootList = new ArrayList();
                                                this.otherRoots.put(path, rootList);
                                        }
                                        rootList.add(new RootInfo(project, path,
                                                        ((ClasspathEntry) entry)
                                                                        .fullExclusionPatternChars()));
                                }

                                // source attachment path
                                if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY)
                                        continue;
                                QualifiedName qName = new QualifiedName(JavaCore.PLUGIN_ID,
                                                "sourceattachment: " + path.toOSString()); //$NON-NLS-1$;
                                String propertyString = null;
                                try {
                                        propertyString = ResourcesPlugin.getWorkspace().getRoot()
                                                        .getPersistentProperty(qName);
                                } catch (CoreException e) {
                                        continue;
                                }
                                IPath sourceAttachmentPath;
                                // if (propertyString != null) {
                                // int index=
                                // propertyString.lastIndexOf(JarPackageFragmentRoot.ATTACHMENT_PROPERTY_DELIMITER);
                                // sourceAttachmentPath = (index < 0) ? new Path(propertyString)
                                // : new Path(propertyString.substring(0, index));
                                // } else {
                                sourceAttachmentPath = entry.getSourceAttachmentPath();
                                // }
                                if (sourceAttachmentPath != null) {
                                        this.sourceAttachments.put(sourceAttachmentPath, path);
                                }
                        }
                }
                this.rootsAreStale = false;
        }

        /*
         * Returns whether a given delta contains some information relevant to the
         * JavaModel, in particular it will not consider SYNC or MARKER only deltas.
         */
        public boolean isAffectedBy(IResourceDelta rootDelta) {
                // if (rootDelta == null) System.out.println("NULL DELTA");
                // long start = System.currentTimeMillis();
                if (rootDelta != null) {
                        // use local exception to quickly escape from delta traversal
                        class FoundRelevantDeltaException extends RuntimeException {
                        }
                        try {
                                rootDelta.accept(new IResourceDeltaVisitor() {
                                        public boolean visit(IResourceDelta delta)
                                                        throws CoreException {
                                                switch (delta.getKind()) {
                                                case IResourceDelta.ADDED:
                                                case IResourceDelta.REMOVED:
                                                        throw new FoundRelevantDeltaException();
                                                case IResourceDelta.CHANGED:
                                                        // if any flag is set but SYNC or MARKER, this delta
                                                        // should be considered
                                                        if (delta.getAffectedChildren().length == 0 // only
                                                                                                                                                // check
                                                                                                                                                // leaf
                                                                                                                                                // delta
                                                                                                                                                // nodes
                                                                        && (delta.getFlags() & ~(IResourceDelta.SYNC | IResourceDelta.MARKERS)) != 0) {
                                                                throw new FoundRelevantDeltaException();
                                                        }
                                                }
                                                return true;
                                        }
                                });
                        } catch (FoundRelevantDeltaException e) {
                                // System.out.println("RELEVANT DELTA detected in: "+
                                // (System.currentTimeMillis() - start));
                                return true;
                        } catch (CoreException e) { // ignore delta if not able to traverse
                        }
                }
                // System.out.println("IGNORE SYNC DELTA took: "+
                // (System.currentTimeMillis() - start));
                return false;
        }

        /*
         * Returns whether the given resource is in one of the given output folders
         * and if it is filtered out from this output folder.
         */
        private boolean isResFilteredFromOutput(OutputsInfo info, IResource res,
                        int elementType) {
                if (info != null) {
                        IPath resPath = res.getFullPath();
                        for (int i = 0; i < info.outputCount; i++) {
                                if (info.paths[i].isPrefixOf(resPath)) {
                                        if (info.traverseModes[i] != IGNORE) {
                                                // case of bin=src
                                                if (info.traverseModes[i] == SOURCE
                                                                && elementType == IJavaElement.CLASS_FILE) {
                                                        return true;
                                                } else {
                                                        // case of .class file under project and no source
                                                        // folder
                                                        // proj=bin
                                                        if (elementType == IJavaElement.JAVA_PROJECT
                                                                        && res instanceof IFile
                                                                        && PHPFileUtil.isPHPFile((IFile) res)) {
                                                                return true;
                                                        }
                                                }
                                        } else {
                                                return true;
                                        }
                                }
                        }
                }
                return false;
        }

        /*
         * Merges all awaiting deltas.
         */
        private IJavaElementDelta mergeDeltas(Collection deltas) {
                if (deltas.size() == 0)
                        return null;
                if (deltas.size() == 1)
                        return (IJavaElementDelta) deltas.iterator().next();

                if (VERBOSE) {
                        System.out
                                        .println("MERGING " + deltas.size() + " DELTAS [" + Thread.currentThread() + "]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                }

                Iterator iterator = deltas.iterator();
                JavaElementDelta rootDelta = new JavaElementDelta(
                                this.manager.javaModel);
                boolean insertedTree = false;
                while (iterator.hasNext()) {
                        JavaElementDelta delta = (JavaElementDelta) iterator.next();
                        if (VERBOSE) {
                                System.out.println(delta.toString());
                        }
                        IJavaElement element = delta.getElement();
                        if (this.manager.javaModel.equals(element)) {
                                IJavaElementDelta[] children = delta.getAffectedChildren();
                                for (int j = 0; j < children.length; j++) {
                                        JavaElementDelta projectDelta = (JavaElementDelta) children[j];
                                        rootDelta.insertDeltaTree(projectDelta.getElement(),
                                                        projectDelta);
                                        insertedTree = true;
                                }
                                IResourceDelta[] resourceDeltas = delta.getResourceDeltas();
                                if (resourceDeltas != null) {
                                        for (int i = 0, length = resourceDeltas.length; i < length; i++) {
                                                rootDelta.addResourceDelta(resourceDeltas[i]);
                                                insertedTree = true;
                                        }
                                }
                        } else {
                                rootDelta.insertDeltaTree(element, delta);
                                insertedTree = true;
                        }
                }
                if (insertedTree)
                        return rootDelta;
                return null;
        }

        /**
         * Check whether the updated file is affecting some of the properties of a
         * given project (like its classpath persisted as a file). Also force
         * classpath problems to be refresh if not running in autobuild mode. NOTE:
         * It can induce resource changes, and cannot be called during POST_CHANGE
         * notification.
         * 
         */
        // public void performPreBuildCheck(
        // IResourceDelta delta,
        // IJavaElement parent) {
        //      
        // IResource resource = delta.getResource();
        // IJavaElement element = null;
        // boolean processChildren = false;
        //      
        // switch (resource.getType()) {
        //      
        // case IResource.ROOT :
        // if (delta.getKind() == IResourceDelta.CHANGED) {
        // element = JavaCore.create(resource);
        // processChildren = true;
        // }
        // break;
        // case IResource.PROJECT :
        // int kind = delta.getKind();
        // switch (kind) {
        // case IResourceDelta.CHANGED:
        // // do not visit non-java projects (see bug 16140 Non-java project gets
        // .classpath)
        // IProject project = (IProject)resource;
        // if (JavaProject.hasJavaNature(project)) {
        // element = JavaCore.create(resource);
        // processChildren = true;
        // } else if
        // (JavaModelManager.getJavaModelManager().getJavaModel().findJavaProject(project)
        // != null) {
        // // project had the java nature
        // this.rootsAreStale = true;
        //
        // // remove classpath cache so that initializeRoots() will not consider the
        // project has a classpath
        // this.manager.removePerProjectInfo((JavaProject)JavaCore.create(project));
        // }
        // break;
        // case IResourceDelta.ADDED:
        // this.rootsAreStale = true;
        // break;
        // case IResourceDelta.REMOVED:
        // // remove classpath cache so that initializeRoots() will not consider the
        // project has a classpath
        // this.manager.removePerProjectInfo((JavaProject)JavaCore.create(resource));
        //                                              
        // this.rootsAreStale = true;
        // break;
        // }
        // break;
        // case IResource.FILE :
        // if (parent.getElementType() == IJavaElement.JAVA_PROJECT) {
        // IFile file = (IFile) resource;
        // JavaProject project = (JavaProject) parent;
        //      
        // /* check classpath file change */
        // if (file.getName().equals(JavaProject.CLASSPATH_FILENAME)) {
        // reconcileClasspathFileUpdate(delta, file, project);
        // this.rootsAreStale = true;
        // break;
        // }
        // // /* check custom preference file change */
        // // if (file.getName().equals(JavaProject.PREF_FILENAME)) {
        // // reconcilePreferenceFileUpdate(delta, file, project);
        // // break;
        // // }
        // }
        // break;
        // }
        // if (processChildren) {
        // IResourceDelta[] children = delta.getAffectedChildren();
        // for (int i = 0; i < children.length; i++) {
        // performPreBuildCheck(children[i], element);
        // }
        // }
        // }
        // private void popUntilPrefixOf(IPath path) {
        // while (this.currentElement != null) {
        // IPath currentElementPath = null;
        // if (this.currentElement instanceof IPackageFragmentRoot) {
        // currentElementPath =
        // ((IPackageFragmentRoot)this.currentElement).getPath();
        // } else {
        // IResource currentElementResource = this.currentElement.getResource();
        // if (currentElementResource != null) {
        // currentElementPath = currentElementResource.getFullPath();
        // }
        // }
        // if (currentElementPath != null) {
        // if (this.currentElement instanceof IPackageFragment
        // && this.currentElement.getElementName().length() == 0
        // && currentElementPath.segmentCount() != path.segmentCount()-1) {
        // // default package and path is not a direct child
        // this.currentElement = (Openable)this.currentElement.getParent();
        // }
        // if (currentElementPath.isPrefixOf(path)) {
        // return;
        // }
        // }
        // this.currentElement = (Openable)this.currentElement.getParent();
        // }
        // }
        /**
         * Converts a <code>IResourceDelta</code> rooted in a
         * <code>Workspace</code> into the corresponding set of
         * <code>IJavaElementDelta</code>, rooted in the relevant
         * <code>JavaModel</code>s.
         */

        /**
         * Update the JavaModel according to a .classpath file change. The file can
         * have changed as a result of a previous call to
         * JavaProject#setRawClasspath or as a result of some user update (through
         * repository)
         */
        // void reconcileClasspathFileUpdate(IResourceDelta delta, IFile file,
        // JavaProject project) {
        //                      
        // switch (delta.getKind()) {
        // case IResourceDelta.REMOVED : // recreate one based on in-memory
        // classpath
        // try {
        // JavaModelManager.PerProjectInfo info =
        // JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project.getProject());
        // if (info.classpath != null) { // if there is an in-memory classpath
        // project.saveClasspath(info.classpath, info.outputLocation);
        // }
        // } catch (JavaModelException e) {
        // if (project.getProject().isAccessible()) {
        // ProjectPrefUtil.log(e, "Could not save classpath for "+
        // project.getPath()); //$NON-NLS-1$
        // }
        // }
        // break;
        // case IResourceDelta.CHANGED :
        // if ((delta.getFlags() & IResourceDelta.CONTENT) == 0 // only consider
        // content change
        // && (delta.getFlags() & IResourceDelta.MOVED_FROM) == 0) // and also move
        // and overide scenario (see
        // http://dev.eclipse.org/bugs/show_bug.cgi?id=21420)
        // break;
        // case IResourceDelta.ADDED :
        // // check if any actual difference
        // project.flushClasspathProblemMarkers(false, true);
        // boolean wasSuccessful = false; // flag recording if .classpath file
        // change got reflected
        // try {
        // // force to (re)read the property file
        // IClasspathEntry[] fileEntries = project.readClasspathFile(true/*create
        // markers*/, false/*don't log problems*/);
        // if (fileEntries == null)
        // break; // could not read, ignore
        // JavaModelManager.PerProjectInfo info =
        // JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project.getProject());
        // if (info.classpath != null) { // if there is an in-memory classpath
        // if (project.isClasspathEqualsTo(info.classpath, info.outputLocation,
        // fileEntries)) {
        // wasSuccessful = true;
        // break;
        // }
        // }
        //              
        // // will force an update of the classpath/output location based on the
        // file information
        // // extract out the output location
        // IPath outputLocation = null;
        // if (fileEntries != null && fileEntries.length > 0) {
        // IClasspathEntry entry = fileEntries[fileEntries.length - 1];
        // if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
        // outputLocation = entry.getPath();
        // IClasspathEntry[] copy = new IClasspathEntry[fileEntries.length - 1];
        // System.arraycopy(fileEntries, 0, copy, 0, copy.length);
        // fileEntries = copy;
        // }
        // }
        // // restore output location
        // if (outputLocation == null) {
        // outputLocation = SetClasspathOperation.ReuseOutputLocation;
        // // clean mode will also default to reusing current one
        // }
        // project.setRawClasspath(
        // fileEntries,
        // outputLocation,
        // null, // monitor
        // true, // canChangeResource
        // project.getResolvedClasspath(true), // ignoreUnresolvedVariable
        // true, // needValidation
        // false); // no need to save
        //                                      
        // // if reach that far, the classpath file change got absorbed
        // wasSuccessful = true;
        // } catch (RuntimeException e) {
        // // setRawClasspath might fire a delta, and a listener may throw an
        // exception
        // if (project.getProject().isAccessible()) {
        // ProjectPrefUtil.log(e, "Could not set classpath for "+
        // project.getPath()); //$NON-NLS-1$
        // }
        // break;
        // } catch (JavaModelException e) { // CP failed validation
        // if (project.getProject().isAccessible()) {
        // if (e.getJavaModelStatus().getException() instanceof CoreException) {
        // // happens if the .classpath could not be written to disk
        // project.createClasspathProblemMarker(new JavaModelStatus(
        // IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
        // ProjectPrefUtil.bind("classpath.couldNotWriteClasspathFile",
        // project.getElementName(), e.getMessage()))); //$NON-NLS-1$
        // } else {
        // project.createClasspathProblemMarker(new JavaModelStatus(
        // IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
        // ProjectPrefUtil.bind("classpath.invalidClasspathInClasspathFile",
        // project.getElementName(), e.getMessage()))); //$NON-NLS-1$
        // }
        // }
        // break;
        // } finally {
        // if (!wasSuccessful) {
        // try {
        // project.setRawClasspath0(JavaProject.INVALID_CLASSPATH);
        // project.updatePackageFragmentRoots();
        // } catch (JavaModelException e) {
        // }
        // }
        // }
        // }
        // }
        /**
         * Update the JavaModel according to a .jprefs file change. The file can
         * have changed as a result of a previous call to JavaProject#setOptions or
         * as a result of some user update (through repository) Unused until
         * preference file get shared (.jpref)
         */
        // void reconcilePreferenceFileUpdate(IResourceDelta delta, IFile file,
        // JavaProject project) {
        //                      
        // switch (delta.getKind()) {
        // case IResourceDelta.REMOVED : // flush project custom settings
        // project.setOptions(null);
        // return;
        // case IResourceDelta.CHANGED :
        // if ((delta.getFlags() & IResourceDelta.CONTENT) == 0 // only consider
        // content change
        // && (delta.getFlags() & IResourceDelta.MOVED_FROM) == 0) // and also move
        // and overide scenario
        // break;
        // identityCheck : { // check if any actual difference
        // // force to (re)read the property file
        // Preferences filePreferences = project.loadPreferences();
        // if (filePreferences == null){
        // project.setOptions(null); // should have got removed delta.
        // return;
        // }
        // Preferences projectPreferences = project.getPreferences();
        // if (projectPreferences == null) return; // not a Java project
        //                                              
        // // compare preferences set to their default
        // String[] defaultProjectPropertyNames =
        // projectPreferences.defaultPropertyNames();
        // String[] defaultFilePropertyNames =
        // filePreferences.defaultPropertyNames();
        // if (defaultProjectPropertyNames.length ==
        // defaultFilePropertyNames.length) {
        // for (int i = 0; i < defaultProjectPropertyNames.length; i++){
        // String propertyName = defaultProjectPropertyNames[i];
        // if
        // (!projectPreferences.getString(propertyName).trim().equals(filePreferences.getString(propertyName).trim())){
        // break identityCheck;
        // }
        // }
        // } else break identityCheck;
        //
        // // compare custom preferences not set to their default
        // String[] projectPropertyNames = projectPreferences.propertyNames();
        // String[] filePropertyNames = filePreferences.propertyNames();
        // if (projectPropertyNames.length == filePropertyNames.length) {
        // for (int i = 0; i < projectPropertyNames.length; i++){
        // String propertyName = projectPropertyNames[i];
        // if
        // (!projectPreferences.getString(propertyName).trim().equals(filePreferences.getString(propertyName).trim())){
        // break identityCheck;
        // }
        // }
        // } else break identityCheck;
        //                                      
        // // identical - do nothing
        // return;
        // }
        // case IResourceDelta.ADDED :
        // // not identical, create delta and reset cached preferences
        // project.setPreferences(null);
        // // create delta
        // //fCurrentDelta.changed(project, IJavaElementDelta.F_OPTIONS_CHANGED);
        // }
        // }
        /*
         * Registers the given delta with this delta processor.
         */
        public void registerJavaModelDelta(IJavaElementDelta delta) {
                this.javaModelDeltas.add(delta);
        }

        /**
         * Removes the given element from its parents cache of children. If the
         * element does not have a parent, or the parent is not currently open, this
         * has no effect.
         */
        protected void removeFromParentInfo(Openable child) {

                Openable parent = (Openable) child.getParent();
                if (parent != null && parent.isOpen()) {
                        try {
                                JavaElementInfo info = (JavaElementInfo) parent
                                                .getElementInfo();
                                info.removeChild(child);
                        } catch (JavaModelException e) {
                                // do nothing - we already checked if open
                        }
                }
        }

        /**
         * Notification that some resource changes have happened on the platform,
         * and that the Java Model should update any required internal structures
         * such that its elements remain consistent. Translates
         * <code>IResourceDeltas</code> into <code>IJavaElementDeltas</code>.
         * 
         * @see IResourceDelta
         * @see IResource
         */
        public void resourceChanged(IResourceChangeEvent event) {
                if (event.getSource() instanceof IWorkspace) {
                        int eventType = this.overridenEventType == -1 ? event.getType()
                                        : this.overridenEventType;
                        IResource resource = event.getResource();
                        IResourceDelta delta = event.getDelta();

                        switch (eventType) {
                        case IResourceChangeEvent.PRE_DELETE:
                                try {
                                        if (resource.getType() == IResource.PROJECT
                                                        && ((IProject) resource)
                                                                        .hasNature(PHPeclipsePlugin.PHP_NATURE_ID)) {

                                                deleting((IProject) resource);
                                        }
                                } catch (CoreException e) {
                                        // project doesn't exist or is not open: ignore
                                }
                                return;

                        case IResourceChangeEvent.POST_CHANGE:
                                if (isAffectedBy(delta)) { // avoid populating for SYNC or
                                                                                        // MARKER deltas
                                        try {
                                                try {
                                                        stopDeltas();
                                                        // checkProjectsBeingAddedOrRemoved(delta);
                                                        // if (this.refreshedElements != null) {
                                                        // createExternalArchiveDelta(null);
                                                        // }
                                                        IJavaElementDelta translatedDelta = processResourceDelta(delta);
                                                        if (translatedDelta != null) {
                                                                registerJavaModelDelta(translatedDelta);
                                                        }
                                                } finally {
                                                        startDeltas();
                                                }
                                                // notifyTypeHierarchies(this.state.elementChangedListeners,
                                                // this.state.elementChangedListenerCount);
                                                fire(null, ElementChangedEvent.POST_CHANGE);
                                        } finally {
                                                // workaround for bug 15168 circular errors not reported
                                                this.state.modelProjectsCache = null;
                                                this.removedRoots = null;
                                        }
                                }
                                return;

                        case IResourceChangeEvent.PRE_BUILD:
                                DeltaProcessingState.ProjectUpdateInfo[] updates = this.state
                                                .removeAllProjectUpdates();
                                if (updates != null) {
                                        for (int i = 0, length = updates.length; i < length; i++) {
                                                try {
                                                        updates[i].updateProjectReferencesIfNecessary();
                                                } catch (JavaModelException e) {
                                                        // do nothing
                                                }
                                        }
                                }
                                // this.processPostChange = false;
                                if (isAffectedBy(delta)) { // avoid populating for SYNC or
                                                                                        // MARKER deltas
                                // updateClasspathMarkers(delta);
                                        PHPBuilder.buildStarting();
                                }
                                // does not fire any deltas
                                return;

                        case IResourceChangeEvent.POST_BUILD:
                                PHPBuilder.buildFinished();
                                return;
                        }
                }
                // // jsurfer TODO compare 3.0 sources
                // if (event.getSource() instanceof IWorkspace) {
                // int eventType = this.overridenEventType == -1 ? event.getType() :
                // this.overridenEventType;
                // IResource resource = event.getResource();
                // IResourceDelta delta = event.getDelta();
                //                      
                // switch(eventType){
                // case IResourceChangeEvent.PRE_DELETE :
                // try {
                // if(resource.getType() == IResource.PROJECT
                // && ((IProject) resource).hasNature(PHPeclipsePlugin.PHP_NATURE_ID)) {
                // // TODO jsurfer temp-del
                // // this.deleting((IProject)resource);
                // }
                // } catch(CoreException e){
                // }
                // return;
                //                                      
                // case IResourceChangeEvent.PRE_BUILD :
                // // TODO jsurfer temp-del
                // // if(isAffectedBy(delta)) { // avoid populating for SYNC or MARKER
                // deltas
                // // this.checkProjectsBeingAddedOrRemoved(delta);
                // //
                // // // update the classpath related markers
                // // this.updateClasspathMarkers();
                // //
                // // // the following will close project if affected by the property
                // file change
                // // try {
                // // // don't fire classpath change deltas right away, but batch them
                // // this.manager.stopDeltas();
                // // this.performPreBuildCheck(delta, null);
                // // } finally {
                // // this.manager.startDeltas();
                // // }
                // // }
                // // only fire already computed deltas (resource ones will be processed
                // in post change only)
                // this.manager.fire(null, ElementChangedEvent.PRE_AUTO_BUILD);
                // break;
                //
                // case IResourceChangeEvent.POST_BUILD :
                // // TODO jsurfer temp-del
                // // JavaBuilder.finishedBuilding(event);
                // break;
                //                                      
                // case IResourceChangeEvent.POST_CHANGE :
                // // TODO jsurfer temp-del
                // // if (isAffectedBy(delta)) {
                // // try {
                // // if (this.refreshedElements != null) {
                // // try {
                // // createExternalArchiveDelta(null);
                // // } catch (JavaModelException e) {
                // // e.printStackTrace();
                // // }
                // // }
                // // IJavaElementDelta translatedDelta =
                // this.processResourceDelta(delta);
                // // if (translatedDelta != null) {
                // // this.manager.registerJavaModelDelta(translatedDelta);
                // // }
                // // this.manager.fire(null, ElementChangedEvent.POST_CHANGE);
                // // } finally {
                // // // workaround for bug 15168 circular errors not reported
                // // this.manager.javaProjectsCache = null;
                // // this.removedRoots = null;
                // // }
                // // }
                // }
                // }
        }

        /*
         * Turns the firing mode to on. That is, deltas that are/have been
         * registered will be fired.
         */
        private void startDeltas() {
                this.isFiring = true;
        }

        /*
         * Turns the firing mode to off. That is, deltas that are/have been
         * registered will not be fired until deltas are started again.
         */
        private void stopDeltas() {
                this.isFiring = false;
        }

        /*
         * Note that the project is about to be deleted.
         */
        private void deleting(IProject project) {

                try {
                        // discard indexing jobs that belong to this project so that the
                        // project can be
                        // deleted without interferences from the index manager
                        // this.manager.indexManager.discardJobs(project.getName());

                        JavaProject javaProject = (JavaProject) JavaCore.create(project);

                        // remember roots of this project
                        if (this.removedRoots == null) {
                                this.removedRoots = new HashMap();
                        }
                        if (javaProject.isOpen()) {
                                this.removedRoots.put(javaProject, javaProject
                                                .getPackageFragmentRoots());
                        } else {
                                // compute roots without opening project
                                // this.removedRoots.put(
                                // javaProject,
                                // javaProject.computePackageFragmentRoots(
                                // javaProject.getResolvedClasspath(true/*ignoreUnresolvedEntry*/,
                                // false/*don't generateMarkerOnError*/, false/*don't
                                // returnResolutionInProgress*/),
                                // false));
                        }

                        javaProject.close();

                        // workaround for bug 15168 circular errors not reported
                        if (this.state.modelProjectsCache == null) {
                                this.state.modelProjectsCache = this.manager.getJavaModel()
                                                .getJavaProjects();
                        }
                        this.removeFromParentInfo(javaProject);

                } catch (JavaModelException e) {
                        // java project doesn't exist: ignore
                }
        }

        /*
         * Converts a <code>IResourceDelta</code> rooted in a <code>Workspace</code>
         * into the corresponding set of <code>IJavaElementDelta</code>, rooted
         * in the relevant <code>JavaModel</code>s.
         */
        private IJavaElementDelta processResourceDelta(IResourceDelta changes) {

                try {
                        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();
                        this.currentElement = null;

                        // get the workspace delta, and start processing there.
                        IResourceDelta[] deltas = changes.getAffectedChildren();
                        for (int i = 0; i < deltas.length; i++) {
                                IResourceDelta delta = deltas[i];
                                IResource res = delta.getResource();

                                // find out the element type
                                // RootInfo rootInfo = null;
                                int elementType;
                                IProject proj = (IProject) res;
                                boolean wasJavaProject = this.manager.getJavaModel()
                                                .findJavaProject(proj) != null;
                                boolean isJavaProject = JavaProject.hasJavaNature(proj);
                                if (!wasJavaProject && !isJavaProject) {
                                        elementType = NON_JAVA_RESOURCE;
                                } else {
                                        // rootInfo = this.enclosingRootInfo(res.getFullPath(),
                                        // delta.getKind());
                                        // if (rootInfo != null &&
                                        // rootInfo.isRootOfProject(res.getFullPath())) {
                                        // elementType = IJavaElement.PACKAGE_FRAGMENT_ROOT;
                                        // } else {
                                        elementType = IJavaElement.JAVA_PROJECT;
                                        // }
                                }

                                // traverse delta
                                // this.traverseDelta(delta, elementType, rootInfo, 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
                                        }
                                }

                        }
                        // refreshPackageFragmentRoots();
                        // resetProjectCaches();

                        return this.currentDelta;
                } finally {
                        this.currentDelta = null;
                        // this.rootsToRefresh.clear();
                        // this.projectCachesToReset.clear();
                }
        }

        /*
         * Converts an <code>IResourceDelta</code> and its children into the
         * corresponding <code>IJavaElementDelta</code>s.
         */
        // private void traverseDelta(
        // IResourceDelta delta,
        // int elementType,
        // RootInfo rootInfo,
        // OutputsInfo outputsInfo) {
        //                      
        // IResource res = delta.getResource();
        //      
        // // set stack of elements
        // if (this.currentElement == null && rootInfo != null) {
        // // this.currentElement = rootInfo.project;
        // }
        //              
        // // process current delta
        // boolean processChildren = true;
        // if (res instanceof IProject) {
        // processChildren =
        // this.updateCurrentDeltaAndIndex(
        // delta,
        // elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT ?
        // IJavaElement.JAVA_PROJECT : // case of prj=src
        // elementType,
        // rootInfo);
        // } else if (rootInfo != null) {
        // processChildren = this.updateCurrentDeltaAndIndex(delta, elementType,
        // rootInfo);
        // } else {
        // // not yet inside a package fragment root
        // processChildren = true;
        // }
        //              
        // // get the project's output locations and traverse mode
        // if (outputsInfo == null) outputsInfo = this.outputsInfo(rootInfo, res);
        //      
        // // process children if needed
        // if (processChildren) {
        // IResourceDelta[] children = delta.getAffectedChildren();
        // boolean oneChildOnClasspath = false;
        // int length = children.length;
        // IResourceDelta[] orphanChildren = null;
        // Openable parent = null;
        // boolean isValidParent = true;
        // for (int i = 0; i < length; i++) {
        // IResourceDelta child = children[i];
        // IResource childRes = child.getResource();
        //      
        // // check source attachment change
        // this.checkSourceAttachmentChange(child, childRes);
        //                              
        // // find out whether the child is a package fragment root of the current
        // project
        // IPath childPath = childRes.getFullPath();
        // int childKind = child.getKind();
        // RootInfo childRootInfo = this.rootInfo(childPath, childKind);
        // if (childRootInfo != null && !childRootInfo.isRootOfProject(childPath)) {
        // // package fragment root of another project (dealt with later)
        // childRootInfo = null;
        // }
        //                              
        // // compute child type
        // int childType =
        // this.elementType(
        // childRes,
        // childKind,
        // elementType,
        // rootInfo == null ? childRootInfo : rootInfo
        // );
        //                                              
        // // is childRes in the output folder and is it filtered out ?
        // boolean isResFilteredFromOutput =
        // this.isResFilteredFromOutput(outputsInfo, childRes, childType);
        //
        // boolean isNestedRoot = rootInfo != null && childRootInfo != null;
        // if (!isResFilteredFromOutput
        // && !isNestedRoot) { // do not treat as non-java rsc if nested root
        //
        // this.traverseDelta(child, childType, rootInfo == null ? childRootInfo :
        // rootInfo, outputsInfo); // traverse delta for child in the same project
        //
        // if (childType == NON_JAVA_RESOURCE) {
        // if (rootInfo != null) { // if inside a package fragment root
        // if (!isValidParent) continue;
        // if (parent == null) {
        // // find the parent of the non-java resource to attach to
        // if (this.currentElement == null
        // || !rootInfo.project.equals(this.currentElement.getJavaProject())) { //
        // note if currentElement is the IJavaModel, getJavaProject() is null
        // // force the currentProject to be used
        // this.currentElement = rootInfo.project;
        // }
        // if (elementType == IJavaElement.JAVA_PROJECT
        // || (elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT
        // && res instanceof IProject)) {
        // // NB: attach non-java resource to project (not to its package fragment
        // root)
        // parent = rootInfo.project;
        // } else {
        // parent = this.createElement(res, elementType, rootInfo);
        // }
        // if (parent == null) {
        // isValidParent = false;
        // continue;
        // }
        // }
        // // add child as non java resource
        // try {
        // nonJavaResourcesChanged(parent, child);
        // } catch (JavaModelException e) {
        // // ignore
        // }
        // } else {
        // // the non-java resource (or its parent folder) will be attached to the
        // java project
        // if (orphanChildren == null) orphanChildren = new IResourceDelta[length];
        // orphanChildren[i] = child;
        // }
        // } else {
        // oneChildOnClasspath = true;
        // }
        // } else {
        // oneChildOnClasspath = true; // to avoid reporting child delta as non-java
        // resource delta
        // }
        //                                                              
        // // if child is a nested root
        // // or if it is not a package fragment root of the current project
        // // but it is a package fragment root of another project, traverse delta
        // too
        // if (isNestedRoot
        // || (childRootInfo == null && (childRootInfo = this.rootInfo(childPath,
        // childKind)) != null)) {
        // this.traverseDelta(child, IJavaElement.PACKAGE_FRAGMENT_ROOT,
        // childRootInfo, null); // binary output of childRootInfo.project cannot be
        // this root
        // }
        //      
        // // if the child is a package fragment root of one or several other
        // projects
        // ArrayList rootList;
        // if ((rootList = this.otherRootsInfo(childPath, childKind)) != null) {
        // Iterator iterator = rootList.iterator();
        // while (iterator.hasNext()) {
        // childRootInfo = (RootInfo) iterator.next();
        // this.traverseDelta(child, IJavaElement.PACKAGE_FRAGMENT_ROOT,
        // childRootInfo, null); // binary output of childRootInfo.project cannot be
        // this root
        // }
        // }
        // }
        // if (orphanChildren != null
        // && (oneChildOnClasspath // orphan children are siblings of a package
        // fragment root
        // || res instanceof IProject)) { // non-java resource directly under a
        // project
        //                                              
        // // attach orphan children
        // IProject rscProject = res.getProject();
        // JavaProject adoptiveProject = (JavaProject)JavaCore.create(rscProject);
        // if (adoptiveProject != null
        // && JavaProject.hasJavaNature(rscProject)) { // delta iff Java project
        // (18698)
        // for (int i = 0; i < length; i++) {
        // if (orphanChildren[i] != null) {
        // try {
        // nonJavaResourcesChanged(adoptiveProject, orphanChildren[i]);
        // } catch (JavaModelException e) {
        // // ignore
        // }
        // }
        // }
        // }
        // } // else resource delta will be added by parent
        // } // else resource delta will be added by parent
        // }
        private void notifyListeners(IJavaElementDelta deltaToNotify,
                        int eventType, IElementChangedListener[] listeners,
                        int[] listenerMask, int listenerCount) {
                final ElementChangedEvent extraEvent = new ElementChangedEvent(
                                deltaToNotify, eventType);
                for (int i = 0; i < listenerCount; i++) {
                        if ((listenerMask[i] & eventType) != 0) {
                                final IElementChangedListener listener = listeners[i];
                                long start = -1;
                                if (VERBOSE) {
                                        System.out
                                                        .print("Listener #" + (i + 1) + "=" + listener.toString());//$NON-NLS-1$//$NON-NLS-2$
                                        start = System.currentTimeMillis();
                                }
                                // wrap callbacks with Safe runnable for subsequent listeners to
                                // be called when some are causing grief
                                SafeRunner.run(new ISafeRunnable() {
                                        public void handleException(Throwable exception) {
                                                Util
                                                                .log(exception,
                                                                                "Exception occurred in listener of Java element change notification"); //$NON-NLS-1$
                                        }

                                        public void run() throws Exception {
                                                listener.elementChanged(extraEvent);
                                        }
                                });
                                if (VERBOSE) {
                                        System.out
                                                        .println(" -> " + (System.currentTimeMillis() - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
                                }
                        }
                }
        }

        // private void notifyTypeHierarchies(IElementChangedListener[] listeners,
        // int listenerCount) {
        // for (int i= 0; i < listenerCount; i++) {
        // final IElementChangedListener listener = listeners[i];
        // if (!(listener instanceof TypeHierarchy)) continue;
        //
        // // wrap callbacks with Safe runnable for subsequent listeners to be
        // called when some are causing grief
        // Platform.run(new ISafeRunnable() {
        // public void handleException(Throwable exception) {
        // ProjectPrefUtil.log(exception, "Exception occurred in listener of Java
        // element change notification"); //$NON-NLS-1$
        // }
        // public void run() throws Exception {
        // TypeHierarchy typeHierarchy = (TypeHierarchy)listener;
        // if (typeHierarchy.hasFineGrainChanges()) {
        // // case of changes in primary working copies
        // typeHierarchy.needsRefresh = true;
        // typeHierarchy.fireChange();
        // }
        // }
        // });
        // }
        // }
        /*
         * Generic processing for elements with changed contents:<ul> <li>The
         * element is closed such that any subsequent accesses will re-open the
         * element reflecting its new structure. <li>An entry is made in the delta
         * reporting a content change (K_CHANGE with F_CONTENT flag set). </ul>
         */
        private void nonJavaResourcesChanged(Openable element, IResourceDelta delta)
                        throws JavaModelException {

                // reset non-java resources if element was open
                if (element.isOpen()) {
                        JavaElementInfo info = (JavaElementInfo) element.getElementInfo();
                        switch (element.getElementType()) {
                        case IJavaElement.JAVA_MODEL:
                                ((JavaModelInfo) info).nonJavaResources = null;
                                currentDelta().addResourceDelta(delta);
                                return;
                        case IJavaElement.JAVA_PROJECT:
                                ((JavaProjectElementInfo) info).setNonJavaResources(null);

                                // if a package fragment root is the project, clear it too
                                JavaProject project = (JavaProject) element;
                                PackageFragmentRoot projectRoot = (PackageFragmentRoot) project
                                                .getPackageFragmentRoot(project.getProject());
                                if (projectRoot.isOpen()) {
                                        ((PackageFragmentRootInfo) projectRoot.getElementInfo())
                                                        .setNonJavaResources(null);
                                }
                                break;
                        case IJavaElement.PACKAGE_FRAGMENT:
                                ((PackageFragmentInfo) info).setNonJavaResources(null);
                                break;
                        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
                                ((PackageFragmentRootInfo) info).setNonJavaResources(null);
                        }
                }

                JavaElementDelta current = currentDelta();
                JavaElementDelta elementDelta = current.find(element);
                if (elementDelta == null) {
                        // don't use find after creating the delta as it can be null (see
                        // https://bugs.eclipse.org/bugs/show_bug.cgi?id=63434)
                        elementDelta = current
                                        .changed(element, IJavaElementDelta.F_CONTENT);
                }
                elementDelta.addResourceDelta(delta);
        }

        /*
         * Flushes all deltas without firing them.
         */
        public void flush() {
                this.javaModelDeltas = new ArrayList();
        }

        /*
         * Finds the root info this path is included in. Returns null if not found.
         */
        RootInfo enclosingRootInfo(IPath path, int kind) {
                while (path != null && path.segmentCount() > 0) {
                        RootInfo rootInfo = this.rootInfo(path, kind);
                        if (rootInfo != null)
                                return rootInfo;
                        path = path.removeLastSegments(1);
                }
                return null;
        }

        /*
         * Fire Java Model delta, flushing them after the fact after post_change
         * notification. If the firing mode has been turned off, this has no effect.
         */
        public void fire(IJavaElementDelta customDelta, int eventType) {
                if (!this.isFiring)
                        return;

                if (DEBUG) {
                        System.out
                                        .println("-----------------------------------------------------------------------------------------------------------------------");//$NON-NLS-1$
                }

                IJavaElementDelta deltaToNotify;
                if (customDelta == null) {
                        deltaToNotify = this.mergeDeltas(this.javaModelDeltas);
                } else {
                        deltaToNotify = customDelta;
                }

                // Refresh internal scopes
                // if (deltaToNotify != null) {
                // Iterator scopes = this.manager.searchScopes.keySet().iterator();
                // while (scopes.hasNext()) {
                // AbstractSearchScope scope = (AbstractSearchScope)scopes.next();
                // scope.processDelta(deltaToNotify);
                // }
                // }

                // Notification

                // Important: if any listener reacts to notification by updating the
                // listeners list or mask, these lists will
                // be duplicated, so it is necessary to remember original lists in a
                // variable (since field values may change under us)
                IElementChangedListener[] listeners = this.state.elementChangedListeners;
                int[] listenerMask = this.state.elementChangedListenerMasks;
                int listenerCount = this.state.elementChangedListenerCount;

                switch (eventType) {
                case DEFAULT_CHANGE_EVENT:
                        firePostChangeDelta(deltaToNotify, listeners, listenerMask,
                                        listenerCount);
                        fireReconcileDelta(listeners, listenerMask, listenerCount);
                        break;
                case ElementChangedEvent.POST_CHANGE:
                        firePostChangeDelta(deltaToNotify, listeners, listenerMask,
                                        listenerCount);
                        fireReconcileDelta(listeners, listenerMask, listenerCount);
                        break;
                }
        }

        private void firePostChangeDelta(IJavaElementDelta deltaToNotify,
                        IElementChangedListener[] listeners, int[] listenerMask,
                        int listenerCount) {

                // post change deltas
                if (DEBUG) {
                        System.out
                                        .println("FIRING POST_CHANGE Delta [" + Thread.currentThread() + "]:"); //$NON-NLS-1$//$NON-NLS-2$
                        System.out
                                        .println(deltaToNotify == null ? "<NONE>" : deltaToNotify.toString()); //$NON-NLS-1$
                }
                if (deltaToNotify != null) {
                        // flush now so as to keep listener reactions to post their own
                        // deltas for subsequent iteration
                        this.flush();

                        notifyListeners(deltaToNotify, ElementChangedEvent.POST_CHANGE,
                                        listeners, listenerMask, listenerCount);
                }
        }

        private void fireReconcileDelta(IElementChangedListener[] listeners,
                        int[] listenerMask, int listenerCount) {

                IJavaElementDelta deltaToNotify = mergeDeltas(this.reconcileDeltas
                                .values());
                if (DEBUG) {
                        System.out
                                        .println("FIRING POST_RECONCILE Delta [" + Thread.currentThread() + "]:"); //$NON-NLS-1$//$NON-NLS-2$
                        System.out
                                        .println(deltaToNotify == null ? "<NONE>" : deltaToNotify.toString()); //$NON-NLS-1$
                }
                if (deltaToNotify != null) {
                        // flush now so as to keep listener reactions to post their own
                        // deltas for subsequent iteration
                        this.reconcileDeltas = new HashMap();

                        notifyListeners(deltaToNotify, ElementChangedEvent.POST_RECONCILE,
                                        listeners, listenerMask, listenerCount);
                }
        }

        /*
         * Returns the root info for the given path. Look in the old roots table if
         * kind is REMOVED.
         */
        RootInfo rootInfo(IPath path, int kind) {
                if (kind == IResourceDelta.REMOVED) {
                        return (RootInfo) this.oldRoots.get(path);
                } else {
                        return (RootInfo) this.roots.get(path);
                }
        }

        /*
         * Returns the other root infos for the given path. Look in the old other
         * roots table if kind is REMOVED.
         */
        ArrayList otherRootsInfo(IPath path, int kind) {
                if (kind == IResourceDelta.REMOVED) {
                        return (ArrayList) this.oldOtherRoots.get(path);
                } else {
                        return (ArrayList) this.otherRoots.get(path);
                }
        }

        /**
         * Converts an <code>IResourceDelta</code> and its children into the
         * corresponding <code>IJavaElementDelta</code>s. Return whether the
         * delta corresponds to a java element. If it is not a java element, it will
         * be added as a non-java resource by the sender of this method.
         */
        // protected boolean traverseDelta(
        // IResourceDelta delta,
        // int elementType,
        // RootInfo rootInfo,
        // OutputsInfo outputsInfo) {
        //                      
        // IResource res = delta.getResource();
        //      
        // // set stack of elements
        // if (this.currentElement == null && rootInfo != null) {
        // this.currentElement = (Openable)rootInfo.project;
        // }
        //              
        // // process current delta
        // boolean processChildren = true;
        // if (res instanceof IProject) {
        // processChildren =
        // this.updateCurrentDeltaAndIndex(
        // delta,
        // elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT ?
        // IJavaElement.JAVA_PROJECT : // case of prj=src
        // elementType,
        // rootInfo);
        // } else if (rootInfo != null) {
        // processChildren = this.updateCurrentDeltaAndIndex(delta, elementType,
        // rootInfo);
        // } else {
        // // not yet inside a package fragment root
        // processChildren = true;
        // }
        //              
        // // get the project's output locations and traverse mode
        // if (outputsInfo == null) outputsInfo = this.outputsInfo(rootInfo, res);
        //      
        // // process children if needed
        // if (processChildren) {
        // IResourceDelta[] children = delta.getAffectedChildren();
        // boolean oneChildOnClasspath = false;
        // int length = children.length;
        // IResourceDelta[] orphanChildren = null;
        // Openable parent = null;
        // boolean isValidParent = true;
        // for (int i = 0; i < length; i++) {
        // IResourceDelta child = children[i];
        // IResource childRes = child.getResource();
        //      
        // // check source attachment change
        // this.checkSourceAttachmentChange(child, childRes);
        //                              
        // // find out whether the child is a package fragment root of the current
        // project
        // IPath childPath = childRes.getFullPath();
        // int childKind = child.getKind();
        // RootInfo childRootInfo = this.rootInfo(childPath, childKind);
        // if (childRootInfo != null && !childRootInfo.isRootOfProject(childPath)) {
        // // package fragment root of another project (dealt with later)
        // childRootInfo = null;
        // }
        //                              
        // // compute child type
        // int childType =
        // this.elementType(
        // childRes,
        // childKind,
        // elementType,
        // rootInfo == null ? childRootInfo : rootInfo
        // );
        //                                              
        // // is childRes in the output folder and is it filtered out ?
        // boolean isResFilteredFromOutput =
        // this.isResFilteredFromOutput(outputsInfo, childRes, childType);
        //
        // boolean isNestedRoot = rootInfo != null && childRootInfo != null;
        // if (!isResFilteredFromOutput
        // && !isNestedRoot) { // do not treat as non-java rsc if nested root
        // if (!this.traverseDelta(child, childType, rootInfo == null ?
        // childRootInfo : rootInfo, outputsInfo)) { // traverse delta for child in
        // the same project
        // // it is a non-java resource
        // try {
        // if (rootInfo != null) { // if inside a package fragment root
        // if (!isValidParent) continue;
        // if (parent == null) {
        // // find the parent of the non-java resource to attach to
        // if (this.currentElement == null
        // || !this.currentElement.getJavaProject().equals(rootInfo.project)) {
        // // force the currentProject to be used
        // this.currentElement = (Openable)rootInfo.project;
        // }
        // if (elementType == IJavaElement.JAVA_PROJECT
        // || (elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT
        // && res instanceof IProject)) {
        // // NB: attach non-java resource to project (not to its package fragment
        // root)
        // parent = (Openable)rootInfo.project;
        // } else {
        // parent = this.createElement(res, elementType, rootInfo);
        // }
        // if (parent == null) {
        // isValidParent = false;
        // continue;
        // }
        // }
        // // add child as non java resource
        // nonJavaResourcesChanged(parent, child);
        // } else {
        // // the non-java resource (or its parent folder) will be attached to the
        // java project
        // if (orphanChildren == null) orphanChildren = new IResourceDelta[length];
        // orphanChildren[i] = child;
        // }
        // } catch (JavaModelException e) {
        // }
        // } else {
        // oneChildOnClasspath = true;
        // }
        // } else {
        // oneChildOnClasspath = true; // to avoid reporting child delta as non-java
        // resource delta
        // }
        //                                                              
        // // if child is a nested root
        // // or if it is not a package fragment root of the current project
        // // but it is a package fragment root of another project, traverse delta
        // too
        // if (isNestedRoot
        // || (childRootInfo == null && (childRootInfo = this.rootInfo(childPath,
        // childKind)) != null)) {
        // this.traverseDelta(child, IJavaElement.PACKAGE_FRAGMENT_ROOT,
        // childRootInfo, null); // binary output of childRootInfo.project cannot be
        // this root
        // // NB: No need to check the return value as the child can only be on the
        // classpath
        // }
        //      
        // // if the child is a package fragment root of one or several other
        // projects
        // ArrayList rootList;
        // if ((rootList = this.otherRootsInfo(childPath, childKind)) != null) {
        // Iterator iterator = rootList.iterator();
        // while (iterator.hasNext()) {
        // childRootInfo = (RootInfo) iterator.next();
        // this.traverseDelta(child, IJavaElement.PACKAGE_FRAGMENT_ROOT,
        // childRootInfo, null); // binary output of childRootInfo.project cannot be
        // this root
        // }
        // }
        // }
        // if (orphanChildren != null
        // && (oneChildOnClasspath // orphan children are siblings of a package
        // fragment root
        // || res instanceof IProject)) { // non-java resource directly under a
        // project
        //                                              
        // // attach orphan children
        // IProject rscProject = res.getProject();
        // JavaProject adoptiveProject = (JavaProject)JavaCore.create(rscProject);
        // if (adoptiveProject != null
        // && JavaProject.hasJavaNature(rscProject)) { // delta iff Java project
        // (18698)
        // for (int i = 0; i < length; i++) {
        // if (orphanChildren[i] != null) {
        // try {
        // nonJavaResourcesChanged(adoptiveProject, orphanChildren[i]);
        // } catch (JavaModelException e) {
        // }
        // }
        // }
        // }
        // } // else resource delta will be added by parent
        // return elementType != NON_JAVA_RESOURCE; // TODO: (jerome) do we still
        // need to return? (check could be done by caller)
        // } else {
        // return elementType != NON_JAVA_RESOURCE;
        // }
        // }
        /**
         * Update the classpath markers and cycle markers for the projects to
         * update.
         */
        // void updateClasspathMarkers() {
        // try {
        // if (!ResourcesPlugin.getWorkspace().isAutoBuilding()) {
        // Iterator iterator = this.projectsToUpdate.iterator();
        // while (iterator.hasNext()) {
        // try {
        // JavaProject project = (JavaProject)iterator.next();
        //                                              
        // // force classpath marker refresh
        // project.getResolvedClasspath(
        // true, // ignoreUnresolvedEntry
        // true); // generateMarkerOnError
        //                                              
        // } catch (JavaModelException e) {
        // }
        // }
        // }
        // if (!this.projectsToUpdate.isEmpty()){
        // try {
        // // update all cycle markers
        // JavaProject.updateAllCycleMarkers();
        // } catch (JavaModelException e) {
        // }
        // }
        // } finally {
        // this.projectsToUpdate = new HashSet();
        // }
        // }
        /*
         * Update the current delta (ie. add/remove/change the given element) and
         * update the correponding index. Returns whether the children of the given
         * delta must be processed. @throws a JavaModelException if the delta
         * doesn't correspond to a java element of the given type.
         */
        // private boolean updateCurrentDeltaAndIndex(IResourceDelta delta, int
        // elementType, RootInfo rootInfo) {
        // Openable element;
        // switch (delta.getKind()) {
        // case IResourceDelta.ADDED :
        // IResource deltaRes = delta.getResource();
        // element = this.createElement(deltaRes, elementType, rootInfo);
        // if (element == null) {
        // // resource might be containing shared roots (see bug 19058)
        // this.updateRoots(deltaRes.getFullPath(), delta);
        // return false;
        // }
        // this.updateIndex(element, delta);
        // this.elementAdded(element, delta, rootInfo);
        // return false;
        // case IResourceDelta.REMOVED :
        // deltaRes = delta.getResource();
        // element = this.createElement(deltaRes, elementType, rootInfo);
        // if (element == null) {
        // // resource might be containing shared roots (see bug 19058)
        // this.updateRoots(deltaRes.getFullPath(), delta);
        // return false;
        // }
        // this.updateIndex(element, delta);
        // this.elementRemoved(element, delta, rootInfo);
        //      
        // if (deltaRes.getType() == IResource.PROJECT){
        // // reset the corresponding project built state, since cannot reuse if
        // added back
        // this.manager.setLastBuiltState((IProject)deltaRes, null /*no state*/);
        // }
        // return false;
        // case IResourceDelta.CHANGED :
        // int flags = delta.getFlags();
        // if ((flags & IResourceDelta.CONTENT) != 0) {
        // // content has changed
        // element = this.createElement(delta.getResource(), elementType, rootInfo);
        // if (element == null) return false;
        // this.updateIndex(element, delta);
        // this.contentChanged(element, delta);
        // } else if (elementType == IJavaElement.JAVA_PROJECT) {
        // if ((flags & IResourceDelta.OPEN) != 0) {
        // // project has been opened or closed
        // IProject res = (IProject)delta.getResource();
        // element = this.createElement(res, elementType, rootInfo);
        // if (element == null) {
        // // resource might be containing shared roots (see bug 19058)
        // this.updateRoots(res.getFullPath(), delta);
        // return false;
        // }
        // if (res.isOpen()) {
        // if (JavaProject.hasJavaNature(res)) {
        // this.elementAdded(element, delta, rootInfo);
        // this.indexManager.indexAll(res);
        // }
        // } else {
        // JavaModel javaModel = this.manager.getJavaModel();
        // boolean wasJavaProject = javaModel.findJavaProject(res) != null;
        // if (wasJavaProject) {
        // this.elementRemoved(element, delta, rootInfo);
        // this.indexManager.discardJobs(element.getElementName());
        // this.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();
        // JavaModel javaModel = this.manager.getJavaModel();
        // boolean wasJavaProject = javaModel.findJavaProject(res) != null;
        // boolean isJavaProject = JavaProject.hasJavaNature(res);
        // if (wasJavaProject != isJavaProject) {
        // // project's nature has been added or removed
        // element = this.createElement(res, elementType, rootInfo);
        // if (element == null) return false; // note its resources are still
        // visible as roots to other projects
        // if (isJavaProject) {
        // this.elementAdded(element, delta, rootInfo);
        // this.indexManager.indexAll(res);
        // } else {
        // this.elementRemoved(element, delta, rootInfo);
        // this.indexManager.discardJobs(element.getElementName());
        // this.indexManager.removeIndexFamily(res.getFullPath());
        // // reset the corresponding project built state, since cannot reuse if
        // added back
        // 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;
        // }
        /**
         * Traverse the set of projects which have changed namespace, and refresh
         * their dependents
         */
        // public void updateDependentNamelookups() {
        // Iterator iterator;
        // // update namelookup of dependent projects
        // iterator = this.projectsForDependentNamelookupRefresh.iterator();
        // HashSet affectedDependents = new HashSet();
        // while (iterator.hasNext()) {
        // JavaProject project = (JavaProject)iterator.next();
        // addDependentProjects(project.getPath(), affectedDependents);
        // }
        // iterator = affectedDependents.iterator();
        // while (iterator.hasNext()) {
        // JavaProject project = (JavaProject) iterator.next();
        // if (project.isOpen()){
        // try {
        // ((JavaProjectElementInfo)project.getElementInfo()).setNameLookup(null);
        // } catch (JavaModelException e) {
        // }
        // }
        // }
        // }
        // protected void updateIndex(Openable element, IResourceDelta delta) {
        //
        // if (indexManager == null)
        // return;
        //
        // switch (element.getElementType()) {
        // case IJavaElement.JAVA_PROJECT :
        // switch (delta.getKind()) {
        // case IResourceDelta.ADDED :
        // this.indexManager.indexAll(element.getJavaProject().getProject());
        // break;
        // case IResourceDelta.REMOVED :
        // this.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.getJavaProject().getProject());
        // 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.getJavaProject().getProject());
        // break;
        // case IResourceDelta.REMOVED:
        // // the jar was physically removed: remove the index
        // this.indexManager.discardJobs(jarPath.toString());
        // this.indexManager.removeIndex(jarPath);
        // break;
        // }
        // break;
        // } else {
        // int kind = delta.getKind();
        // if (kind == IResourceDelta.ADDED || kind == IResourceDelta.REMOVED) {
        // IPackageFragmentRoot root = (IPackageFragmentRoot)element;
        // this.updateRootIndex(root, root.getPackageFragment(""), delta);
        // //$NON-NLS-1$
        // break;
        // }
        // }
        // // don't break as packages of the package fragment root can be indexed
        // below
        // case IJavaElement.PACKAGE_FRAGMENT :
        // switch (delta.getKind()) {
        // case IResourceDelta.ADDED:
        // case IResourceDelta.REMOVED:
        // IPackageFragment pkg = null;
        // if (element instanceof IPackageFragmentRoot) {
        // IPackageFragmentRoot root = (IPackageFragmentRoot)element;
        // pkg = root.getPackageFragment(""); //$NON-NLS-1$
        // } else {
        // pkg = (IPackageFragment)element;
        // }
        // IResourceDelta[] children = delta.getAffectedChildren();
        // for (int i = 0, length = children.length; i < length; i++) {
        // IResourceDelta child = children[i];
        // IResource resource = child.getResource();
        // if (resource instanceof IFile) {
        // String name = resource.getName();
        // if (ProjectPrefUtil.isJavaFileName(name)) {
        // Openable cu = (Openable)pkg.getCompilationUnit(name);
        // this.updateIndex(cu, child);
        // } else if (ProjectPrefUtil.isClassFileName(name)) {
        // Openable classFile = (Openable)pkg.getClassFile(name);
        // this.updateIndex(classFile, child);
        // }
        // }
        // }
        // break;
        // }
        // break;
        // case IJavaElement.CLASS_FILE :
        // IFile file = (IFile) delta.getResource();
        // IJavaProject project = element.getJavaProject();
        // IPath binaryFolderPath = element.getPackageFragmentRoot().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) {
        // }
        // switch (delta.getKind()) {
        // case IResourceDelta.CHANGED :
        // // no need to index if the content has not changed
        // if ((delta.getFlags() & IResourceDelta.CONTENT) == 0)
        // break;
        // case IResourceDelta.ADDED :
        // indexManager.addBinary(file, binaryFolderPath);
        // break;
        // case IResourceDelta.REMOVED :
        // indexManager.remove(file.getFullPath().toString(), binaryFolderPath);
        // break;
        // }
        // break;
        // case IJavaElement.COMPILATION_UNIT :
        // file = (IFile) delta.getResource();
        // switch (delta.getKind()) {
        // case IResourceDelta.CHANGED :
        // // no need to index if the content has not changed
        // if ((delta.getFlags() & IResourceDelta.CONTENT) == 0)
        // break;
        // case IResourceDelta.ADDED :
        // indexManager.addSource(file,
        // file.getProject().getProject().getFullPath());
        // break;
        // case IResourceDelta.REMOVED :
        // indexManager.remove(file.getFullPath().toString(),
        // file.getProject().getProject().getFullPath());
        // break;
        // }
        // }
        // }
        /**
         * Upadtes the index of the given root (assuming it's an addition or a
         * removal). This is done recusively, pkg being the current package.
         */
        // private void updateRootIndex(IPackageFragmentRoot root, IPackageFragment
        // pkg, IResourceDelta delta) {
        // this.updateIndex((Openable)pkg, delta);
        // IResourceDelta[] children = delta.getAffectedChildren();
        // String name = pkg.getElementName();
        // for (int i = 0, length = children.length; i < length; i++) {
        // IResourceDelta child = children[i];
        // IResource resource = child.getResource();
        // if (resource instanceof IFolder) {
        // String subpkgName =
        // name.length() == 0 ?
        // resource.getName() :
        // name + "." + resource.getName(); //$NON-NLS-1$
        // IPackageFragment subpkg = root.getPackageFragment(subpkgName);
        // this.updateRootIndex(root, subpkg, child);
        // }
        // }
        // }
        /*
         * Update the roots that are affected by the addition or the removal of the
         * given container resource.
         */
        // private void updateRoots(IPath containerPath, IResourceDelta
        // containerDelta) {
        // Map roots;
        // Map otherRoots;
        // if (containerDelta.getKind() == IResourceDelta.REMOVED) {
        // roots = this.oldRoots;
        // otherRoots = this.oldOtherRoots;
        // } else {
        // roots = this.roots;
        // otherRoots = this.otherRoots;
        // }
        // Iterator iterator = roots.keySet().iterator();
        // while (iterator.hasNext()) {
        // IPath path = (IPath)iterator.next();
        // if (containerPath.isPrefixOf(path) && !containerPath.equals(path)) {
        // IResourceDelta rootDelta =
        // containerDelta.findMember(path.removeFirstSegments(1));
        // if (rootDelta == null) continue;
        // RootInfo rootInfo = (RootInfo)roots.get(path);
        //
        // if (!rootInfo.project.getPath().isPrefixOf(path)) { // only consider
        // roots that are not included in the container
        // this.updateCurrentDeltaAndIndex(rootDelta,
        // IJavaElement.PACKAGE_FRAGMENT_ROOT, rootInfo);
        // }
        //                      
        // ArrayList rootList = (ArrayList)otherRoots.get(path);
        // if (rootList != null) {
        // Iterator otherProjects = rootList.iterator();
        // while (otherProjects.hasNext()) {
        // rootInfo = (RootInfo)otherProjects.next();
        // if (!rootInfo.project.getPath().isPrefixOf(path)) { // only consider
        // roots that are not included in the container
        // this.updateCurrentDeltaAndIndex(rootDelta,
        // IJavaElement.PACKAGE_FRAGMENT_ROOT, rootInfo);
        // }
        // }
        // }
        // }
        // }
        // }
}