io.nadron.event.impl

Class JetlangEventDispatcher

java.lang.Object

io.nadron.event.impl.JetlangEventDispatcher

All Implemented Interfaces:

EventDispatcher

public class JetlangEventDispatcher
extends Object
implements EventDispatcher

Field Summary

Fields

Modifier and Type	Field and Description
private List<EventHandler>	anyHandler
private Lane<String,ExecutorService>	dispatcherLane
private Map<EventHandler,org.jetlang.core.Disposable>	disposableHandlerMap This Map holds event handlers and their corresponding Disposable objects.
private org.jetlang.channels.MemoryChannel<Event>	eventQueue
private org.jetlang.fibers.Fiber	fiber
private Map<Integer,List<EventHandler>>	handlersByEventType
private boolean	isCloseCalled
private static org.slf4j.Logger	LOG

Constructor Summary

Constructors

Constructor and Description
JetlangEventDispatcher(Map<Integer,List<EventHandler>> listenersByEventType, List<EventHandler> anyHandler, org.jetlang.channels.MemoryChannel<Event> eventQueue, org.jetlang.fibers.Fiber fiber, Lane<String,ExecutorService> lane)
JetlangEventDispatcher(org.jetlang.channels.MemoryChannel<Event> eventQueue, org.jetlang.fibers.Fiber fiber, Lane<String,ExecutorService> lane)

Method Summary

Methods

Modifier and Type	Method and Description
protected void	addANYHandler(EventHandler eventHandler) Creates a batch subscription to the jetlang memory channel for the ANY event handler.
void	addHandler(EventHandler eventHandler) Adds event handler to the dispatcher.
void	clear() Clears all handles associated with this dispatcher.
void	close() Called by the session during disconnect, the dispatcher will no longer accept any events, it will also detach the existing listeners.
protected org.jetlang.core.Callback<List<Event>>	createEventCallbackForHandler(EventHandler eventHandler)
protected void	dispatchEventOnSameLane(Event event)
void	fireEvent(Event event) Fires event in asynchronous mode
Map<EventHandler,org.jetlang.core.Disposable>	getDisposableHandlerMap()
org.jetlang.channels.MemoryChannel<Event>	getEventQueue()
org.jetlang.fibers.Fiber	getFiber()
List<EventHandler>	getHandlers(int eventType) Returns the list of EventHandlers associated with a particular event type.
protected List<EventHandler>	getHandlersToRemoveForSession(List<EventHandler> handlerList, Session session)
Map<Integer,List<EventHandler>>	getListenersByEventType()
void	initialize()
private void	removeDisposableForHandler(EventHandler eventHandler)
void	removeHandler(EventHandler eventHandler) Removes an event handler from the dispatcher
void	removeHandlersForEvent(int eventType) Removes all event listeners associated with the event type.
boolean	removeHandlersForSession(Session session) Removes all the handlers for a session.
void	setDisposableHandlerMap(Map<EventHandler,org.jetlang.core.Disposable> disposableHandlerMap)
void	setListenersByEventType(Map<Integer,List<EventHandler>> listenersByEventType)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

private static final org.slf4j.Logger LOG

handlersByEventType

private Map<Integer,List<EventHandler>> handlersByEventType

anyHandler

private List<EventHandler> anyHandler

eventQueue

private final org.jetlang.channels.MemoryChannel<Event> eventQueue

fiber

private final org.jetlang.fibers.Fiber fiber

isCloseCalled

private volatile boolean isCloseCalled

dispatcherLane

private final Lane<String,ExecutorService> dispatcherLane

disposableHandlerMap

private Map<EventHandler,org.jetlang.core.Disposable> disposableHandlerMap

This Map holds event handlers and their corresponding Disposable objects. This way, when a handler is removed, the dispose method can be called on the Disposable.

Constructor Detail

JetlangEventDispatcher

