EventProcessor

abstract def eventManifest: Manifest[Event]

abstract def handleListenerResponse(value: Response, state: EventState[Event]): Unit

abstract def listenable: Listenable

abstract def name: String

abstract def responseFor(state: EventState[Event]): Result

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +=(listener: Listener[Event, Response]): Unit

def -=(listener: Listener[Event, Response]): Unit

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def add(listener: Listener[Event, Response]): Unit

def and[NE >: Event, NV >: Response, NR >: Result](processor: EventProcessor[NE, NV, NR]): ProcessorGroup[NE, NV, NR]

final def asInstanceOf[T0]: T0

def asynchronousLogging: Boolean

def clone(): AnyRef

def create(priority: Priority, modes: ListenMode*)(f: (Event) ⇒ Response): FunctionalListener[Event, Response]

Creates the listener but does not add it.

def debug(message: ⇒ Any): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(message: ⇒ Any, t: Throwable): Unit

def error(message: ⇒ Any): Unit

def finalize(): Unit

def fire(event: Event, mode: ListenMode = ListenMode.Standard): Result

def fireAdditional(state: EventState[Event], mode: ListenMode, listenable: Listenable): Unit

Allows extending classes to continue processing on additional listeners if needed before a response is determined and sent back to the caller.

def fireInternal(state: EventState[Event], mode: ListenMode, listenable: Listenable): Unit

final def getClass(): Class[_]

def hashCode(): Int

def info(message: ⇒ Any): Unit

final def isInstanceOf[T0]: Boolean

def isListenerTypeValid(state: EventState[Event], listener: Listener[_, _]): Boolean

def isModeValid(listener: Listener[_, _], mode: ListenMode): Boolean

def isNameValid(listener: Listener[_, _]): Boolean

def listen(priority: Priority, modes: ListenMode*)(f: (Event) ⇒ Response): FunctionalListener[Event, Response]

def log(level: Level, message: ⇒ Any): Unit

val logger: InnerLogging

def loggingClassName: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def on(f: (Event) ⇒ Response, priority: Priority = Priority.Normal): FunctionalListener[Event, Response]

def once(f: (Event) ⇒ Response, priority: Priority = Priority.Normal): Listener[Event, Response]

Works similarly to on but after the first event is received the listener is removed.

def onceConditional(default: Response, priority: Priority = Priority.Normal)(f: (Event) ⇒ Option[Response]): Listener[Event, Response]

Invokes the function upon each event until it returns Some[V] and then removes the listener from receiving any other invocations.

def remove(listener: Listener[Event, Response]): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def trace(message: ⇒ Any): Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def warn(message: ⇒ Any, t: Throwable): Unit

def warn(message: ⇒ Any): Unit