SourceStream

An alias for the publish method with no explicit execution context.

A version of the publish method which takes the implicit execution context for dispatching.

The difference between !! and ! (and also between the two publish methods) is that even if the source's execution context is the same as the subscriber's execution context, if we send an event using !, it will be wrapped in a future and executed asychronously. If we use !! then for subscribers working in the same execution context the call will be synchronous. This may be desirable in some cases, but please use with caution.

Publishes the event to all subscribers.

Publishes the event to all subscriber, using the given execution context.

Creates a new event stream of events of type V by applying a partial function which maps the original event of type E to an event of type V. If the partial function doesn't work for the emitted event, nothing will be emitted in the new event stream. Basically, it's filter + map.

Typically, a newly created event streams and signals are lazy in the sense that till there are no subscriptions to them, they will not execute any intermediate computations (e.g. assembled to it through maps, flatMaps, etc). After all, those computations would be ignored at the end. Only when a subscription is created, the computations are performed for the first time. disableAutowiring enforces those computations even if there are no subscribers. It can be useful if e.g. the computations perform side-effects or if it's important from the performance point of view to have the intermediate results ready when the subscriber is created.

Creates a new EventStream[E] by filtering events emitted by the original one.

Creates a new EventStream[V] by mapping each event of the original EventStream[E] to a new event stream and switching to it. The usual use case is that the event from the original stream serves to make a decision which next stream we should be listening to. When another event is emitted by the original stream, we may stay listening to that second one, or change our previous decision.

An alias for the on method with the default ExecutionContext.

A shorthand for next which additionally unwraps the cancellable future

Checks if there are any subscribers registered in this EventRelay.

An alias to the future method.

Assuming that the event emitted by the stream can be interpreted as a boolean, this method creates a new event stream of type Unit which emits unit events for each original event which is interpreted as false.

Assuming that the event emitted by the stream can be interpreted as a boolean, this method creates a new event stream of type Unit which emits unit events for each original event which is interpreted as true.

Creates a new EventStream[V] by mapping events of the type E emitted by the original one.

Creates a new EventStream[V] by mapping events of the type E emitted by the original one.

Produces a CancellableFuture which will finish when the next event is emitted in the parent event stream.

The class which implements this EventRelay can use this method to notify all the subscribers that a new event arrived.

Registers a subscriber in a specified execution context and returns the subscription. An optional event context can also be provided by the user for managing the subscription instead of doing it manually. When an event is published in the event stream, the subscriber function will be called in the given execution context instead of the one of the publisher.

Registers a subscriber which will always be called in the same execution context in which the event was published. An optional event context can be provided by the user for managing the subscription instead of doing it manually.

A shorthand for registering a subscriber function in this event stream which only purpose is to publish events emitted by this stream in a given SourceStream. The subscriber function will be called in the execution context of the original publisher.

Creates a new event stream of events of type V where each event is a result of applying a function which combines the previous result of type V with the original event of type E that triggers the emission of the new one.

Adds a new subscriber instance. The implementing class should handle notifying this subscriber when a new event arrives. If this is the first subscriber, and disableAutowiring wasn't called previous, this will trigger a call to onWire.

Removes a previously registered subscriber instance. If this is the last subscriber, and disableAutowiring wasn't called previously, this will trigger a call to onUnwire.

Empties the set of subscribers and calls unWire if disableAutowiring wasn't called before.

An alias for filter used in the for/yield notation.

Creates a new event stream by merging the original stream with another one of the same type. The resulting stream will emit events coming from both sources.

An alias for pipeTo.