ListEventAssembler (Glazed Lists 1.13.0)

java.lang.Object
- ca.odell.glazedlists.event.ListEventAssembler<E>

All Implemented Interfaces:

IListEventAssembler<E>
```
public final class ListEventAssembler<E>
extends java.lang.Object
implements IListEventAssembler<E>
```
Models a continuous stream of changes on a list. Changes of the same type that occur on a continuous set of rows are grouped into blocks automatically for performance benefits.
Atomic sets of changes may involve many lines of changes and many blocks of changes. They are committed to the queue in one action. No other threads should be creating a change on the same list change queue when an atomic change is being created.

Author:

Jesse Wilson

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`allowNestedEvents` whether to allow nested events
`protected int`	`eventLevel` the event level is the number of nested events
`protected int[]`	`reorderMap` the current reordering array if this change is a reorder
`protected EventList<E>`	`sourceList` the list that this tracks changes for

Constructor Summary

Constructors
Constructor and Description
`ListEventAssembler(EventList<E> sourceList, ListEventPublisher publisher)` Creates a new ListEventAssembler that tracks changes for the specified list.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addChange(int type, int startIndex, java.util.List<ObjectChange<E>> changeEvents)` Adds a block of changes to the set of list changes.
`void`	`addChange(int type, int index, ObjectChange<E> event)` Convenience method for appending a single change of the specified type.
`void`	`addListEventListener(ListEventListener<? super E> listChangeListener)` Registers the specified listener to be notified whenever new changes are appended to this list change sequence.
`static <T> void`	`applyListEvent(ListEvent<T> event, java.util.List<T> target)`
`static <T> void`	`applyListEvent(ListEvent<T> event, java.util.List<T> target, ListEventAssembler<T> targetAssembler)`
`void`	`beginEvent()` Starts a new atomic change to this list change queue.
`void`	`beginEvent(boolean allowNestedEvents)` Starts a new atomic change to this list change queue.
`void`	`commitEvent()` Commits the current atomic change to this list change queue.
`static ListEventPublisher`	`createListEventPublisher()` Deprecated.
`protected ListEventAssembler<E>`	`deepCopy()`
`void`	`discardEvent()` Discards the current atomic change to this list change queue.
`void`	`elementDeleted(int index, E oldValue)` Add to the current ListEvent the removal of the element at the specified index, with the specified previous value.
`void`	`elementDeleted(int index, java.util.List<E> oldValues)` Adds a block of removal events
`void`	`elementInserted(int index, E newValue)` Add to the current ListEvent the insert of the element at the specified index, with the specified previous value.
`void`	`elementInserted(int index, java.util.List<E> newValues)` Adds a block of insert events.
`void`	`elementUpdated(int index, E oldValue)` Deprecated. replaced with `elementUpdated(int, Object, Object)`.
`void`	`elementUpdated(int index, E oldValue, E newValue)` Add to the current ListEvent the update of the element at the specified index, with the specified previous value.
`void`	`elementUpdated(int index, java.util.List<E> oldValues, java.util.List<E> newValues)`
`void`	`elementUpdated(int index, java.util.List<ObjectChange<E>> changes)` Adds a block of update events
`void`	`elementUpdated(int index, ObjectChange<E> change)`
`ListEvent<E>`	`emptyEvent()`
`void`	`forwardEvent(ListEvent<?> listChanges)` Forwards the event.
`ListEvent<E>`	`getCurrentChanges()` Returns the uncommited changes of the current event level
`java.util.List<ListEventListener<E>>`	`getListEventListeners()` Get all `ListEventListener`s observing the `EventList`.
`boolean`	`isEventEmpty()` Returns `true` if the current atomic change to this list change queue is empty; `false` otherwise.
`boolean`	`isEventInProgress()` Indicate whether or not an event is in progress.
`ListEventAssembler<E>`	`newAssembler()`
`void`	`removeListEventListener(ListEventListener<? super E> listChangeListener)` Removes the specified listener from receiving notification when new changes are appended to this list change sequence.
`void`	`reorder(int[] reorderMap, java.util.List<ObjectChange<E>> changes)` Sets the current event as a reordering.

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

- Field Detail
  - sourceList
```
protected EventList<E> sourceList
```
    the list that this tracks changes for
  - eventLevel
```
protected int eventLevel
```
    the event level is the number of nested events
  - allowNestedEvents
```
protected boolean allowNestedEvents
```
    whether to allow nested events
  - reorderMap
```
protected int[] reorderMap
```
    the current reordering array if this change is a reorder
- Constructor Detail
  - ListEventAssembler
```
public ListEventAssembler(EventList<E> sourceList,
                          ListEventPublisher publisher)
