def __init__(self, key=None, handlers=None):
HashableImpl.__init__(self)
self.signalers = dict()
self._signalers_lock = RLock()
self.key = key
if handlers is not None:
for handler in handlers:
self.registerHandler(handler)
def __init__(self, key=None, handlers=None):
HashableImpl.__init__(self)
self.signalers = dict()
self._signalers_lock = RLock()
self.key = key
if handlers is not None:
for handler in handlers:
self.registerHandler(handler)
def __init__(self, key=None, handlers=None, onNoHandlers=None):
HashableImpl.__init__(self)
self.handlers = set()
self._lock = Lock()
self.key = key
self.on_no_handlers = onNoHandlers
if handlers is not None:
for handler in handlers:
self.registerHandler(handler)
def __init__(self, key=None, handlers=None, onNoHandlers=None):
HashableImpl.__init__(self)
self.handlers = set()
self._lock = Lock()
self.key = key
self.on_no_handlers = onNoHandlers
if handlers is not None:
for handler in handlers:
self.registerHandler(handler)
def __init__(self,
processSignalFunc,
onRegisteredFunc=None,
onUnregisteredFunc=None,
shouldHandleSignalFunc=None,
signalers=None,
instant=True,
preprocessSignal=None):
""" Initialize event handler.
@param processSignalFunc Called when signal is processed either from cache or directly from
the signaler, depending on the instant parameter. This should be a
function with signature: processSignal(signaler, data).
@param onRegisteredFunc Called when this handler is registered to a signaler. This should be
a function with signature: onRegisteredFunc(handler, signaler) where
handler is a reference to this object.
@param onUnregisteredFunc Same as onRegisteredFunc but called when unregistered from signaler.
@param shouldHandleSignalFunc Called when a signal is initially received, before caching or
processing. This should be a function with signature:
shouldHandleSignalFunc(signaler, data). If true is returned
the signal continues to caching or processing, if false is returned
the signal is discarded silently.
Note: the signal passed to this method will have passed through
the preprocess stage.
@param instant If true signals are cached - one signal per signaler with newer signals
overwriting older ones. Signals are cached until a call to
processCachedSignals is made, at which point they are processed as
normal. If false signals are not cached and are passed straight to
the processSignalFunc as they are received.
@param preprocessSignal Called when a signal is initially received (before any caching).
This should be a function with signature:
preprocessSignal(handler, signaler, oldData, newData) which returns the
modified signal.
Using this method a signaler can modify the default behaviour
of overwriting existing cached signals.
For example, it can join multiple signals together so that no
data loss occurs between processCachedSignals calls. Note that this
function is thread safe and can safely modify the contents of oldData
and newData within the context of the handler/signaler paradigm. """
HashableImpl.__init__(self)
if onRegisteredFunc is None:
onRegisteredFunc = lambda x, y: None
if onUnregisteredFunc is None:
onUnregisteredFunc = lambda x, y: None
if shouldHandleSignalFunc is None:
shouldHandleSignalFunc = lambda x, y: True
if preprocessSignal is None:
preprocessSignal = lambda handler, signaler, oldData, newData: newData
self.registered_to_signalers = set()
self.on_registered_func = onRegisteredFunc
self.on_unregistered_func = onUnregisteredFunc
self.should_handle_signal_func = shouldHandleSignalFunc
self.instant = instant
self.preprocess_signal = preprocessSignal
self.on_signal_func = self._handleSignalDecider
if not self.instant:
self._signals_cache_lock = Lock()
self._signals_cache = dict()
self.on_process_func = processSignalFunc
if signalers is not None:
for signaler in signalers:
extractSignaler(signaler).registerHandler(self)
def __init__(self, processSignalFunc,
onRegisteredFunc=None,
onUnregisteredFunc=None,
shouldHandleSignalFunc=None,
signalers=None,
instant=True,
preprocessSignal=None):
""" Initialize event handler.
@param processSignalFunc Called when signal is processed either from cache or directly from
the signaler, depending on the instant parameter. This should be a
function with signature: processSignal(signaler, data).
@param onRegisteredFunc Called when this handler is registered to a signaler. This should be
a function with signature: onRegisteredFunc(handler, signaler) where
handler is a reference to this object.
@param onUnregisteredFunc Same as onRegisteredFunc but called when unregistered from signaler.
@param shouldHandleSignalFunc Called when a signal is initially received, before caching or
processing. This should be a function with signature:
shouldHandleSignalFunc(signaler, data). If true is returned
the signal continues to caching or processing, if false is returned
the signal is discarded silently.
Note: the signal passed to this method will have passed through
the preprocess stage.
@param instant If true signals are cached - one signal per signaler with newer signals
overwriting older ones. Signals are cached until a call to
processCachedSignals is made, at which point they are processed as
normal. If false signals are not cached and are passed straight to
the processSignalFunc as they are received.
@param preprocessSignal Called when a signal is initially received (before any caching).
This should be a function with signature:
preprocessSignal(handler, signaler, oldData, newData) which returns the
modified signal.
Using this method a signaler can modify the default behaviour
of overwriting existing cached signals.
For example, it can join multiple signals together so that no
data loss occurs between processCachedSignals calls. Note that this
function is thread safe and can safely modify the contents of oldData
and newData within the context of the handler/signaler paradigm. """
HashableImpl.__init__(self)
if onRegisteredFunc is None:
onRegisteredFunc = lambda x, y: None
if onUnregisteredFunc is None:
onUnregisteredFunc = lambda x, y: None
if shouldHandleSignalFunc is None:
shouldHandleSignalFunc = lambda x, y: True
if preprocessSignal is None:
preprocessSignal = lambda handler, signaler, oldData, newData: newData
self.registered_to_signalers = set()
self.on_registered_func = onRegisteredFunc
self.on_unregistered_func = onUnregisteredFunc
self.should_handle_signal_func = shouldHandleSignalFunc
self.instant = instant
self.preprocess_signal = preprocessSignal
self.on_signal_func = self._handleSignalDecider
if not self.instant:
self._signals_cache_lock = Lock()
self._signals_cache = dict()
self.on_process_func = processSignalFunc
if signalers is not None:
for signaler in signalers:
extractSignaler(signaler).registerHandler(self)
