TransactionEventAssembler (Glazed Lists 1.13.0)

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

All Implemented Interfaces:: IListEventAssembler<E>

public class TransactionEventAssembler<E>
extends java.lang.Object
implements IListEventAssembler<E>

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`TransactionEventAssembler.UndoRedoSupport<E>` UndoRedoSupport, as the name suggests, will provide generic support for undoing and redoing groups of changes to an `EventList`.

Constructor Summary

Constructors
Constructor and Description
`TransactionEventAssembler()`
`TransactionEventAssembler(boolean rollbackSupport)`
`TransactionEventAssembler(EventList<E> source)`
`TransactionEventAssembler(EventList<E> source, boolean rollbackSupport)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addBufferedListEventListener(ListEventListener<? super E> listChangeListener)`
`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.
`void`	`addRollbackEventListener(ListEventListener<? super E> listChangeListener)`
`void`	`beginEvent()` Demarks the beginning of a transaction which accumulates all ListEvents received during the transaction and fires a single aggregate ListEvent on `commitEvent()`.
`void`	`beginEvent(boolean buffered)` Demarks the beginning of a transaction.
`void`	`commitEvent()` Demarks the successful completion of a transaction.
`void`	`discardEvent()` Discards the current atomic change to this list change queue.
`void`	`dispose()`
`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, 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.
`ListEventAssembler<E>`	`getBufferedUpdates()`
`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`.
`protected ListEventAssembler<E>`	`getUpdates()`
`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`	`removeBufferedListEventListener(ListEventListener<? super E> listChangeListener)`
`void`	`removeListEventListener(ListEventListener<? super E> listChangeListener)` Removes the specified listener from receiving notification when new changes are appended to this list change sequence.
`void`	`removeRollbackEventListener(ListEventListener<? super E> listChangeListener)`
`void`	`reorder(int[] reorderMap, java.util.List<ObjectChange<E>> changes)` Sets the current event as a reordering.
`void`	`rollbackEvent()` Demarks the unsuccessful completion of a transaction.

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

Methods inherited from interface ca.odell.glazedlists.event.IListEventAssembler
createListEventPublisher

- Constructor Detail
  - TransactionEventAssembler
```
public TransactionEventAssembler()
```
  - TransactionEventAssembler
```
public TransactionEventAssembler(boolean rollbackSupport)
```
  - TransactionEventAssembler
```
public TransactionEventAssembler(EventList<E> source)
```
  - TransactionEventAssembler
```
public TransactionEventAssembler(EventList<E> source,
                                 boolean rollbackSupport)
```
- Method Detail
  - isEventInProgress
```
public boolean isEventInProgress()
```
    Description copied from interface: IListEventAssembler
    
    Indicate whether or not an event is in progress. Intended for testing purposes.
    
    Specified by:
    
    isEventInProgress in interface IListEventAssembler<E>
  - isEventEmpty
```
public boolean isEventEmpty()
```
    Description copied from interface: IListEventAssembler
    
    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
  - getCurrentChanges
```
public ListEvent<E> getCurrentChanges()
```
    Description copied from interface: IListEventAssembler
    
    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>
  - getBufferedUpdates
```
public ListEventAssembler<E> getBufferedUpdates()
```
  - getUpdates
```
protected ListEventAssembler<E> getUpdates()
```
  - 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>
  - 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>
  - beginEvent
```
public void beginEvent()
```
    Demarks the beginning of a transaction which accumulates all ListEvents received during the transaction and fires a single aggregate ListEvent on commitEvent().
    
    Specified by:
    
    beginEvent in interface IListEventAssembler<E>
  - beginEvent
```
public void beginEvent(boolean buffered)
```
    Demarks the beginning of a transaction. If buffered is true then all ListEvents received during the transaction are accumulated and fired as a single aggregate ListEvent on commitEvent(). If buffered is false then all ListEvents received during the transaction are forwarded immediately and commitEvent() produces no ListEvent of its own.
    
    Specified by:
    
    beginEvent in interface IListEventAssembler<E>
    
    Parameters:
    
    buffered - true indicates ListEvents should be buffered and sent on commitEvent(); false indicates they should be sent on immediately
    
    See Also:
    
    Bug 52
  - commitEvent
```
public void commitEvent()
```
    Demarks the successful completion of a transaction. If changes were buffered during the transaction by calling beginEvent(true) then a single ListEvent will be fired from this TransactionList describing the changes accumulated during the transaction.
    
    Specified by:
    
    commitEvent in interface IListEventAssembler<E>
  - discardEvent
```
public void discardEvent()
```
    Description copied from interface: IListEventAssembler
    
    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>
  - rollbackEvent
```
public void rollbackEvent()
```
    Demarks the unsuccessful completion of a transaction. If changes were NOT buffered during the transaction by calling beginEvent(false) then a single ListEvent will be fired from this TransactionList describing the rollback of the changes accumulated during the transaction.
  - dispose
```
public void dispose()
```
  - addListEventListener
```
public void addListEventListener(ListEventListener<? super E> listChangeListener)
```
    Description copied from interface: IListEventAssembler
    
    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
  - removeListEventListener
```
public void removeListEventListener(ListEventListener<? super E> listChangeListener)
```
    Description copied from interface: IListEventAssembler
    
    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
  - addBufferedListEventListener
```
public void addBufferedListEventListener(ListEventListener<? super E> listChangeListener)
```
  - removeBufferedListEventListener
```
public void removeBufferedListEventListener(ListEventListener<? super E> listChangeListener)
```
  - addRollbackEventListener
```
public void addRollbackEventListener(ListEventListener<? super E> listChangeListener)
```
  - removeRollbackEventListener
```
public void removeRollbackEventListener(ListEventListener<? super E> listChangeListener)
```
  - getListEventListeners
```
public java.util.List<ListEventListener<E>> getListEventListeners()
```
    Description copied from interface: IListEventAssembler
    
    Get all ListEventListeners observing the EventList.
    
    Specified by:
    
    getListEventListeners in interface IListEventAssembler<E>

Class TransactionEventAssembler<E>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface ca.odell.glazedlists.event.IListEventAssembler

Constructor Detail

TransactionEventAssembler

TransactionEventAssembler

TransactionEventAssembler

TransactionEventAssembler

Method Detail

isEventInProgress

isEventEmpty

getCurrentChanges

emptyEvent

newAssembler

getBufferedUpdates

getUpdates

elementInserted

elementInserted

elementDeleted

elementDeleted

elementUpdated

elementUpdated

elementUpdated

elementUpdated

addChange

addChange

reorder

forwardEvent

beginEvent

beginEvent

commitEvent

discardEvent

rollbackEvent

dispose

addListEventListener

removeListEventListener

addBufferedListEventListener

removeBufferedListEventListener

addRollbackEventListener

removeRollbackEventListener

getListEventListeners