```
    Creates a new ListEventAssembler that tracks changes for the specified list.
- Method Detail
  - createListEventPublisher
```
@Deprecated
public static ListEventPublisher createListEventPublisher()
```
    Deprecated.
    
    Create a new ListEventPublisher for an EventList not attached to any other EventLists.
    
    Specified by:
    
    createListEventPublisher in interface IListEventAssembler<E>
  - isEventInProgress
```
public boolean isEventInProgress()
```
    Indicate whether or not an event is in progress. Intended for testing purposes.
    
    Specified by:
    
    isEventInProgress in interface IListEventAssembler<E>
  - beginEvent
```
public void beginEvent()
```
    Starts a new atomic change to this list change queue.
    This simple change event does not support change events nested within. To allow other methods to nest change events within a change event, use beginEvent(true).
    
    Specified by:
    
    beginEvent in interface IListEventAssembler<E>
  - beginEvent
```
public void beginEvent(boolean allowNestedEvents)
```
    Starts a new atomic change to this list change queue. This signature allows you to specify allowing nested changes. This simply means that you can call other methods that contain a beginEvent(), commitEvent() block and their changes will be recorded but not fired. This allows the creation of list modification methods to call simpler list modification methods while still firing a single ListEvent to listeners.
    
    Specified by:
    
    beginEvent in interface IListEventAssembler<E>
    
    Parameters:
    
    allowNestedEvents - false to throw an exception if another call to beginEvent() is made before the next call to commitEvent(). Nested events allow multiple method's events to be composed into a single event.
    
    See Also:
    
    Bug 52
  - elementInserted
```
public void elementInserted(int index,
                            E newValue)
```
    Add to the current ListEvent the insert of the element at the specified index, with the specified previous value.
    
    Specified by:
    
    elementInserted in interface IListEventAssembler<E>
  - elementInserted
```
public void elementInserted(int index,
                            java.util.List<E> newValues)
```
    Adds a block of insert events.
    
    Specified by:
    
    elementInserted in interface IListEventAssembler<E>
  - elementDeleted
```
public void elementDeleted(int index,
                           E oldValue)
```
    Add to the current ListEvent the removal of the element at the specified index, with the specified previous value.
    
    Specified by:
    
    elementDeleted in interface IListEventAssembler<E>
  - elementDeleted
```
public void elementDeleted(int index,
                           java.util.List<E> oldValues)
```
    Adds a block of removal events
    
    Specified by:
    
    elementDeleted in interface IListEventAssembler<E>
  - elementUpdated
```
public void elementUpdated(int index,
                           java.util.List<ObjectChange<E>> changes)
```
    Adds a block of update events
    
    Specified by:
    
    elementUpdated in interface IListEventAssembler<E>
  - elementUpdated
```
public void elementUpdated(int index,
                           E oldValue,
                           E newValue)
```
    Add to the current ListEvent the update of the element at the specified index, with the specified previous value.
    
    Specified by:
    
    elementUpdated in interface IListEventAssembler<E>
  - elementUpdated
```
public void elementUpdated(int index,
                           java.util.List<E> oldValues,
                           java.util.List<E> newValues)
```
    Specified by:
    
    elementUpdated in interface IListEventAssembler<E>
  - elementUpdated
```
public void elementUpdated(int index,
                           ObjectChange<E> change)
```
    Specified by:
    
    elementUpdated in interface IListEventAssembler<E>
  - elementUpdated
```
@Deprecated
public void elementUpdated(int index,
                                        E oldValue)
```
    Deprecated. replaced with elementUpdated(int, Object, Object).
  - addChange
```
public void addChange(int type,
                      int index,
                      ObjectChange<E> event)
```
    Convenience method for appending a single change of the specified type.
    
    Specified by:
    
    addChange in interface IListEventAssembler<E>
  - addChange
```
public void addChange(int type,
                      int startIndex,
                      java.util.List<ObjectChange<E>> changeEvents)
```
    Adds a block of changes to the set of list changes. The change block allows a range of changes to be grouped together for efficiency.
    
    Specified by:
    
    addChange in interface IListEventAssembler<E>
  - reorder
```
public void reorder(int[] reorderMap,
                    java.util.List<ObjectChange<E>> changes)
