Package-level declarations

Provide general utilities to attach many handlers to be applied on events processing. Events can be of any type.

Handlers may or may not be applied to certain events at runtime based on rules provided as a predicate (function).

If an event doesn't match a handler's predicate, that handler is ignored, and the next one will be processed.

When a handler's predicate returns true, its callback will be called. That block will process the event, and return a modified copy with the changes.

The callback block will decide if subsequent handler's will be evaluated by calling the next handler explicitly (if next method is not called, the handlers defined later won't be evaluated).

There are types of handlers like 'After' y 'Before' that call next as part as their operation discharging the user of doing so.

The events are passed to handlers' callbacks wrapped in a 'context'. The context can also pass information among handlers in the attributes field. And store an exception if it is thrown in a previous handler processing.

Concepts:

  • Events

    • Context

  • Handlers

    • Predicates

    • Callbacks

Types of handlers:

  • On Handler: the callback is executed before calling the remaining handlers. next is called after the callback.

  • After Handler: the predicate is evaluated after the remaining handlers return, and the callback is executed after. next is called before the callback

  • Filter Handler: next is not called by this handler, its callback is responsible for doing so if needed.

  • Chain Handler: this handler contains a list of handlers inside.

IMPORTANT: the order is NOT the order, it is the depth. Handlers are not linked, they are NESTED. The next() method passes control to the next level.

This definition:

H1
H2
H3

Is really this execution:

H1 (on)
H2 (on)
H3 (on)
H2 (after)
H1 (after)

Types

Link copied to clipboard
data class AfterHandler<T : Any>(val afterFilter: Predicate<T> = { true }, val afterCallback: Callback<T>) : Handler<T>

After handlers are executed even if a filter don't call next handler (if after was added before filter).

Link copied to clipboard
typealias Callback<T> = (Context<T>) -> Context<T>
Link copied to clipboard
data class ChainHandler<T : Any>(val handlers: List<Handler<T>>, val predicate: Predicate<T> = { true }) : Handler<T>
Link copied to clipboard
data class Context<T : Any>(val event: T, val currentFilter: Predicate<T>, val nextHandlers: List<Handler<T>> = emptyList(), val exception: Exception? = null, val attributes: Map<*, *> = emptyMap<Any, Any>())

Context for an event.

Link copied to clipboard
data class FilterHandler<T : Any>(val predicate: Predicate<T> = { true }, val callback: Callback<T>) : Handler<T>
Link copied to clipboard
interface Handler<T : Any>

Handler for an event.

Link copied to clipboard
data class OnHandler<T : Any>(val predicate: Predicate<T> = { true }, val beforeCallback: Callback<T>) : Handler<T>
Link copied to clipboard
typealias Predicate<T> = (Context<T>) -> Boolean