ListChangeListener.Change (JavaFX 2.2)

java.lang.Object
- javafx.collections.ListChangeListener.Change<E>

Type Parameters:
E - the list element type

Enclosing interface:

ListChangeListener<E>
```
public abstract static class ListChangeListener.Change<E>
extends java.lang.Object
```
Represents a report of a change done to an Observablelist.

The getRemoved() method returns a list of elements that have been replaced or removed from the list.

The range [getFrom(), getTo()) is the range of elements in the list that contain new elements. Note that this is a half-open interval, so if the range is empty, addedFrom will be equal to addedTo. This will occur, for example, if the operation was a deletion and will mark the index where the deletion happened
It is possible to get a list of added elements by calling getAddedSubList().

The permutation and updated flags are exclusive with all other states. If a list was permutated/updated, no content was removed or added at the same time and the indexes marks the range of permutated items or the position of updated element
Typical usage is to observe changes on an ObservableList in order to hook or unhook (or add or remove a listener) or in order to maintain some invariant on every element in that ObservableList. A common code pattern for doing this looks something like the following:
```
ObservableList<Item> theList = ...;
 {
     theList.addListener(new ListChangeListener<Item>() {
         public void onChanged(Change<Item> c) {
             while (c.next()) {
                 if (c.wasPermutated()) {
                     for (int i = c.getFrom(); i < c.getTo(); ++i) {
                          //permutate
                     }
                 } else if (c.wasUpdated()) {
                          //update item
                 } else {
                     for (Item remitem : c.getRemoved()) {
                         remitem.remove(Outer.this);
                     }
                     for (Item additem : c.getAddedSubList()) {
                         additem.add(Outer.this);
                     }
                 }
             }
         }
     });
 }
 
```
Warning: This class directly accesses the source list to acquire information about the changes.
This effectively makes the Change object invalid when another change occurs on the list.
For this reason it is not safe to use this class on a different thread.

Constructor Summary

Constructors
Constructor and Description

ListChangeListener.Change(ObservableList<E> list)
Constructs a new change done to a list.

Constructors
Constructor and Description
`ListChangeListener.Change(ObservableList<E> list)` Constructs a new change done to a list.

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`getAddedSize()` Size of the interval that was added.
`java.util.List<E>`	`getAddedSubList()` To get a subList view of the list that contains only the elements added, use getAddedSubList() method.
`abstract int`	`getFrom()` If wasAdded is true, the interval contains all the values that were added.
`ObservableList<E>`	`getList()` The source list of the change.
`protected abstract int[]`	`getPermutation()` If this change is an permutation, it returns an integer array that describes the permutation.
`int`	`getPermutation(int i)` By calling these method, you can observe the permutation that happened.
`abstract java.util.List<E>`	`getRemoved()` An immutable list of removed/replaced elements.
`int`	`getRemovedSize()` Size of getRemoved() list.
`abstract int`	`getTo()` The end of the change interval.
`abstract boolean`	`next()` Go to the next change.
`abstract void`	`reset()` Reset to the initial stage.
`boolean`	`wasAdded()` Indicates if elements were added during this change
`boolean`	`wasPermutated()` Indicates if the change was only a permutation.
`boolean`	`wasRemoved()` Indicates if elements were removed during this change
`boolean`	`wasReplaced()` Indicates if elements were replaced during this change
`boolean`	`wasUpdated()` Indicates that the elements between getFrom() (inclusive) to getTo() exclusive has changed.

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

- Constructor Detail
  - ListChangeListener.Change
```
public ListChangeListener.Change(ObservableList<E> list)
```
    Constructs a new change done to a list.
    
    Parameters:
    list - that was changed
- Method Detail
  - next
```
public abstract boolean next()
```
    Go to the next change. In initial state is invalid a require a call to next() before calling other methods. The first next() call will make this object represent the first change.
    
    Returns:
    true if switched to the next change, false if this is the last change.
  - reset
```
public abstract void reset()
```
    Reset to the initial stage. After this call, the next() must be called before working with the first change.
  - getList
```
public ObservableList<E> getList()
```
    The source list of the change.
    
    Returns:
    a list that was changed
  - getFrom
```
public abstract int getFrom()
```
    If wasAdded is true, the interval contains all the values that were added. If wasPermutated is true, the interval marks the values that were permutated. If wasRemoved is true and wasAdded is false, getFrom() and getTo() should return the same number - the place whare the removed elements were positioned in the list.
    
    Returns:
    a beginning (inclusive) of an interval related to the change
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - getTo
```
public abstract int getTo()
```
    The end of the change interval.
    
    Returns:
    a end (exclusive) of an interval related to the change.
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
    See Also:
    getFrom()
  - getRemoved
```
public abstract java.util.List<E> getRemoved()
```
    An immutable list of removed/replaced elements. If no elements were removed from the list, an empty list is returned.
    
    Returns:
    a list with all the removed elements
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - wasPermutated
```
public boolean wasPermutated()
```
    Indicates if the change was only a permutation.
    
    Returns:
    true if the change was just a permutation.
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - wasAdded
```
public boolean wasAdded()
```
    Indicates if elements were added during this change
    
    Returns:
    true if something was added to the list
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - wasRemoved
```
public boolean wasRemoved()
```
    Indicates if elements were removed during this change
    
    Returns:
    true if something was removed from the list
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - wasReplaced
```
public boolean wasReplaced()
```
    Indicates if elements were replaced during this change
    
    Returns:
    same as wasAdded() && wasRemoved()
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - wasUpdated
```
public boolean wasUpdated()
```
    Indicates that the elements between getFrom() (inclusive) to getTo() exclusive has changed. This is the only optional event type and may not be fired by all ObservableLists.
    
    Returns:
    true if the current change is an update change.
    Since:
    
    2.1
  - getAddedSubList
```
public java.util.List<E> getAddedSubList()
```
    To get a subList view of the list that contains only the elements added, use getAddedSubList() method. This is actually a shortcut to c.getList().subList(c.getFrom(), c.getTo());
```
 for (Node n : change.getAddedSubList()) {
       // do something
 }
 
```
    Returns:
    the newly created sublist view that contains all the added elements.
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - getRemovedSize
```
public int getRemovedSize()
```
    Size of getRemoved() list.
    
    Returns:
    the number of removed items
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - getAddedSize
```
public int getAddedSize()
```
    Size of the interval that was added.
    
    Returns:
    the number of added items
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - getPermutation
```
protected abstract int[] getPermutation()
```
    If this change is an permutation, it returns an integer array that describes the permutation. This array maps directly from the previous indexes to the new ones. This method is not publicly accessible and therefore can return an array safely. The method is used by wasPermutated() and getPermutation(int) methods.
    
    Returns:
    empty array if this is not permutation or an integer array containing the permutation
    
    Throws:
    
    java.lang.IllegalStateException - if this Change is in initial state
  - getPermutation
```
public int getPermutation(int i)
```
    By calling these method, you can observe the permutation that happened. In order to get the new position of an element, you must call:
```
    change.getPermutation()(oldIndex);
 
```
    Note: default implementation of this method takes the information from getPermutation() method. You don't have to override this method.
    Parameters:
    i - the old index that contained the element prior to this change
    
    Returns:
    the new index of the same element

Class ListChangeListener.Change<E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ListChangeListener.Change

Method Detail

next

reset

getList

getFrom

getTo

getRemoved

wasPermutated

wasAdded

wasRemoved

wasReplaced

wasUpdated

getAddedSubList

getRemovedSize

getAddedSize

getPermutation

getPermutation