org.eclipse.jdt/org.eclipse.jdt.core/3.20.0 : org/eclipse/jdt/core/IJavaElementDelta.java

IJavaElementDelta
http://www.eclipse.org/jdt: Java Development Tools Core (Eclipse Foundation)
Eclipse Public License - v 2.0
Copyright (c) 2000, 2019 IBM Corporation and others.
This program and the accompanying materials
are made available under the terms of the Eclipse Public License 2.0
which accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
Contributors:
    IBM Corporation - initial API and implementation
/*******************************************************************************
 * Copyright (c) 2000, 2019 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * 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.
 Deltas have a different status depending on the kind of change they represent. The list below summarizes each status (as returned by getKind) and its meaning (see individual constants for a more detailed description): 

ADDED - The element described by the delta has been added.
REMOVED - The element described by the delta has been removed.
CHANGED - The element described by the delta has been changed in some way. Specification of the type of change is provided by getFlags which returns the following values: 
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 IPackageFragmentRoot.
F_ARCHIVE_CONTENT_CHANGED - The contents of an archive has changed in some way. This flag is only valid if the element is an IPackageFragmentRoot which is an archive.
F_CHILDREN - A child of the element has changed in some way. This flag is only valid if the element is an IParent.
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 IPackageFragmentRoot.
F_CLOSED - The underlying IProject has been closed. This flag is only valid if the element is an IJavaProject.
F_CONTENT - The contents of the element have been altered. This flag is only valid for elements which correspond to files.
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.
F_MODIFIERS - The modifiers on the element have changed in some way. This flag is only valid if the element is an IMember.
F_OPENED - The underlying IProject has been opened. This flag is only valid if the element is an IJavaProject.
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 IPackageFragmentRoot.
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 IPackageFragmentRoot.
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 IPackageFragmentRoot.
F_SUPER_TYPES - One of the supertypes of an IType has changed.



 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 REMOVED, with change flag F_MOVED_TO. In this case, getMovedToElement on delta A will return the handle for B. The delta for B will have status ADDED, with change flag F_MOVED_FROM, and 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). 

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.

 The F_ADDED_TO_CLASSPATH, F_REMOVED_FROM_CLASSPATH and 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 IJavaElementDelta with the F_ADDED_TO_CLASSPATH flag for the 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 IJavaElementDelta with the ADDED, REMOVED, or CHANGED kind will be fired. 
 Note that when a source attachment path or a source attachment root path is changed, then the flags of the delta contain both F_SOURCEATTACHED and F_SOURCEDETACHED. 
 No assumptions should be made on whether the java element delta tree is rooted at the IJavaModel level or not. 
 IJavaElementDelta object are not valid outside the dynamic scope of the notification. 
See Also: IElementChangedListener
ElementChangedEvent
@noimplement This interface is not intended to be implemented by clients./**
 * 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 detailed 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>
 * 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.
/**
	 * 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.
/**
	 * 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 Also: getFlags()/**
	 * 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.
/**
	 * 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 IMember. /**
	 * 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 IParent. /**
	 * 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 getMovedFromElement. /**
	 * 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 getMovedToElement. /**
	 * 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 IPackageFragmentRoot. /**
	 * 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 IPackageFragmentRoot. /**
	 * 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 IPackageFragmentRoot. 
Deprecated: Use F_REORDER instead./**
	 * 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 IPackageFragmentRoot, a classpath entry corresponding to the element has changed position in the project's classpath. 
Since: 2.1/**
	 * 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 IProject has been opened. This flag is only valid if the element is an IJavaProject. /**
	 * 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 IProject has been closed. This flag is only valid if the element is an IJavaProject. /**
	 * 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 IType has changed. /**
	 * 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 IPackageFragmentRoot. /**
	 * 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 IPackageFragmentRoot. /**
	 * 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.
 Clients can use this flag to find out if a compilation unit that have a F_CONTENT change should assume that there are no finer grained changes (F_FINE_GRAINED is set) or if finer grained changes were not considered (F_FINE_GRAINED is not set). 
Since: 2.0/**
	 * 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 IPackageFragmentRoot which is an archive. 
See Also: IPackageFragmentRoot.isArchive()
Since: 2.0/**
	 * 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 ICompilationUnit. 
Since: 3.0/**
	 * 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 raw classpath (or the output folder) of a project has changed. This flag is only valid if the element is an IJavaProject. Also see F_RESOLVED_CLASSPATH_CHANGED, which indicates that there is a change to the 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/**
	 * 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 ICompilationUnit. 
Since: 3.0/**
	 * 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 getCompilationUnitAST() to retrieve the AST (if any is available). This flag is only valid if the element is an ICompilationUnit in working copy mode. 
Since: 3.2/**
	 * 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 IMember. 
Since: 3.2/**
	 * 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 
resolved classpath of a project has changed. This flag is only valid if the element is an IJavaProject. Also see F_CLASSPATH_CHANGED, which indicates that there is a change to the 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/**
	 * 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 getAnnotationDeltas() to get the added/removed/changed annotations. This flag is only valid if the element is an IAnnotatable. 
Since: 3.4/**
	 * 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.
Returns: deltas for the children that have been added/**
	 * 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.
Returns: deltas for the affected (added, removed, or changed) children/**
	 * 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 IAnnotatable. 
Returns: deltas for affected annotations (added, removed, or changed)
Since: 3.4/**
	 * 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:

the last reconcile operation on this working copy requested an AST
this delta's element is an ICompilationUnit in working copy mode
the delta comes from a ElementChangedEvent.POST_RECONCILE event 
See Also: ICompilationUnit.reconcile(int, boolean, WorkingCopyOwner, IProgressMonitor)
F_AST_AFFECTED
Returns: the AST created during the last reconcile operation
Since: 3.2/**
	 * 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.
Returns: deltas for the children which have changed/**
	 * 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.
Returns: the element that this delta describes a change to/**
	 * 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 & operand. For example:
if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) != 0) {
	// the delta indicates a content change
}

Returns: flags that describe how an element has changed/**
	 * Returns flags that describe how an element has changed.
	 * Such flags should be tested using the <code>&amp;</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 ADDED, REMOVED, or CHANGED. 
Returns: the kind of this delta/**
	 * 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 null if the F_MOVED_FROM change flag is not set. 
Returns: an element describing this element before it was moved
to its current location, or null if the F_MOVED_FROM change flag is not set/**
	 * 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 null if the F_MOVED_TO change flag is not set. 
Returns: an element describing this element in its new location,
or null if the F_MOVED_TO change flag is not set/**
	 * 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.
Returns: deltas for the children which have been removed/**
	 * 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.

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.

Returns: the underlying resource deltas, or null if none/**
	 * 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();
}
See Also:	IElementChangedListener ElementChangedEvent
@noimplement	This interface is not intended to be implemented by clients.
Returns:	deltas for affected annotations (added, removed, or changed)
Since:	3.4
See Also:	ICompilationUnit.reconcile(int, boolean, WorkingCopyOwner, IProgressMonitor) F_AST_AFFECTED
Returns:	the AST created during the last reconcile operation
Since:	3.2
/

org.eclipse.jdt/ org.eclipse.jdt.core/ 3.20.0/ org/eclipse/jdt/core/IJavaElementDelta.java
