Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse JDT Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.eclipse.ltk.core.refactoring
Class NullChange

    java.lang.Object
      org.eclipse.ltk.core.refactoring.Change
          org.eclipse.ltk.core.refactoring.NullChange

All Implemented Interfaces:
  IAdaptable

public class NullChange
extends Change

A refactoring change that does nothing. The reverse change of a `NullChange` is a `NullChange`.

Note: this class is not intended to be extended by clients.

Since:
  3.0

Constructor Summary
`NullChange()` Creates a new `NullChange` with a default name.
`NullChange(String name)` Creates a new `NullChange` with the given name.

Method Summary
`Object` | `getModifiedElement()` Returns the element modified by this `Change`. The method may return `null` if the change isn't related to an element.
`String` | `getName()` Returns the human readable name of this change. The name MUST not be `null`.
`void` | `initializeValidationData(IProgressMonitor pm)` Hook method to initialize some internal state to provide an adequate answer for the `isValid` method. This method gets called after a change or a whole change tree has been created. Typically this method is implemented in one of the following ways: the change hooks up a listener on some delta notification mechanism and marks itself as invalid if it receives a certain delta. Is this the case the implementor must take care of unhooking the listener in `dispose`. the change remembers some information allowing to decide if a change object is still valid when `isValid` is called. For example, a change object that manipulates the content of an `IFile` could either listen to resource changes and detect that the file got changed or it could remember some content stamp and compare it with the actual content stamp when `isValid` is called.
`RefactoringStatus` | `isValid(IProgressMonitor pm)` Verifies that this change object is still valid and can be executed by calling `perform`. If a refactoring status with a severity of `RefactoringStatus.FATAL` is returned then the change has to be treated as invalid and can no longer be executed. Performing such a change produces an unspecified result and will very likely throw an exception. This method is also called by the `UndoManager` to decide if an undo or redo change is still valid and therefore can be executed.
`Change` | `perform(IProgressMonitor pm)` Performs this change. If this method is call on an invalid or disabled change object the result is unspecified. Changes should in general not respond to `IProgressMonitor.isCanceled()` since canceling a change tree in the middle of its execution leaves the workspace in a half changed state.

Methods inherited from class org.eclipse.ltk.core.refactoring.Change
`dispose, getAdapter, getParent, isEnabled, setEnabled`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### NullChange

    public NullChange()

  Creates a new `NullChange` with a default name.

### NullChange

    public NullChange(String name)

  Creates a new `NullChange` with the given name.

Parameters:
  `name` - the human readable name of this change

Method Detail

### getName

    public String getName()

  Returns the human readable name of this change. The name MUST not be `null`.

  Specified by:
    `getName` in class `Change`
  Returns:
    the human readable name of this change

### initializeValidationData

    public void initializeValidationData(IProgressMonitor pm)

  Hook method to initialize some internal state to provide an adequate answer for the `isValid` method. This method gets called after a change or a whole change tree has been created.

  Typically this method is implemented in one of the following ways:

  - the change hooks up a listener on some delta notification mechanism and marks itself as invalid if it receives a certain delta. Is this the case the implementor must take care of unhooking the listener in `dispose`.
  - the change remembers some information allowing to decide if a change object is still valid when `isValid` is called.

  For example, a change object that manipulates the content of an `IFile` could either listen to resource changes and detect that the file got changed or it could remember some content stamp and compare it with the actual content stamp when `isValid` is called.

  Specified by:
    `initializeValidationData` in class `Change`
  Parameters:
    `pm` - a progress monitor

### isValid

    public RefactoringStatus isValid(IProgressMonitor pm)
                              throws CoreException

  Verifies that this change object is still valid and can be executed by calling `perform`. If a refactoring status with a severity of `RefactoringStatus.FATAL` is returned then the change has to be treated as invalid and can no longer be executed. Performing such a change produces an unspecified result and will very likely throw an exception.

  This method is also called by the `UndoManager` to decide if an undo or redo change is still valid and therefore can be executed.

  Specified by:
    `isValid` in class `Change`
  Parameters:
    `pm` - a progress monitor.
  Returns:
    a refactoring status describing the outcome of the validation check
  Throws:
    `CoreException` - if an error occurred during validation check. The change is to be treated as invalid if an exception occurs

### perform

    public Change perform(IProgressMonitor pm)
                   throws CoreException

  Performs this change. If this method is call on an invalid or disabled change object the result is unspecified. Changes should in general not respond to `IProgressMonitor.isCanceled()` since canceling a change tree in the middle of its execution leaves the workspace in a half changed state.

  Specified by:
    `perform` in class `Change`
  Parameters:
    `pm` - a progress monitor
  Returns:
    the undo change for this change object or `null` if no undo is provided
  Throws:
    `CoreException` - if an error occurred during change execution

### getModifiedElement

    public Object getModifiedElement()

  Returns the element modified by this `Change`. The method may return `null` if the change isn't related to an element.

  Specified by:
    `getModifiedElement` in class `Change`
  Returns:
    the element modified by this change

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse JDT Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) IBM Corp. and others 2000, 2004. All Rights Reserved.