```
    Sets the current event as a reordering. Reordering events cannot be combined with other events.
    
    Specified by:
    
    reorder in interface IListEventAssembler<E>
  - forwardEvent
```
public void forwardEvent(ListEvent<?> listChanges)
```
    Forwards the event. This is a convenience method that does the following:
    1. beginEvent()
    2. For all changes in sourceEvent, apply those changes to this
    3. commitEvent()
    Note that this method should be preferred to manually forwarding events because it is heavily optimized.
    Note that currently this implementation does a best effort to preserve reorderings. This means that a reordering is lost if it is combined with any other ListEvent.
    
    Specified by:
    
    forwardEvent in interface IListEventAssembler<E>
  - commitEvent
```
public void commitEvent()
```
    Commits the current atomic change to this list change queue. This will notify all listeners about the change.
    If the current event is nested within a greater event, this will simply change the nesting level so that further changes are applied directly to the parent change.
    
    Specified by:
    
    commitEvent in interface IListEventAssembler<E>
  - discardEvent
```
public void discardEvent()
```
    Discards the current atomic change to this list change queue. This does not notify any listeners about any changes.
    The caller of this method is responsible for returning the EventList to its state before the event began. If they fail to do so, the EventList pipeline may be in an inconsistent state.
    If the current event is nested within a greater event, this will discard changes at the current nesting level and that further changes are still applied directly to the parent change.
    
    Specified by:
    
    discardEvent in interface IListEventAssembler<E>
  - isEventEmpty
```
public boolean isEventEmpty()
```
    Returns true if the current atomic change to this list change queue is empty; false otherwise.
    
    Specified by:
    
    isEventEmpty in interface IListEventAssembler<E>
    
    Returns:
    
    true if the current atomic change to this list change queue is empty; false otherwise
  - addListEventListener
```
public void addListEventListener(ListEventListener<? super E> listChangeListener)
```
    Registers the specified listener to be notified whenever new changes are appended to this list change sequence.
    For each listener, a ListEvent is created, which provides a read-only view to the list changes in the list. The same ListChangeView object is used for all notifications to the specified listener, so if a listener does not process a set of changes, those changes will persist in the next notification.
    
    Specified by:
    
    addListEventListener in interface IListEventAssembler<E>
    
    Parameters:
    
    listChangeListener - event listener != null
    
    Throws:
    
    java.lang.NullPointerException - if the specified listener is null
  - removeListEventListener
```
public void removeListEventListener(ListEventListener<? super E> listChangeListener)
```
    Removes the specified listener from receiving notification when new changes are appended to this list change sequence.
    This uses the == identity comparison to find the listener instead of equals(). This is because multiple Lists may be listening and therefore equals() may be ambiguous.
    
    Specified by:
    
    removeListEventListener in interface IListEventAssembler<E>
    
    Parameters:
    
    listChangeListener - event listener != null
    
    Throws:
    
    java.lang.NullPointerException - if the specified listener is null
    
    java.lang.IllegalArgumentException - if the specified listener wasn't added before
  - getListEventListeners
```
public java.util.List<ListEventListener<E>> getListEventListeners()
```
    Get all ListEventListeners observing the EventList.
    
    Specified by:
    
    getListEventListeners in interface IListEventAssembler<E>
  - getCurrentChanges
```
public ListEvent<E> getCurrentChanges()
```
    Returns the uncommited changes of the current event level
    
    Specified by:
    
    getCurrentChanges in interface IListEventAssembler<E>
    
    Returns:
  - emptyEvent
```
public ListEvent<E> emptyEvent()
```
    Specified by:
    
    emptyEvent in interface IListEventAssembler<E>
  - newAssembler
```
public ListEventAssembler<E> newAssembler()
```
    Specified by:
    
    newAssembler in interface IListEventAssembler<E>
  - deepCopy
```
protected ListEventAssembler<E> deepCopy()
```
  - applyListEvent
```
public static <T> void applyListEvent(ListEvent<T> event,
                                      java.util.List<T> target)
```
  - applyListEvent
```
public static <T> void applyListEvent(ListEvent<T> event,
                                      java.util.List<T> target,
                                      ListEventAssembler<T> targetAssembler)
```

Class ListEventAssembler<E>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sourceList

eventLevel

allowNestedEvents

reorderMap

Constructor Detail

ListEventAssembler

Method Detail

createListEventPublisher

isEventInProgress

beginEvent

beginEvent

elementInserted

elementInserted

elementDeleted

elementDeleted

elementUpdated

elementUpdated

elementUpdated

elementUpdated

elementUpdated

addChange

addChange

reorder

forwardEvent

commitEvent

discardEvent

isEventEmpty

addListEventListener

removeListEventListener

getListEventListeners

getCurrentChanges

emptyEvent

newAssembler

deepCopy

applyListEvent

applyListEvent