core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/DeltaProcessor.java - cdt/org.eclipse.cdt - Git at Google

 package org.eclipse.cdt.internal.core.model;

 /*
  * (c) Copyright IBM Corp. 2000, 2001.
  * All Rights Reserved.
  */

 import org.eclipse.cdt.core.model.CModelException;
 import org.eclipse.cdt.core.model.CoreModel;
 import org.eclipse.cdt.core.model.IArchiveContainer;
 import org.eclipse.cdt.core.model.IBinaryContainer;
 import org.eclipse.cdt.core.model.ICElement;
 import org.eclipse.cdt.core.model.ICElementDelta;
 import org.eclipse.cdt.core.model.ICModel;
 import org.eclipse.cdt.core.model.ICProject;
 import org.eclipse.cdt.core.model.IParent;
 import org.eclipse.cdt.internal.core.search.indexing.IndexManager;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IResourceDelta;
 import org.eclipse.core.runtime.IPath;

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

 	/**
 	 * The <code>CElementDelta</code> corresponding to the <code>IResourceDelta</code> being translated.
 	 */
 	protected CElementDelta fCurrentDelta;

 	protected IndexManager indexManager = new IndexManager();

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

 	static final ICElementDelta[] NO_DELTA = new ICElementDelta[0];

 	public static boolean VERBOSE = false;

 	// Hold on the element bein renamed.
 	ICElement movedFromElement = null;

 	/**
 	 * Creates the create corresponding to this resource.
 	 * Returns null if none was found.
 	 */
 	protected ICElement createElement(IResource resource) {
 		CModelManager manager = CModelManager.getDefault();
 		if (resource == null)
 			return null;
 		ICElement celement = manager.create(resource);
 		if (celement == null) {
 			ICElement parent = manager.create(resource.getParent());
 			// Probably it was deleted, find it
 			if (parent instanceof IParent) {
 				ICElement[] children;
 				if ( CModelManager.getDefault().peekAtInfo(parent) != null ) {
 					children = ((CElement)parent).getElementInfo().getChildren();
 					for (int i = 0; i < children.length; i++) {
 						IResource res = children[i].getResource();
 						if (res != null && res.equals(resource)) {
 							celement = children[i];
 							break;
 						}
 					}
 				}
 				// BUG 36424:
 				// The Binary may only be visible in the BinaryContainers
 				if (celement == null) {
 					ICProject cproj = parent.getCProject();
 					if (cproj != null) {
 						IBinaryContainer bin = cproj.getBinaryContainer();
 						children = ((CElement)bin).getElementInfo().getChildren();
 						for (int i = 0; i < children.length; i++) {
 							IResource res = children[i].getResource();
 							if (res != null && res.equals(resource)) {
 								celement = children[i];
 								break;
 							}
 						}
 					}
 				}
 				// BUG 36424:
 				// The Archive may only be visible in the ArchiveContainers
 				if (celement == null) {
 					ICProject cproj = parent.getCProject();
 					if (cproj != null) {
 						IArchiveContainer bin = cproj.getArchiveContainer();
 						children = ((CElement)bin).getElementInfo().getChildren();
 						for (int i = 0; i < children.length; i++) {
 							IResource res = children[i].getResource();
 							if (res != null && res.equals(resource)) {
 								celement = children[i];
 								break;
 							}
 						}
 					}
 				}
 			}
 		}
 		return celement;
 	}

 	/**
 	 * Creates the create corresponding to this resource.
 	 * Returns null if none was found.
 	 */
 	protected ICElement createElement(IPath path) {
 		return CModelManager.getDefault().create(path);
 	}

 	/**
 	 * Release the Element from the CModel hastable.
 	 * Returns null if none was found.
 	 */
 	protected void releaseCElement(ICElement celement) {
 		CModelManager.getDefault().releaseCElement(celement);
 	}

 	/**
 	 * 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()) {
 			CElementInfo info = (CElementInfo)parent.getElementInfo();
 			info.addChild(child);
 		}
 	}

 	/**
 	 * 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>
 	 */
 	protected void elementAdded(ICElement element, IResourceDelta delta) {

 		if (element instanceof Openable) {
 			addToParentInfo((Openable)element);
 		}
 		if ((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
 			//ICElement movedFromElement = createElement(delta.getMovedFromPath());
 			if  (movedFromElement == null)
 				movedFromElement = createElement(delta.getMovedFromPath());
 			fCurrentDelta.movedTo(element, movedFromElement);
 			movedFromElement = null;
 		} else {
 			fCurrentDelta.added(element);
 		}
 	}

 	/**
 	 * Processing for the closing of an element - there are two cases:<ul>
 	 * <li>when a project is closed (in the platform sense), the
 	 * 		CModel reports this as if the CProject has been removed.
 	 * <li>otherwise, the CModel reports this
 	 *		as a the element being closed (CHANGED + F_CLOSED).
 	 * </ul>
 	 * <p>In both cases, the children of the element are not processed. When
 	 * a resource is closed, the platform reports all children as removed. This
 	 * would effectively delete the classpath if we processed children.
 	 */
 	protected void elementClosed(ICElement element, IResourceDelta delta) {

 		if (element.getElementType() == ICElement.C_PROJECT) {
 			// treat project closing as removal
 			elementRemoved(element, delta);
 		} else {
 			fCurrentDelta.closed(element);
 		}
 	}

 	/**
 	 * Processing for the opening of an element - there are two cases:<ul>
 	 * <li>when a project is opened (in the platform sense), the
 	 * 		CModel reports this as if the CProject has been added.
 	 * <li>otherwise, the CModel reports this
 	 *		as a the element being opened (CHANGED + F_CLOSED).
 	 * </ul>
 	 */
 	protected void elementOpened(ICElement element, IResourceDelta delta) {

 		if (element.getElementType() == ICElement.C_PROJECT) {
 			// treat project opening as addition
 			if (hasCNature(delta.getResource())) {
 				elementAdded(element, delta);
 			}
 		} else {
 			fCurrentDelta.opened(element);
 		}
 	}

 	/*
 	 * Closes the given element, which removes it from the cache of open elements.
 	 */
 	private void close(Openable element) {
 		try {
 			element.close();
 		} catch (CModelException 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>
 	 */
 	protected void elementChanged(ICElement element, IResourceDelta delta) {
 		if (element instanceof Openable) {
 			close((Openable)element);
 		}
 		fCurrentDelta.changed(element, ICElementDelta.F_CONTENT);
 	}

 	/**
 	 * 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>
 	 */
 	protected void elementRemoved(ICElement element, IResourceDelta delta) {
 		if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
 			IPath movedToPath = delta.getMovedToPath();
 			// create the moved to element
 			ICElement movedToElement = createElement(movedToPath);
 			if (movedToElement == null) {
 				// moved outside
 				fCurrentDelta.removed(element);
 			} else {
 				movedFromElement = element;
 				fCurrentDelta.movedFrom(element, movedToElement);
 			}
 		} else {
 			fCurrentDelta.removed(element);
 		}
 		releaseCElement(element);
 	}

 	/**
 	 * Filters the generated <code>CElementDelta</code>s to remove those
 	 * which should not be fired (because they don't represent a real change
 	 * in the C Model).
 	 */
 	protected ICElementDelta[] filterRealDeltas(ICElementDelta[] deltas) {

 		int length = deltas.length;
 		ICElementDelta[] realDeltas = null;
 		int index = 0;
 		for (int i = 0; i < length; i++) {
 			CElementDelta delta = (CElementDelta)deltas[i];
 			if (delta == null) {
 				continue;
 			}
 			if (delta.getAffectedChildren().length > 0
 				|| delta.getKind() == ICElementDelta.ADDED
 				|| delta.getKind() == ICElementDelta.REMOVED
 				|| (delta.getFlags() & ICElementDelta.F_CLOSED) != 0
 				|| (delta.getFlags() & ICElementDelta.F_OPENED) != 0
 				|| delta.resourceDeltasCounter > 0) {

 				if (realDeltas == null) {
 					realDeltas = new ICElementDelta[length];
 				}
 				realDeltas[index++] = delta;
 			}
 		}
 		if (index > 0) {
 			ICElementDelta[] result = new ICElementDelta[index];
 			System.arraycopy(realDeltas, 0, result, 0, index);
 			return result;
 		} else {
 			return NO_DELTA;
 		}
 	}

 	/**
 	 * Returns true if the given resource is contained in an open project
 	 * with a java nature, otherwise false.
 	 */
 	protected boolean hasCNature(IResource resource) {
 		// ensure the project has a C nature (if open)
 		IProject project = resource.getProject();
 		if (project.isOpen()) {
 			return CoreModel.getDefault().hasCNature(project);
 		}
 		return false;
 	}

 	/**
 	 * Converts a <code>IResourceDelta</code> rooted in a <code>Workspace</code> into
 	 * the corresponding set of <code>ICElementDelta</code>, rooted in the
 	 * relevant <code>CModel</code>s.
 	 */
 	public ICElementDelta[] processResourceDelta(IResourceDelta changes) {

 		try {
 			ICElement root = (ICModel)CModelManager.getDefault().getCModel();

 /*
 			try {
 				changes.accept(new IResourceDeltaVisitor() {
 					public boolean visit(IResourceDelta delta) {
 						switch (delta.getKind()) {
 							case IResourceDelta.ADDED :
 							// handle added resource
 							System.out.print("ADDED ");
 							break;
 							case IResourceDelta.REMOVED :
 							// handle removed resource
 							System.out.print("REMOVED ");
 							break;
 							case IResourceDelta.CHANGED :
 							// handle changed resource
 							System.out.print("CHANGED ");
 							break;
 						}
 						System.out.println(delta.getResource());
 						return true;
 					}
 				});
 			} catch (CoreException e) {
 			}
 */
 			// get the workspace delta, and start processing there.
 			IResourceDelta[] deltas = changes.getAffectedChildren();
 			ICElementDelta[] translatedDeltas = new CElementDelta[deltas.length];
 			//System.out.println("delta.length: " + deltas.length);
 			for (int i = 0; i < deltas.length; i++) {
 				IResourceDelta delta = deltas[i];
 				fCurrentDelta = new CElementDelta(root);
 				traverseDelta(root, delta); // traverse delta
 				translatedDeltas[i] = fCurrentDelta;
 			}
 			return filterRealDeltas(translatedDeltas);
 		} finally {
 		}
 	}

 	/**
 	 * Converts an <code>IResourceDelta</code> and its children into
 	 * the corresponding <code>ICElementDelta</code>s.
 	 * Return whether the delta corresponds to a resource on the classpath.
 	 * If it is not a resource on the classpath, it will be added as a non-java
 	 * resource by the sender of this method.
 	 */
 	protected void traverseDelta(ICElement parent, IResourceDelta delta) {
 		try {
 			ICElement current = updateCurrentDeltaAndIndex(delta);
 			if (current == null) {
 				nonCResourcesChanged(parent, delta);
 			} else {
 				parent = current;
 			}
 		} catch (CModelException e) {
 		}
 		IResourceDelta [] children = delta.getAffectedChildren();
 		for (int i = 0; i < children.length; i++) {
 				traverseDelta(parent, children[i]);
 		}
 	}

 	protected void nonCResourcesChanged(ICElement parent, IResourceDelta delta) {
 		CElementDelta elementDelta = fCurrentDelta.find(parent);
 		if (elementDelta == null) {
 			fCurrentDelta.changed(parent, ICElementDelta.F_CONTENT);
 		} else {
 			elementDelta.addResourceDelta(delta);
 		}
 		if (parent instanceof CContainer) {
 			// if info not created yet no need to null NonCResources...
 			if (CModelManager.getDefault().peekAtInfo(parent) != null) {
 				CElementInfo info = ((CContainer)parent).getElementInfo();
 				if (info instanceof CContainerInfo) {
 					((CContainerInfo)info).setNonCResources(null);
 				}
 			}
 		}
 	}

 	/*
 	 * 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 CModelException if the delta doesn't correspond to a c element of the given type.
 	 */
 	private ICElement updateCurrentDeltaAndIndex(IResourceDelta delta) throws CModelException {

 		IResource resource = delta.getResource();
 		ICElement element = createElement(resource);

 		switch (delta.getKind()) {
 			case IResourceDelta.ADDED :
 				if (element != null) {
 					updateIndexAddResource(element, delta);
 					elementAdded(element, delta);
 				}
 				break;

 			case IResourceDelta.REMOVED :
 				if (element != null) {
 					updateIndexRemoveResource(element, delta);
 					elementRemoved(element, delta);
 				}
 				break;

 			case IResourceDelta.CHANGED :
 				int flags = delta.getFlags();
 				if ((flags & IResourceDelta.CONTENT) != 0) {
 					// content has changed
 					if (element != null) {
 						elementChanged(element, delta);
 						updateIndexAddResource(element, delta);
 						//check to see if any projects need to be reindexed
 						updateDependencies(element);

 					}
 				} else if (resource.getType() == IResource.PROJECT) {
 					if ((flags & IResourceDelta.OPEN) != 0) {
 						// project has been opened or closed
 						IProject res = (IProject)resource;
 						if (element != null) {
 							if (res.isOpen()) {
 								elementOpened(element, delta);
 								updateIndexAddResource(element, delta);
 							} else {
 								elementClosed(element, delta);
 								updateIndexRemoveResource(element, delta);
 							}
 						}
 					} else if ((flags & IResourceDelta.DESCRIPTION) != 0) {
 						if (element != null) {
 							elementAdded(element, delta);
 						}
 					} else if (element != null) {
 						elementChanged(element, delta);
 					}
 				} else if (element != null) {
 					elementChanged(element, delta);
 				}
 				break;
 		}
 		return element;
 	}

 	protected void updateIndexAddResource(ICElement element, IResourceDelta delta) {

 		if (indexManager == null)
 			return;

 	    switch (element.getElementType()) {
 			case ICElement.C_PROJECT :
 				this.indexManager.indexAll(element.getCProject().getProject());
 				break;

 			case ICElement.C_UNIT:
 				IFile file = (IFile) delta.getResource();
 				IProject filesProject = file.getProject();
 				indexManager.addSource(file, filesProject.getFullPath());
 				break;
 	    }

 	}

 	protected void updateIndexRemoveResource(ICElement element, IResourceDelta delta) {

 		if (indexManager == null)
 						return;

 		switch (element.getElementType()) {
 			case ICElement.C_PROJECT :
 						this.indexManager.removeIndexFamily(element.getCProject().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 c nature is added or removed
 						//     is done in updateCurrentDeltaAndIndex

 			case ICElement.C_UNIT:
 						IFile file = (IFile) delta.getResource();
 						indexManager.remove(file.getFullPath().toString(), file.getProject().getProject().getFullPath());
 						break;
 		}


 	}

 	private void updateDependencies(ICElement element){

 		IResource resource = element.getResource();
 		if (resource == null)
 		 return;

 		String fileExtension = resource.getFileExtension();

 		if ((fileExtension != null) &&
 			(isValidHeader(fileExtension))){
 			indexManager.updateDependencies(resource);
 		}
 	}

 	private boolean isValidHeader(String fileExtension) {
 		String[] supportedTypes = CModelManager.headerExtensions;
 		for (int i = 0; i < supportedTypes.length; ++i) {
 			if (supportedTypes[i].equals(fileExtension))
 				return true;
 		}
 		return false;
 	}
 }
	package org.eclipse.cdt.internal.core.model;

	/*
	* (c) Copyright IBM Corp. 2000, 2001.
	* All Rights Reserved.
	*/

	import org.eclipse.cdt.core.model.CModelException;
	import org.eclipse.cdt.core.model.CoreModel;
	import org.eclipse.cdt.core.model.IArchiveContainer;
	import org.eclipse.cdt.core.model.IBinaryContainer;
	import org.eclipse.cdt.core.model.ICElement;
	import org.eclipse.cdt.core.model.ICElementDelta;
	import org.eclipse.cdt.core.model.ICModel;
	import org.eclipse.cdt.core.model.ICProject;
	import org.eclipse.cdt.core.model.IParent;
	import org.eclipse.cdt.internal.core.search.indexing.IndexManager;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IResourceDelta;
	import org.eclipse.core.runtime.IPath;

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

	/**
	* The <code>CElementDelta</code> corresponding to the <code>IResourceDelta</code> being translated.
	*/
	protected CElementDelta fCurrentDelta;

	protected IndexManager indexManager = new IndexManager();

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

	static final ICElementDelta[] NO_DELTA = new ICElementDelta[0];

	public static boolean VERBOSE = false;

	// Hold on the element bein renamed.
	ICElement movedFromElement = null;

	/**
	* Creates the create corresponding to this resource.
	* Returns null if none was found.
	*/
	protected ICElement createElement(IResource resource) {
	CModelManager manager = CModelManager.getDefault();
	if (resource == null)
	return null;
	ICElement celement = manager.create(resource);
	if (celement == null) {
	ICElement parent = manager.create(resource.getParent());
	// Probably it was deleted, find it
	if (parent instanceof IParent) {
	ICElement[] children;
	if ( CModelManager.getDefault().peekAtInfo(parent) != null ) {
	children = ((CElement)parent).getElementInfo().getChildren();
	for (int i = 0; i < children.length; i++) {
	IResource res = children[i].getResource();
	if (res != null && res.equals(resource)) {
	celement = children[i];
	break;
	}
	}
	}
	// BUG 36424:
	// The Binary may only be visible in the BinaryContainers
	if (celement == null) {
	ICProject cproj = parent.getCProject();
	if (cproj != null) {
	IBinaryContainer bin = cproj.getBinaryContainer();
	children = ((CElement)bin).getElementInfo().getChildren();
	for (int i = 0; i < children.length; i++) {
	IResource res = children[i].getResource();
	if (res != null && res.equals(resource)) {
	celement = children[i];
	break;
	}
	}
	}
	}
	// BUG 36424:
	// The Archive may only be visible in the ArchiveContainers
	if (celement == null) {
	ICProject cproj = parent.getCProject();
	if (cproj != null) {
	IArchiveContainer bin = cproj.getArchiveContainer();
	children = ((CElement)bin).getElementInfo().getChildren();
	for (int i = 0; i < children.length; i++) {
	IResource res = children[i].getResource();
	if (res != null && res.equals(resource)) {
	celement = children[i];
	break;
	}
	}
	}
	}
	}
	}
	return celement;
	}

	/**
	* Creates the create corresponding to this resource.
	* Returns null if none was found.
	*/
	protected ICElement createElement(IPath path) {
	return CModelManager.getDefault().create(path);
	}

	/**
	* Release the Element from the CModel hastable.
	* Returns null if none was found.
	*/
	protected void releaseCElement(ICElement celement) {
	CModelManager.getDefault().releaseCElement(celement);
	}

	/**
	* 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()) {
	CElementInfo info = (CElementInfo)parent.getElementInfo();
	info.addChild(child);
	}
	}

	/**
	* 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>
	*/
	protected void elementAdded(ICElement element, IResourceDelta delta) {

	if (element instanceof Openable) {
	addToParentInfo((Openable)element);
	}
	if ((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
	//ICElement movedFromElement = createElement(delta.getMovedFromPath());
	if (movedFromElement == null)
	movedFromElement = createElement(delta.getMovedFromPath());
	fCurrentDelta.movedTo(element, movedFromElement);
	movedFromElement = null;
	} else {
	fCurrentDelta.added(element);
	}
	}

	/**
	* Processing for the closing of an element - there are two cases:<ul>
	* <li>when a project is closed (in the platform sense), the
	* CModel reports this as if the CProject has been removed.
	* <li>otherwise, the CModel reports this
	* as a the element being closed (CHANGED + F_CLOSED).
	* </ul>
	* <p>In both cases, the children of the element are not processed. When
	* a resource is closed, the platform reports all children as removed. This
	* would effectively delete the classpath if we processed children.
	*/
	protected void elementClosed(ICElement element, IResourceDelta delta) {

	if (element.getElementType() == ICElement.C_PROJECT) {
	// treat project closing as removal
	elementRemoved(element, delta);
	} else {
	fCurrentDelta.closed(element);
	}
	}

	/**
	* Processing for the opening of an element - there are two cases:<ul>
	* <li>when a project is opened (in the platform sense), the
	* CModel reports this as if the CProject has been added.
	* <li>otherwise, the CModel reports this
	* as a the element being opened (CHANGED + F_CLOSED).
	* </ul>
	*/
	protected void elementOpened(ICElement element, IResourceDelta delta) {

	if (element.getElementType() == ICElement.C_PROJECT) {
	// treat project opening as addition
	if (hasCNature(delta.getResource())) {
	elementAdded(element, delta);
	}
	} else {
	fCurrentDelta.opened(element);
	}
	}

	/*
	* Closes the given element, which removes it from the cache of open elements.
	*/
	private void close(Openable element) {
	try {
	element.close();
	} catch (CModelException 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>
	*/
	protected void elementChanged(ICElement element, IResourceDelta delta) {
	if (element instanceof Openable) {
	close((Openable)element);
	}
	fCurrentDelta.changed(element, ICElementDelta.F_CONTENT);
	}

	/**
	* 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>
	*/
	protected void elementRemoved(ICElement element, IResourceDelta delta) {
	if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
	IPath movedToPath = delta.getMovedToPath();
	// create the moved to element
	ICElement movedToElement = createElement(movedToPath);
	if (movedToElement == null) {
	// moved outside
	fCurrentDelta.removed(element);
	} else {
	movedFromElement = element;
	fCurrentDelta.movedFrom(element, movedToElement);
	}
	} else {
	fCurrentDelta.removed(element);
	}
	releaseCElement(element);
	}

	/**
	* Filters the generated <code>CElementDelta</code>s to remove those
	* which should not be fired (because they don't represent a real change
	* in the C Model).
	*/
	protected ICElementDelta[] filterRealDeltas(ICElementDelta[] deltas) {

	int length = deltas.length;
	ICElementDelta[] realDeltas = null;
	int index = 0;
	for (int i = 0; i < length; i++) {
	CElementDelta delta = (CElementDelta)deltas[i];
	if (delta == null) {
	continue;
	}
	if (delta.getAffectedChildren().length > 0
	\|\| delta.getKind() == ICElementDelta.ADDED
	\|\| delta.getKind() == ICElementDelta.REMOVED
	\|\| (delta.getFlags() & ICElementDelta.F_CLOSED) != 0
	\|\| (delta.getFlags() & ICElementDelta.F_OPENED) != 0
	\|\| delta.resourceDeltasCounter > 0) {

	if (realDeltas == null) {
	realDeltas = new ICElementDelta[length];
	}
	realDeltas[index++] = delta;
	}
	}
	if (index > 0) {
	ICElementDelta[] result = new ICElementDelta[index];
	System.arraycopy(realDeltas, 0, result, 0, index);
	return result;
	} else {
	return NO_DELTA;
	}
	}

	/**
	* Returns true if the given resource is contained in an open project
	* with a java nature, otherwise false.
	*/
	protected boolean hasCNature(IResource resource) {
	// ensure the project has a C nature (if open)
	IProject project = resource.getProject();
	if (project.isOpen()) {
	return CoreModel.getDefault().hasCNature(project);
	}
	return false;
	}

	/**
	* Converts a <code>IResourceDelta</code> rooted in a <code>Workspace</code> into
	* the corresponding set of <code>ICElementDelta</code>, rooted in the
	* relevant <code>CModel</code>s.
	*/
	public ICElementDelta[] processResourceDelta(IResourceDelta changes) {

	try {
	ICElement root = (ICModel)CModelManager.getDefault().getCModel();

	/*
	try {
	changes.accept(new IResourceDeltaVisitor() {
	public boolean visit(IResourceDelta delta) {
	switch (delta.getKind()) {
	case IResourceDelta.ADDED :
	// handle added resource
	System.out.print("ADDED ");
	break;
	case IResourceDelta.REMOVED :
	// handle removed resource
	System.out.print("REMOVED ");
	break;
	case IResourceDelta.CHANGED :
	// handle changed resource
	System.out.print("CHANGED ");
	break;
	}
	System.out.println(delta.getResource());
	return true;
	}
	});
	} catch (CoreException e) {
	}
	*/
	// get the workspace delta, and start processing there.
	IResourceDelta[] deltas = changes.getAffectedChildren();
	ICElementDelta[] translatedDeltas = new CElementDelta[deltas.length];
	//System.out.println("delta.length: " + deltas.length);
	for (int i = 0; i < deltas.length; i++) {
	IResourceDelta delta = deltas[i];
	fCurrentDelta = new CElementDelta(root);
	traverseDelta(root, delta); // traverse delta
	translatedDeltas[i] = fCurrentDelta;
	}
	return filterRealDeltas(translatedDeltas);
	} finally {
	}
	}

	/**
	* Converts an <code>IResourceDelta</code> and its children into
	* the corresponding <code>ICElementDelta</code>s.
	* Return whether the delta corresponds to a resource on the classpath.
	* If it is not a resource on the classpath, it will be added as a non-java
	* resource by the sender of this method.
	*/
	protected void traverseDelta(ICElement parent, IResourceDelta delta) {
	try {
	ICElement current = updateCurrentDeltaAndIndex(delta);
	if (current == null) {
	nonCResourcesChanged(parent, delta);
	} else {
	parent = current;
	}
	} catch (CModelException e) {
	}
	IResourceDelta [] children = delta.getAffectedChildren();
	for (int i = 0; i < children.length; i++) {
	traverseDelta(parent, children[i]);
	}
	}

	protected void nonCResourcesChanged(ICElement parent, IResourceDelta delta) {
	CElementDelta elementDelta = fCurrentDelta.find(parent);
	if (elementDelta == null) {
	fCurrentDelta.changed(parent, ICElementDelta.F_CONTENT);
	} else {
	elementDelta.addResourceDelta(delta);
	}
	if (parent instanceof CContainer) {
	// if info not created yet no need to null NonCResources...
	if (CModelManager.getDefault().peekAtInfo(parent) != null) {
	CElementInfo info = ((CContainer)parent).getElementInfo();
	if (info instanceof CContainerInfo) {
	((CContainerInfo)info).setNonCResources(null);
	}
	}
	}
	}

	/*
	* 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 CModelException if the delta doesn't correspond to a c element of the given type.
	*/
	private ICElement updateCurrentDeltaAndIndex(IResourceDelta delta) throws CModelException {

	IResource resource = delta.getResource();
	ICElement element = createElement(resource);

	switch (delta.getKind()) {
	case IResourceDelta.ADDED :
	if (element != null) {
	updateIndexAddResource(element, delta);
	elementAdded(element, delta);
	}
	break;

	case IResourceDelta.REMOVED :
	if (element != null) {
	updateIndexRemoveResource(element, delta);
	elementRemoved(element, delta);
	}
	break;

	case IResourceDelta.CHANGED :
	int flags = delta.getFlags();
	if ((flags & IResourceDelta.CONTENT) != 0) {
	// content has changed
	if (element != null) {
	elementChanged(element, delta);
	updateIndexAddResource(element, delta);
	//check to see if any projects need to be reindexed
	updateDependencies(element);

	}
	} else if (resource.getType() == IResource.PROJECT) {
	if ((flags & IResourceDelta.OPEN) != 0) {
	// project has been opened or closed
	IProject res = (IProject)resource;
	if (element != null) {
	if (res.isOpen()) {
	elementOpened(element, delta);
	updateIndexAddResource(element, delta);
	} else {
	elementClosed(element, delta);
	updateIndexRemoveResource(element, delta);
	}
	}
	} else if ((flags & IResourceDelta.DESCRIPTION) != 0) {
	if (element != null) {
	elementAdded(element, delta);
	}
	} else if (element != null) {
	elementChanged(element, delta);
	}
	} else if (element != null) {
	elementChanged(element, delta);
	}
	break;
	}
	return element;
	}

	protected void updateIndexAddResource(ICElement element, IResourceDelta delta) {

	if (indexManager == null)
	return;

	switch (element.getElementType()) {
	case ICElement.C_PROJECT :
	this.indexManager.indexAll(element.getCProject().getProject());
	break;

	case ICElement.C_UNIT:
	IFile file = (IFile) delta.getResource();
	IProject filesProject = file.getProject();
	indexManager.addSource(file, filesProject.getFullPath());
	break;
	}

	}

	protected void updateIndexRemoveResource(ICElement element, IResourceDelta delta) {

	if (indexManager == null)
	return;

	switch (element.getElementType()) {
	case ICElement.C_PROJECT :
	this.indexManager.removeIndexFamily(element.getCProject().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 c nature is added or removed
	// is done in updateCurrentDeltaAndIndex

	case ICElement.C_UNIT:
	IFile file = (IFile) delta.getResource();
	indexManager.remove(file.getFullPath().toString(), file.getProject().getProject().getFullPath());
	break;
	}


	}

	private void updateDependencies(ICElement element){

	IResource resource = element.getResource();
	if (resource == null)
	return;

	String fileExtension = resource.getFileExtension();

	if ((fileExtension != null) &&
	(isValidHeader(fileExtension))){
	indexManager.updateDependencies(resource);
	}
	}

	private boolean isValidHeader(String fileExtension) {
	String[] supportedTypes = CModelManager.headerExtensions;
	for (int i = 0; i < supportedTypes.length; ++i) {
	if (supportedTypes[i].equals(fileExtension))
	return true;
	}
	return false;
	}
	}