(Since version scala.this.deprecated.init$default$2) No longer needed; predicates can be Any
Apply a function for every value.
Apply a function for every value. Same as =>>.
Run a block of code for every value
Run a block of code for every value
Forwards values from this Forwardable to a target, for whose type a CanForward exists (in the implicit scope).
Forwards values from this Forwardable to a target, for whose type a CanForward exists (in the implicit scope). This operator is available for right associativity. For example: val time = Var(0) <<: timerTicks // equivalent to: val time = Var(0); timerTicks >> time
the target
Apply a function for every value
Apply a function for every value
Forwards values from this Forwardable to a target, for whose type a CanForward exists (in the implicit scope).
Forwards values from this Forwardable to a target, for whose type a CanForward exists (in the implicit scope).
the forwarding instance
Apply a PartialFunction for every applicable value
Apply a PartialFunction for every applicable value
Runs code while batching messages.
Runs code while batching messages. While the code is running, calls to 'fire' on the same thread will not fire messages immediately, but will collect them. When the code completes, the messages are wrapped in a single Batch which is then fired. If there is only one message to be fired it is not wrapped in a Batch but fired directly. Nested calls to batching are ignored, so all messages collected from within the outermost call are collected and they are fired in one batch at the end.
the code to run
the result of evaluating p
Filter and map in one step.
Filter and map in one step. Takes a PartialFunction. Whenever an event is received, if the PartialFunction is defined at that event, the value returned by applying it will be fired.
Returns a derived EventStream that only fires events that are not equal to the previous event.
Returns a derived EventStream that only fires events that are not equal to the previous event. This can be used to prevent infinite recursion between multiple event streams that are mutually dependent in a consistent manner.
Log a semantic event at the error level
Log a semantic event at the error level
Returns a new EventStream that propagates a subset of the events that this EventStream fires.
Returns a new EventStream that propagates a subset of the events that this EventStream fires.
the predicate function that determines which events will be fired by the new EventStream.
Sends an event to all listeners.
Sends an event to all listeners.
Create a new EventStream that consists of the events of the EventStreams returned by f.
Create a new EventStream that consists of the events of the EventStreams returned by f. f is applied on every event of the original EventStream, and its returned EventStream is used until the next event fired by the original EventStream, at which time the previously returned EventStream is no longer used and a new one is used instead.
the function that is applied for every event to produce the next segment of the resulting EventStream.
Allows one, in a functional manner, to respond to an event while taking into account past events.
Allows one, in a functional manner, to respond to an event while taking into account past events. For every event t, f is called with arguments (u, t), where u is initially the value of the 'initial' parameter, and subsequently the result of the previous application of f. Returns a new EventStream that, for every event t fired by the original EventStream, fires the result of the application of f (which will also be the next value of u passed to it). Often 'u' will be an object representing some accumulated state. For instance, given an EventStream[Int] named 'es', es.foldLeft(0)(_ + _) would return an EventStream that, for every (integer) event fired by es, would fire the sum of all events that have been fired by es.
Registers a listener function to run whenever an event is fired.
Registers a listener function to run whenever an event is fired. The function is held with a WeakReference and a strong reference is placed in the Observing, so the latter determines the function's gc lifetime.
a function to be applied on every event
the object whose gc lifetime should determine that of the function
Whether this EventStream has any listeners depending on it
Whether this EventStream has any listeners depending on it
Returns a Signal whose value is initially the 'init' parameter, and after every event fired by this EventStream, the value of that event.
Returns a Signal whose value is initially the 'init' parameter, and after every event fired by this EventStream, the value of that event.
the initial value of the signal
Log a semantic event at the specified level
Log a semantic event at the specified level
Returns a new EventStream, that for every event that this EventStream fires, that one will fire an event that is the result of applying 'f' to this EventStream's event.
Returns a new EventStream, that for every event that this EventStream fires, that one will fire an event that is the result of applying 'f' to this EventStream's event.
the function that transforms events fired by this EventStream into events to be fired by the resulting EventStream.
Returns a derived event stream in which event propagation does not happen on the thread firing it and block it.
Returns a derived event stream in which event propagation does not happen on the thread firing it and block it. This is helpful when handling events can be time consuming. The implementation delegates propagation to an actor (scala standard library), so events are handled sequentially.
Returns a derived EventStream that does not fire events during a prior call to fire on the same thread, thus preventing infinite recursion between multiple event streams that are mutually dependent.
Returns a derived EventStream that does not fire events during a prior call to fire on the same thread, thus preventing infinite recursion between multiple event streams that are mutually dependent.
When n empty WeakReferences are found, purge them
When n empty WeakReferences are found, purge them
Sets the log level and returns the original instance.
Sets the log level and returns the original instance. So for instance: eventSource.setLogLevel(Logger.Levels.None).fire(mouseEvent) val lessThanTen = eventStream.setLogLevel(Logger.Levels.Trace).filter(_ < 10)
The subject parameter that LogEvents will be created with
The subject parameter that LogEvents will be created with
Returns a new EventStream that propagates this EventStream's events until the predicate returns false.
Returns a new EventStream that propagates this EventStream's events until the predicate returns false.
the precate function, taking an event as its argument and returning true if event propagation should continue
Returns an EventStream that only fires events that are not followed by another event within period milliseconds.
Returns an EventStream that only fires events that are not followed by another event within period milliseconds. For instance, if you want to display some results in response to the user typing, and you do not want to perform more work than necessary, you may want to wait until the user has not typed anything for a full second.
Log a semantic event at the trace level
Log a semantic event at the trace level
Log a semantic event at the warning level
Log a semantic event at the warning level
Returns an EventStream whose tuple-valued events include a function for testing staleness.
Returns an EventStream whose tuple-valued events include a function for testing staleness. The events will be of type (T, ()=>Boolean), where T is the type of the parent event stream; and the tuple will contain the event fired in the parent as well as a function that can be used to test whether that event is outdated because a new event has been fired since then. This is especially useful in conjunction with 'nonblocking', because its actor implementation means that a new event cannot be received until the previous event is finished being handled. The test function is useful because it may be desirable to abort the time-consuming work if a new event has been fired since then. Example usage: for((v, isSuperseded) <- eventStream.zipWithStaleness) { doSomework(); if(!isSuperseded()) doSomeMoreWork() }
Union of two EventStreams.
Union of two EventStreams. Returns a new EventStream that consists of all events fired by both this EventStream and 'that.'
the other EventStream to combine in the resulting EventStream.
(Since version scala.this.deprecated.init$default$2) Use logLevel or setLogLevel, this does nothing anymore
(Since version scala.this.deprecated.init$default$2) Use eventStream.hold(initial).flatMap(f)
This EventStream fires SeqDeltas (Seq deltas) and can batch them up.