public JetlangEventDispatcher(org.jetlang.channels.MemoryChannel<Event> eventQueue,
                      org.jetlang.fibers.Fiber fiber,
                      Lane<String,ExecutorService> lane)

JetlangEventDispatcher

public JetlangEventDispatcher(Map<Integer,List<EventHandler>> listenersByEventType,
                      List<EventHandler> anyHandler,
                      org.jetlang.channels.MemoryChannel<Event> eventQueue,
                      org.jetlang.fibers.Fiber fiber,
                      Lane<String,ExecutorService> lane)

Method Detail

initialize

public void initialize()

fireEvent

public void fireEvent(Event event)

Description copied from interface: EventDispatcher

Fires event in asynchronous mode

Specified by:

fireEvent in interface EventDispatcher

addHandler

public void addHandler(EventHandler eventHandler)

Description copied from interface: EventDispatcher

Adds event handler to the dispatcher. Using this method, different events can be handled using different handlers.

Specified by:

addHandler in interface EventDispatcher

Parameters:

eventHandler - The event handler to be added to the dispatcher.

addANYHandler

protected void addANYHandler(EventHandler eventHandler)

Creates a batch subscription to the jetlang memory channel for the ANY event handler. This method does not require synchronization since we are using CopyOnWriteArrayList

Parameters:

eventHandler -

createEventCallbackForHandler

protected org.jetlang.core.Callback<List<Event>> createEventCallbackForHandler(EventHandler eventHandler)

dispatchEventOnSameLane

protected void dispatchEventOnSameLane(Event event)

getHandlers

public List<EventHandler> getHandlers(int eventType)

Description copied from interface: EventDispatcher

Returns the list of EventHandlers associated with a particular event type.

Specified by:

getHandlers in interface EventDispatcher

Parameters:

eventType - The type of event.

Returns:

The list EventHandlers associated with that event or null.

removeHandler

public void removeHandler(EventHandler eventHandler)

Description copied from interface: EventDispatcher

Removes an event handler from the dispatcher

Specified by:

removeHandler in interface EventDispatcher

Parameters:

eventHandler - the event handler to be removed from the dispatcher

removeDisposableForHandler

private void removeDisposableForHandler(EventHandler eventHandler)

removeHandlersForEvent

public void removeHandlersForEvent(int eventType)

Description copied from interface: EventDispatcher

Removes all event listeners associated with the event type.

Specified by:

removeHandlersForEvent in interface EventDispatcher

removeHandlersForSession

public boolean removeHandlersForSession(Session session)

Description copied from interface: EventDispatcher

Removes all the handlers for a session.

Specified by:

removeHandlersForSession in interface EventDispatcher

Parameters:

session - The session instance from which event handlers need to be removed.

Returns:

Returns true if all handlers were successfully removed.

clear

public void clear()

Description copied from interface: EventDispatcher

Clears all handles associated with this dispatcher.

Specified by:

clear in interface EventDispatcher

getHandlersToRemoveForSession

protected List<EventHandler> getHandlersToRemoveForSession(List<EventHandler> handlerList,
                                               Session session)

close

public void close()

Description copied from interface: EventDispatcher

Called by the session during disconnect, the dispatcher will no longer accept any events, it will also detach the existing listeners.

Specified by:

close in interface EventDispatcher

getListenersByEventType

public Map<Integer,List<EventHandler>> getListenersByEventType()

setListenersByEventType

public void setListenersByEventType(Map<Integer,List<EventHandler>> listenersByEventType)

getEventQueue

public org.jetlang.channels.MemoryChannel<Event> getEventQueue()

getFiber

public org.jetlang.fibers.Fiber getFiber()

getDisposableHandlerMap

public Map<EventHandler,org.jetlang.core.Disposable> getDisposableHandlerMap()

setDisposableHandlerMap

public void setDisposableHandlerMap(Map<EventHandler,org.jetlang.core.Disposable> disposableHandlerMap)