org.eclipse.jdt.core/model/org/eclipse/jdt/core/IJavaElementDelta.java - aspectj/org.aspectj.shadows - Git at Google

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

 import org.eclipse.core.resources.IResourceDelta;
 import org.eclipse.jdt.core.dom.CompilationUnit;

 /**
  * A Java element delta describes changes in Java element between two discrete
  * points in time.  Given a delta, clients can access the element that has
  * changed, and any children that have changed.
  * <p>
  * Deltas have a different status depending on the kind of change they represent.
  * The list below summarizes each status (as returned by {@link #getKind})
  * and its meaning (see individual constants for a more detailled description):
  * <ul>
  * <li>{@link #ADDED} - The element described by the delta has been added.</li>
  * <li>{@link #REMOVED} - The element described by the delta has been removed.</li>
  * <li>{@link #CHANGED} - The element described by the delta has been changed in some way.
  * Specification of the type of change is provided by {@link #getFlags} which returns the following values:
  * <ul>
  * <li>{@link #F_ADDED_TO_CLASSPATH} - A classpath entry corresponding to the element
  * has been added to the project's classpath. This flag is only valid if the element is an
  * {@link IPackageFragmentRoot}.</li>
  * <li>{@link #F_ARCHIVE_CONTENT_CHANGED} - The contents of an archive
  * has changed in some way. This flag is only valid if the element is an {@link IPackageFragmentRoot}
  * which is an archive.</li>
  * <li>{@link #F_CHILDREN} - A child of the element has changed in some way.  This flag
  * is only valid if the element is an {@link IParent}.</li>
  * <li>{@link #F_CLASSPATH_REORDER} - A classpath entry corresponding to the element
  * has changed position in the project's classpath. This flag is only valid if the element is an
  * {@link IPackageFragmentRoot}.</li>
  * <li>{@link #F_CLOSED} - The underlying {@link org.eclipse.core.resources.IProject}
  * has been closed. This flag is only valid if the element is an {@link IJavaProject}.</li>
  * <li>{@link #F_CONTENT} - The contents of the element have been altered.  This flag
  * is only valid for elements which correspond to files.</li>
  *<li>{@link #F_FINE_GRAINED} - The delta is a fine-grained delta, that is, an analysis down
  * to the members level was done to determine if there were structural changes to members of the element.</li>
  * <li>{@link #F_MODIFIERS} - The modifiers on the element have changed in some way.
  * This flag is only valid if the element is an {@link IMember}.</li>
  * <li>{@link #F_OPENED} - The underlying {@link org.eclipse.core.resources.IProject}
  * has been opened. This flag is only valid if the element is an {@link IJavaProject}.</li>
  * <li>{@link #F_REMOVED_FROM_CLASSPATH} - A classpath entry corresponding to the element
  * has been removed from the project's classpath. This flag is only valid if the element is an
  * {@link IPackageFragmentRoot}.</li>
  * <li>{@link #F_SOURCEATTACHED} - The source attachment path or the source attachment root path
  * of a classpath entry corresponding to the element was added. This flag is only valid if the element is an
  * {@link IPackageFragmentRoot}.</li>
  * <li>{@link #F_SOURCEDETACHED} - The source attachment path or the source attachment root path
  * of a classpath entry corresponding to the element was removed. This flag is only valid if the element is an
  * {@link IPackageFragmentRoot}.</li>
  * <li>{@link #F_SUPER_TYPES} - One of the supertypes of an {@link IType} has changed</li>.
  * </ul>
  * </li>
  * </ul>
  * </p>
  * <p>
  * Move operations are indicated by other change flags, layered on top
  * of the change flags described above. If element A is moved to become B,
  * the delta for the  change in A will have status {@link #REMOVED},
  * with change flag {@link #F_MOVED_TO}. In this case,
  * {@link #getMovedToElement} on delta A will return the handle for B.
  * The  delta for B will have status {@link #ADDED}, with change flag
  * {@link #F_MOVED_FROM}, and {@link #getMovedFromElement} on delta
  * B will return the handle for A. (Note, the handle to A in this case represents
  * an element that no longer exists).
  * </p>
  * <p>
  * Note that the move change flags only describe the changes to a single element, they
  * do not imply anything about the parent or children of the element.
  * </p>
  * <p>
  * The {@link #F_ADDED_TO_CLASSPATH}, {@link #F_REMOVED_FROM_CLASSPATH} and
  * {@link #F_CLASSPATH_REORDER} flags are triggered by changes to a project's classpath. They do not mean that
  * the underlying resource was added, removed or changed. For example, if a project P already contains a folder src, then
  * adding a classpath entry with the 'P/src' path to the project's classpath will result in an {@link IJavaElementDelta}
  * with the {@link #F_ADDED_TO_CLASSPATH} flag for the {@link IPackageFragmentRoot} P/src.
  * On the contrary, if a resource is physically added, removed or changed and this resource corresponds to a classpath
  * entry of the project, then an {@link IJavaElementDelta} with the {@link #ADDED},
  * {@link #REMOVED}, or {@link #CHANGED} kind will be fired.
  * </p>
  * <p>
  * Note that when a source attachment path or a source attachment root path is changed, then the flags of the delta contain
  * both {@link #F_SOURCEATTACHED} and {@link #F_SOURCEDETACHED}.
  * </p>
  * <p>
  * No assumptions should be made on whether the java element delta tree is rooted at the {@link IJavaModel}
  * level or not.
  * </p>
  * <p>
  * {@link IJavaElementDelta} object are not valid outside the dynamic scope
  * of the notification.
  * </p>
  *
  * @see IElementChangedListener
  * @see ElementChangedEvent
  * @noimplement This interface is not intended to be implemented by clients.
  */
 public interface IJavaElementDelta {

 	/**
 	 * Status constant indicating that the element has been added.
 	 * Note that an added java element delta has no children, as they are all implicitely added.
 	 */
 	public int ADDED = 1;

 	/**
 	 * Status constant indicating that the element has been removed.
 	 * Note that a removed java element delta has no children, as they are all implicitely removed.
 	 */
 	public int REMOVED = 2;

 	/**
 	 * Status constant indicating that the element has been changed,
 	 * as described by the change flags.
 	 *
 	 * @see #getFlags()
 	 */
 	public int CHANGED = 4;

 	/**
 	 * Change flag indicating that the content of the element has changed.
 	 * This flag is only valid for elements which correspond to files.
 	 */
 	public int F_CONTENT = 0x000001;

 	/**
 	 * Change flag indicating that the modifiers of the element have changed.
 	 * This flag is only valid if the element is an {@link IMember}.
 	 */
 	public int F_MODIFIERS = 0x000002;

 	/**
 	 * Change flag indicating that there are changes to the children of the element.
 	 * This flag is only valid if the element is an {@link IParent}.
 	 */
 	public int F_CHILDREN = 0x000008;

 	/**
 	 * Change flag indicating that the element was moved from another location.
 	 * The location of the old element can be retrieved using {@link #getMovedFromElement}.
 	 */
 	public int F_MOVED_FROM = 0x000010;

 	/**
 	 * Change flag indicating that the element was moved to another location.
 	 * The location of the new element can be retrieved using {@link #getMovedToElement}.
 	 */
 	public int F_MOVED_TO = 0x000020;

 	/**
 	 * Change flag indicating that a classpath entry corresponding to the element has been added to the project's classpath.
 	 * This flag is only valid if the element is an {@link IPackageFragmentRoot}.
 	 */
 	public int F_ADDED_TO_CLASSPATH = 0x000040;

 	/**
 	 * Change flag indicating that a classpath entry corresponding to the element has been removed from the project's
 	 * classpath. This flag is only valid if the element is an {@link IPackageFragmentRoot}.
 	 */
 	public int F_REMOVED_FROM_CLASSPATH = 0x000080;

 	/**
 	 * Change flag indicating that a classpath entry corresponding to the element has changed position in the project's
 	 * classpath. This flag is only valid if the element is an {@link IPackageFragmentRoot}.
 	 * @deprecated Use {@link #F_REORDER} instead.
 	 */
 	public int F_CLASSPATH_REORDER = 0x000100;
 	/**
 	 * Change flag indicating that the element has changed position relatively to its siblings.
 	 * If the element is an {@link IPackageFragmentRoot},  a classpath entry corresponding
 	 * to the element has changed position in the project's classpath.
 	 *
 	 * @since 2.1
 	 */
 	public int F_REORDER = 0x000100;

 	/**
 	 * Change flag indicating that the underlying {@link org.eclipse.core.resources.IProject} has been
 	 * opened. This flag is only valid if the element is an {@link IJavaProject}.
 	 */
 	public int F_OPENED = 0x000200;

 	/**
 	 * Change flag indicating that the underlying {@link org.eclipse.core.resources.IProject} has been
 	 * closed. This flag is only valid if the element is an {@link IJavaProject}.
 	 */
 	public int F_CLOSED = 0x000400;

 	/**
 	 * Change flag indicating that one of the supertypes of an {@link IType}
 	 * has changed.
 	 */
 	public int F_SUPER_TYPES = 0x000800;

 	/**
 	 * Change flag indicating that the source attachment path or the source attachment root path of a classpath entry
 	 * corresponding to the element was added. This flag is only valid if the element is an
 	 * {@link IPackageFragmentRoot}.
 	 */
 	public int F_SOURCEATTACHED = 0x001000;

 	/**
 	 * Change flag indicating that the source attachment path or the source attachment root path of a classpath entry
 	 * corresponding to the element was removed. This flag is only valid if the element is an
 	 * {@link IPackageFragmentRoot}.
 	 */
 	public int F_SOURCEDETACHED = 0x002000;

 	/**
 	 * Change flag indicating that this is a fine-grained delta, that is, an analysis down
 	 * to the members level was done to determine if there were structural changes to
 	 * members.
 	 * <p>
 	 * Clients can use this flag to find out if a compilation unit
      * that have a {@link #F_CONTENT} change should assume that there are
      * no finer grained changes ({@link #F_FINE_GRAINED} is set) or if
      * finer grained changes were not considered ({@link #F_FINE_GRAINED}
      * is not set).
      *
      * @since 2.0
 	 */
 	public int F_FINE_GRAINED = 0x004000;

 	/**
 	 * Change flag indicating that the element's archive content on the classpath has changed.
 	 * This flag is only valid if the element is an {@link IPackageFragmentRoot}
 	 * which is an archive.
 	 *
 	 * @see IPackageFragmentRoot#isArchive()
 	 * @since 2.0
 	 */
 	public int F_ARCHIVE_CONTENT_CHANGED = 0x008000;

 	/**
 	 * Change flag indicating that a compilation unit has become a primary working copy, or that a
 	 * primary working copy has reverted to a compilation unit.
 	 * This flag is only valid if the element is an {@link ICompilationUnit}.
 	 *
 	 * @since 3.0
 	 */
 	public int F_PRIMARY_WORKING_COPY = 0x010000;

 	/**
 	 * Change flag indicating that the {@link IJavaProject#getRawClasspath() raw classpath}
 	 * (or the {@link IJavaProject#getOutputLocation() output folder}) of a project has changed.
 	 * This flag is only valid if the element is an {@link IJavaProject}.
 	 * Also see {@link #F_RESOLVED_CLASSPATH_CHANGED}, which indicates that there is a
 	 * change to the {@link IJavaProject#getResolvedClasspath(boolean) resolved class path}.
 	 * The resolved classpath can change without the raw classpath changing (e.g.
 	 * if a container resolves to a different set of classpath entries).
 	 * And conversely, it is possible to construct a case where the raw classpath
 	 * can change without the resolved classpath changing.
 	 *
 	 * @since 3.0
 	 */
 	public int F_CLASSPATH_CHANGED = 0x020000;

 	/**
 	 * Change flag indicating that the resource of a primary compilation unit has changed.
 	 * This flag is only valid if the element is a primary {@link ICompilationUnit}.
 	 *
 	 * @since 3.0
 	 */
 	public int F_PRIMARY_RESOURCE = 0x040000;

 	/**
 	 * Change flag indicating that a reconcile operation has affected the compilation unit AST created in a
 	 * previous reconcile operation. Use {@link #getCompilationUnitAST()} to retrieve the AST (if any is available).
 	 * This flag is only valid if the element is an {@link ICompilationUnit} in working copy mode.
 	 *
 	 * @since 3.2
 	 */
 	public int F_AST_AFFECTED = 0x080000;

 	/**
 	 * Change flag indicating that the categories of the element have changed.
 	 * This flag is only valid if the element is an {@link IMember}.
 	 *
 	 * @since 3.2
 	 */
 	public int F_CATEGORIES = 0x100000;

 	/**
 	 * Change flag indicating that the {@link IJavaProject#getResolvedClasspath(boolean)
 	 * resolved classpath} of a project has changed.
 	 * This flag is only valid if the element is an {@link IJavaProject}.
 	 * Also see {@link #F_CLASSPATH_CHANGED}, which indicates that there is a
 	 * change to the {@link IJavaProject#getRawClasspath() raw class path}.
 	 * The resolved classpath can change without the raw classpath changing (e.g.
 	 * if a container resolves to a different set of classpath entries).
 	 * And conversely, it is possible to construct a case where the raw classpath
 	 * can change without the resolved classpath changing.
 	 *
 	 * @since 3.4
 	 */
 	public int F_RESOLVED_CLASSPATH_CHANGED = 0x200000;

 	/**
 	 * Change flag indicating that the annotations of the element have changed.
 	 * Use {@link #getAnnotationDeltas()} to get the added/removed/changed annotations.
 	 * This flag is only valid if the element is an {@link IAnnotatable}.
 	 *
 	 * @since 3.4
 	 */
 	public int F_ANNOTATIONS = 0x400000;

 	/**
 	 * Returns deltas for the children that have been added.
 	 * @return deltas for the children that have been added
 	 */
 	public IJavaElementDelta[] getAddedChildren();

 	/**
 	 * Returns deltas for the affected (added, removed, or changed) children.
 	 * @return deltas for the affected (added, removed, or changed) children
 	 */
 	public IJavaElementDelta[] getAffectedChildren();

 	/**
 	 * Returns deltas for affected annotations (added, removed, or changed).
 	 * Returns an empty array if no annotations was affected, or if this delta's element is not
 	 * an {@link IAnnotatable}.
 	 *
 	 * @return deltas for affected annotations (added, removed, or changed)
 	 *
 	 * @since 3.4
 	 */
 	public IJavaElementDelta[] getAnnotationDeltas();

 	/**
 	 * Returns the compilation unit AST created by the last reconcile operation on this delta's element.
 	 * This returns a non-null value if and only if:
 	 * <ul>
 	 * <li>the last reconcile operation on this working copy requested an AST</li>
 	 * <li>this delta's element is an {@link ICompilationUnit} in working copy mode</li>
 	 * <li>the delta comes from a {@link ElementChangedEvent#POST_RECONCILE} event
 	 * </ul>
 	 *
 	 * @return the AST created during the last reconcile operation
 	 * @see ICompilationUnit#reconcile(int, boolean, WorkingCopyOwner, org.eclipse.core.runtime.IProgressMonitor)
 	 * @see #F_AST_AFFECTED
 	 * @since 3.2
 	 */
 	public CompilationUnit getCompilationUnitAST();

 	/**
 	 * Returns deltas for the children which have changed.
 	 * @return deltas for the children which have changed
 	 */
 	public IJavaElementDelta[] getChangedChildren();

 	/**
 	 * Returns the element that this delta describes a change to.
 	 * @return the element that this delta describes a change to
 	 */
 	public IJavaElement getElement();

 	/**
 	 * Returns flags that describe how an element has changed.
 	 * Such flags should be tested using the <code>&</code> operand. For example:
 	 * <pre>
 	 * if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) != 0) {
 	 * 	// the delta indicates a content change
 	 * }
 	 * </pre>
 	 *
 	 * @return flags that describe how an element has changed
 	 */
 	public int getFlags();

 	/**
 	 * Returns the kind of this delta - one of {@link #ADDED}, {@link #REMOVED},
 	 * or {@link #CHANGED}.
 	 *
 	 * @return the kind of this delta
 	 */
 	public int getKind();

 	/**
 	 * Returns an element describing this element before it was moved
 	 * to its current location, or <code>null</code> if the
 	 * {@link #F_MOVED_FROM} change flag is not set.
 	 *
 	 * @return an element describing this element before it was moved
 	 * to its current location, or <code>null</code> if the
 	 * {@link #F_MOVED_FROM} change flag is not set
 	 */
 	public IJavaElement getMovedFromElement();

 	/**
 	 * Returns an element describing this element in its new location,
 	 * or <code>null</code> if the {@link #F_MOVED_TO} change
 	 * flag is not set.
 	 *
 	 * @return an element describing this element in its new location,
 	 * or <code>null</code> if the {@link #F_MOVED_TO} change
 	 * flag is not set
 	 */
 	public IJavaElement getMovedToElement();

 	/**
 	 * Returns deltas for the children which have been removed.
 	 *
 	 * @return deltas for the children which have been removed
 	 */
 	public IJavaElementDelta[] getRemovedChildren();

 	/**
 	 * Returns the collection of resource deltas.
 	 * <p>
 	 * Note that resource deltas, like Java element deltas, are generally only valid
 	 * for the dynamic scope of an event notification. Clients must not hang on to
 	 * these objects.
 	 * </p>
 	 *
 	 * @return the underlying resource deltas, or <code>null</code> if none
 	 */
 	public IResourceDelta[] getResourceDeltas();
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2011 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.core;

	import org.eclipse.core.resources.IResourceDelta;
	import org.eclipse.jdt.core.dom.CompilationUnit;

	/**
	* A Java element delta describes changes in Java element between two discrete
	* points in time. Given a delta, clients can access the element that has
	* changed, and any children that have changed.
	* <p>
	* Deltas have a different status depending on the kind of change they represent.
	* The list below summarizes each status (as returned by {@link #getKind})
	* and its meaning (see individual constants for a more detailled description):
	* <ul>
	* <li>{@link #ADDED} - The element described by the delta has been added.</li>
	* <li>{@link #REMOVED} - The element described by the delta has been removed.</li>
	* <li>{@link #CHANGED} - The element described by the delta has been changed in some way.
	* Specification of the type of change is provided by {@link #getFlags} which returns the following values:
	* <ul>
	* <li>{@link #F_ADDED_TO_CLASSPATH} - A classpath entry corresponding to the element
	* has been added to the project's classpath. This flag is only valid if the element is an
	* {@link IPackageFragmentRoot}.</li>
	* <li>{@link #F_ARCHIVE_CONTENT_CHANGED} - The contents of an archive
	* has changed in some way. This flag is only valid if the element is an {@link IPackageFragmentRoot}
	* which is an archive.</li>
	* <li>{@link #F_CHILDREN} - A child of the element has changed in some way. This flag
	* is only valid if the element is an {@link IParent}.</li>
	* <li>{@link #F_CLASSPATH_REORDER} - A classpath entry corresponding to the element
	* has changed position in the project's classpath. This flag is only valid if the element is an
	* {@link IPackageFragmentRoot}.</li>
	* <li>{@link #F_CLOSED} - The underlying {@link org.eclipse.core.resources.IProject}
	* has been closed. This flag is only valid if the element is an {@link IJavaProject}.</li>
	* <li>{@link #F_CONTENT} - The contents of the element have been altered. This flag
	* is only valid for elements which correspond to files.</li>
	*<li>{@link #F_FINE_GRAINED} - The delta is a fine-grained delta, that is, an analysis down
	* to the members level was done to determine if there were structural changes to members of the element.</li>
	* <li>{@link #F_MODIFIERS} - The modifiers on the element have changed in some way.
	* This flag is only valid if the element is an {@link IMember}.</li>
	* <li>{@link #F_OPENED} - The underlying {@link org.eclipse.core.resources.IProject}
	* has been opened. This flag is only valid if the element is an {@link IJavaProject}.</li>
	* <li>{@link #F_REMOVED_FROM_CLASSPATH} - A classpath entry corresponding to the element
	* has been removed from the project's classpath. This flag is only valid if the element is an
	* {@link IPackageFragmentRoot}.</li>
	* <li>{@link #F_SOURCEATTACHED} - The source attachment path or the source attachment root path
	* of a classpath entry corresponding to the element was added. This flag is only valid if the element is an
	* {@link IPackageFragmentRoot}.</li>
	* <li>{@link #F_SOURCEDETACHED} - The source attachment path or the source attachment root path
	* of a classpath entry corresponding to the element was removed. This flag is only valid if the element is an
	* {@link IPackageFragmentRoot}.</li>
	* <li>{@link #F_SUPER_TYPES} - One of the supertypes of an {@link IType} has changed</li>.
	* </ul>
	* </li>
	* </ul>
	* </p>
	* <p>
	* Move operations are indicated by other change flags, layered on top
	* of the change flags described above. If element A is moved to become B,
	* the delta for the change in A will have status {@link #REMOVED},
	* with change flag {@link #F_MOVED_TO}. In this case,
	* {@link #getMovedToElement} on delta A will return the handle for B.
	* The delta for B will have status {@link #ADDED}, with change flag
	* {@link #F_MOVED_FROM}, and {@link #getMovedFromElement} on delta
	* B will return the handle for A. (Note, the handle to A in this case represents
	* an element that no longer exists).
	* </p>
	* <p>
	* Note that the move change flags only describe the changes to a single element, they
	* do not imply anything about the parent or children of the element.
	* </p>
	* <p>
	* The {@link #F_ADDED_TO_CLASSPATH}, {@link #F_REMOVED_FROM_CLASSPATH} and
	* {@link #F_CLASSPATH_REORDER} flags are triggered by changes to a project's classpath. They do not mean that
	* the underlying resource was added, removed or changed. For example, if a project P already contains a folder src, then
	* adding a classpath entry with the 'P/src' path to the project's classpath will result in an {@link IJavaElementDelta}
	* with the {@link #F_ADDED_TO_CLASSPATH} flag for the {@link IPackageFragmentRoot} P/src.
	* On the contrary, if a resource is physically added, removed or changed and this resource corresponds to a classpath
	* entry of the project, then an {@link IJavaElementDelta} with the {@link #ADDED},
	* {@link #REMOVED}, or {@link #CHANGED} kind will be fired.
	* </p>
	* <p>
	* Note that when a source attachment path or a source attachment root path is changed, then the flags of the delta contain
	* both {@link #F_SOURCEATTACHED} and {@link #F_SOURCEDETACHED}.
	* </p>
	* <p>
	* No assumptions should be made on whether the java element delta tree is rooted at the {@link IJavaModel}
	* level or not.
	* </p>
	* <p>
	* {@link IJavaElementDelta} object are not valid outside the dynamic scope
	* of the notification.
	* </p>
	*
	* @see IElementChangedListener
	* @see ElementChangedEvent
	* @noimplement This interface is not intended to be implemented by clients.
	*/
	public interface IJavaElementDelta {

	/**
	* Status constant indicating that the element has been added.
	* Note that an added java element delta has no children, as they are all implicitely added.
	*/
	public int ADDED = 1;

	/**
	* Status constant indicating that the element has been removed.
	* Note that a removed java element delta has no children, as they are all implicitely removed.
	*/
	public int REMOVED = 2;

	/**
	* Status constant indicating that the element has been changed,
	* as described by the change flags.
	*
	* @see #getFlags()
	*/
	public int CHANGED = 4;

	/**
	* Change flag indicating that the content of the element has changed.
	* This flag is only valid for elements which correspond to files.
	*/
	public int F_CONTENT = 0x000001;

	/**
	* Change flag indicating that the modifiers of the element have changed.
	* This flag is only valid if the element is an {@link IMember}.
	*/
	public int F_MODIFIERS = 0x000002;

	/**
	* Change flag indicating that there are changes to the children of the element.
	* This flag is only valid if the element is an {@link IParent}.
	*/
	public int F_CHILDREN = 0x000008;

	/**
	* Change flag indicating that the element was moved from another location.
	* The location of the old element can be retrieved using {@link #getMovedFromElement}.
	*/
	public int F_MOVED_FROM = 0x000010;

	/**
	* Change flag indicating that the element was moved to another location.
	* The location of the new element can be retrieved using {@link #getMovedToElement}.
	*/
	public int F_MOVED_TO = 0x000020;

	/**
	* Change flag indicating that a classpath entry corresponding to the element has been added to the project's classpath.
	* This flag is only valid if the element is an {@link IPackageFragmentRoot}.
	*/
	public int F_ADDED_TO_CLASSPATH = 0x000040;

	/**
	* Change flag indicating that a classpath entry corresponding to the element has been removed from the project's
	* classpath. This flag is only valid if the element is an {@link IPackageFragmentRoot}.
	*/
	public int F_REMOVED_FROM_CLASSPATH = 0x000080;

	/**
	* Change flag indicating that a classpath entry corresponding to the element has changed position in the project's
	* classpath. This flag is only valid if the element is an {@link IPackageFragmentRoot}.
	* @deprecated Use {@link #F_REORDER} instead.
	*/
	public int F_CLASSPATH_REORDER = 0x000100;
	/**
	* Change flag indicating that the element has changed position relatively to its siblings.
	* If the element is an {@link IPackageFragmentRoot}, a classpath entry corresponding
	* to the element has changed position in the project's classpath.
	*
	* @since 2.1
	*/
	public int F_REORDER = 0x000100;

	/**
	* Change flag indicating that the underlying {@link org.eclipse.core.resources.IProject} has been
	* opened. This flag is only valid if the element is an {@link IJavaProject}.
	*/
	public int F_OPENED = 0x000200;

	/**
	* Change flag indicating that the underlying {@link org.eclipse.core.resources.IProject} has been
	* closed. This flag is only valid if the element is an {@link IJavaProject}.
	*/
	public int F_CLOSED = 0x000400;

	/**
	* Change flag indicating that one of the supertypes of an {@link IType}
	* has changed.
	*/
	public int F_SUPER_TYPES = 0x000800;

	/**
	* Change flag indicating that the source attachment path or the source attachment root path of a classpath entry
	* corresponding to the element was added. This flag is only valid if the element is an
	* {@link IPackageFragmentRoot}.
	*/
	public int F_SOURCEATTACHED = 0x001000;

	/**
	* Change flag indicating that the source attachment path or the source attachment root path of a classpath entry
	* corresponding to the element was removed. This flag is only valid if the element is an
	* {@link IPackageFragmentRoot}.
	*/
	public int F_SOURCEDETACHED = 0x002000;

	/**
	* Change flag indicating that this is a fine-grained delta, that is, an analysis down
	* to the members level was done to determine if there were structural changes to
	* members.
	* <p>
	* Clients can use this flag to find out if a compilation unit
	* that have a {@link #F_CONTENT} change should assume that there are
	* no finer grained changes ({@link #F_FINE_GRAINED} is set) or if
	* finer grained changes were not considered ({@link #F_FINE_GRAINED}
	* is not set).
	*
	* @since 2.0
	*/
	public int F_FINE_GRAINED = 0x004000;

	/**
	* Change flag indicating that the element's archive content on the classpath has changed.
	* This flag is only valid if the element is an {@link IPackageFragmentRoot}
	* which is an archive.
	*
	* @see IPackageFragmentRoot#isArchive()
	* @since 2.0
	*/
	public int F_ARCHIVE_CONTENT_CHANGED = 0x008000;

	/**
	* Change flag indicating that a compilation unit has become a primary working copy, or that a
	* primary working copy has reverted to a compilation unit.
	* This flag is only valid if the element is an {@link ICompilationUnit}.
	*
	* @since 3.0
	*/
	public int F_PRIMARY_WORKING_COPY = 0x010000;

	/**
	* Change flag indicating that the {@link IJavaProject#getRawClasspath() raw classpath}
	* (or the {@link IJavaProject#getOutputLocation() output folder}) of a project has changed.
	* This flag is only valid if the element is an {@link IJavaProject}.
	* Also see {@link #F_RESOLVED_CLASSPATH_CHANGED}, which indicates that there is a
	* change to the {@link IJavaProject#getResolvedClasspath(boolean) resolved class path}.
	* The resolved classpath can change without the raw classpath changing (e.g.
	* if a container resolves to a different set of classpath entries).
	* And conversely, it is possible to construct a case where the raw classpath
	* can change without the resolved classpath changing.
	*
	* @since 3.0
	*/
	public int F_CLASSPATH_CHANGED = 0x020000;

	/**
	* Change flag indicating that the resource of a primary compilation unit has changed.
	* This flag is only valid if the element is a primary {@link ICompilationUnit}.
	*
	* @since 3.0
	*/
	public int F_PRIMARY_RESOURCE = 0x040000;

	/**
	* Change flag indicating that a reconcile operation has affected the compilation unit AST created in a
	* previous reconcile operation. Use {@link #getCompilationUnitAST()} to retrieve the AST (if any is available).
	* This flag is only valid if the element is an {@link ICompilationUnit} in working copy mode.
	*
	* @since 3.2
	*/
	public int F_AST_AFFECTED = 0x080000;

	/**
	* Change flag indicating that the categories of the element have changed.
	* This flag is only valid if the element is an {@link IMember}.
	*
	* @since 3.2
	*/
	public int F_CATEGORIES = 0x100000;

	/**
	* Change flag indicating that the {@link IJavaProject#getResolvedClasspath(boolean)
	* resolved classpath} of a project has changed.
	* This flag is only valid if the element is an {@link IJavaProject}.
	* Also see {@link #F_CLASSPATH_CHANGED}, which indicates that there is a
	* change to the {@link IJavaProject#getRawClasspath() raw class path}.
	* The resolved classpath can change without the raw classpath changing (e.g.
	* if a container resolves to a different set of classpath entries).
	* And conversely, it is possible to construct a case where the raw classpath
	* can change without the resolved classpath changing.
	*
	* @since 3.4
	*/
	public int F_RESOLVED_CLASSPATH_CHANGED = 0x200000;

	/**
	* Change flag indicating that the annotations of the element have changed.
	* Use {@link #getAnnotationDeltas()} to get the added/removed/changed annotations.
	* This flag is only valid if the element is an {@link IAnnotatable}.
	*
	* @since 3.4
	*/
	public int F_ANNOTATIONS = 0x400000;

	/**
	* Returns deltas for the children that have been added.
	* @return deltas for the children that have been added
	*/
	public IJavaElementDelta[] getAddedChildren();

	/**
	* Returns deltas for the affected (added, removed, or changed) children.
	* @return deltas for the affected (added, removed, or changed) children
	*/
	public IJavaElementDelta[] getAffectedChildren();

	/**
	* Returns deltas for affected annotations (added, removed, or changed).
	* Returns an empty array if no annotations was affected, or if this delta's element is not
	* an {@link IAnnotatable}.
	*
	* @return deltas for affected annotations (added, removed, or changed)
	*
	* @since 3.4
	*/
	public IJavaElementDelta[] getAnnotationDeltas();

	/**
	* Returns the compilation unit AST created by the last reconcile operation on this delta's element.
	* This returns a non-null value if and only if:
	* <ul>
	* <li>the last reconcile operation on this working copy requested an AST</li>
	* <li>this delta's element is an {@link ICompilationUnit} in working copy mode</li>
	* <li>the delta comes from a {@link ElementChangedEvent#POST_RECONCILE} event
	* </ul>
	*
	* @return the AST created during the last reconcile operation
	* @see ICompilationUnit#reconcile(int, boolean, WorkingCopyOwner, org.eclipse.core.runtime.IProgressMonitor)
	* @see #F_AST_AFFECTED
	* @since 3.2
	*/
	public CompilationUnit getCompilationUnitAST();

	/**
	* Returns deltas for the children which have changed.
	* @return deltas for the children which have changed
	*/
	public IJavaElementDelta[] getChangedChildren();

	/**
	* Returns the element that this delta describes a change to.
	* @return the element that this delta describes a change to
	*/
	public IJavaElement getElement();

	/**
	* Returns flags that describe how an element has changed.
	* Such flags should be tested using the <code>&</code> operand. For example:
	* <pre>
	* if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) != 0) {
	* // the delta indicates a content change
	* }
	* </pre>
	*
	* @return flags that describe how an element has changed
	*/
	public int getFlags();

	/**
	* Returns the kind of this delta - one of {@link #ADDED}, {@link #REMOVED},
	* or {@link #CHANGED}.
	*
	* @return the kind of this delta
	*/
	public int getKind();

	/**
	* Returns an element describing this element before it was moved
	* to its current location, or <code>null</code> if the
	* {@link #F_MOVED_FROM} change flag is not set.
	*
	* @return an element describing this element before it was moved
	* to its current location, or <code>null</code> if the
	* {@link #F_MOVED_FROM} change flag is not set
	*/
	public IJavaElement getMovedFromElement();

	/**
	* Returns an element describing this element in its new location,
	* or <code>null</code> if the {@link #F_MOVED_TO} change
	* flag is not set.
	*
	* @return an element describing this element in its new location,
	* or <code>null</code> if the {@link #F_MOVED_TO} change
	* flag is not set
	*/
	public IJavaElement getMovedToElement();

	/**
	* Returns deltas for the children which have been removed.
	*
	* @return deltas for the children which have been removed
	*/
	public IJavaElementDelta[] getRemovedChildren();

	/**
	* Returns the collection of resource deltas.
	* <p>
	* Note that resource deltas, like Java element deltas, are generally only valid
	* for the dynamic scope of an event notification. Clients must not hang on to
	* these objects.
	* </p>
	*
	* @return the underlying resource deltas, or <code>null</code> if none
	*/
	public IResourceDelta[] getResourceDeltas();
	}