Package com.tangosol.net.events

Interface Event<T extends Enum<T>>

Type Parameters:

T - the type of event

All Known Subinterfaces:

CacheLifecycleEvent, CoherenceLifecycleEvent, EntryEvent<K,V>, EntryProcessorEvent, Event<T>, Event<T>, EventDispatcher.InterceptorRegistrationEvent<E>, LifecycleEvent, SessionLifecycleEvent, TransactionEvent, TransferEvent, TransferEvent.RecoveryTransferEvent, UnsolicitedCommitEvent

public interface Event<T extends Enum<T>>

An Event object captures the necessary information required to adequately describe some activity that has occurred. Events can fire before a change has been committed to memory (pre-committed) or after the change has been committed (post-commit). Semantically EventInterceptors listening to pre-committed events will have the opportunity to change the state of the request before it has been committed.

Note that an Event object itself is immutable and is only valid in the context of a single chain of EventInterceptor.onEvent(Event) calls. Holding a reference to the Event outside of that scope is unsafe.

Since:

Coherence 12.1.2

Author:

bo, nsa, rhan, rhl, hr 2011.03.29

Method Summary

Modifier and Type	Method	Description
EventDispatcher	getDispatcher()	Return the EventDispatcher this event was raised by.
T	getType()	Return the Event's type.
void	nextInterceptor()	Dispatch this event to the next EventInterceptor in the chain if one exists.

Method Detail

getType

T getType()

Return the Event's type.

Returns:

the Event's type

getDispatcher

EventDispatcher getDispatcher()

Return the EventDispatcher this event was raised by.

Returns:

the EventDispatcher this event was raised by

nextInterceptor

void nextInterceptor()
              throws RuntimeException

Dispatch this event to the next EventInterceptor in the chain if one exists. After each subsequent interceptor has run, this method will return giving the caller the opportunity to observe any side effects caused by down stream EventInterceptors. EventInterceptors that do not explicitly call this method will not prevent other interceptors from being executed, but rather will not have the opportunity to see any side effects of those interceptors.

In the following example an interceptor looks for an INSERTING storage event, and calls nextInterceptor. This allows "more application logic" to look at the effects of other interceptors down stream. If the event is not an INSERTING storage event, the interceptor is not interested in the side effects, and simply returns.

 public void onEvent(Event event)
   {
   if (event.getType() == StorageEntryEvent.INSERTING)
     {
     // application logic

     event.nextInterceptor();

     // more application logic
     }
   }
 

If an Exception is thrown by an interceptor's onEvent method and this event is pre-committed, the processing of further interceptors will be terminated, the exception is re-thrown and the operation that generated the event will fail. If this event is immutable however, the exception will be caught and logged and normal processing of subsequent interceptors will continue.

Throws:

RuntimeException