Sinobu

The Signal class that implements the Reactive Pattern. This class provides methods for subscribing to the Signal as well as delegate methods to the various observers.

In Reactive Pattern an observer subscribes to a Signal. Then that observer reacts to whatever item or sequence of items the Signal emits. This pattern facilitates concurrent operations because it does not need to block while waiting for the Signal to emit objects, but instead it creates a sentry in the form of an observer that stands ready to react appropriately at whatever future time the Signal does so.

The subscribe method is how you connect an Observer to a Signal. Your Observer implements some subset of the following methods:

Observer#accept(Object)

A Signal calls this method whenever the Signal emits an item. This method takes as a parameter the item emitted by the Signal.

Observer#error(Throwable)

A Signal calls this method to indicate that it has failed to generate the expected data or has encountered some other error. It will not make further calls to Observer#error(Throwable) or Observer#complete(). The Observer#error(Throwable) method takes as its parameter an indication of what caused the error.

Observer#complete()

A Signal calls this method after it has called Observer#accept(Object) for the final time, if it has not encountered any errors.

By the terms of the Signal contract, it may call Observer#accept(Object) zero or more times, and then may follow those calls with a call to either Observer#complete() or Observer#error(Throwable) but not both, which will be its last call. By convention, in this document, calls to Observer#accept(Object) are usually called “emissions” of items, whereas calls to Observer#complete() or Observer#error(Throwable) are called “notifications.”

Create Signal preassign the specified subscriber Collection which will be invoked whenever you calls #to(Observer) related methods.

Create Signal preassign the specified subscriber BiFunction which will be invoked whenever you calls #to(Observer) related methods.

For reuse.

An Observer must call an Signal#to() method in order to receive items and notifications from the Observable.

An Observer must call an Signal#to() method in order to receive items and notifications from the Observable.

An Observer must call an Signal#to() method in order to receive items and notifications from the Observable.

Receive values from this Signal.

Receive values from this Signal.

Receive values from this Signal.

Receive values from this Signal.

Receive values as Variable from this Signal.

Receive values as Variable from this Signal.

Receive values from this Signal.

Receive values as Collection from this Signal.

Groups the elements according to the classification function and returns the result in a Map. The classification function maps elements to some key type K. The method produces a Map whose keys are the values resulting from applying the classification function to the input elements, and whose corresponding values are Lists containing the input elements which map to the associated key under the classification function.

There are no guarantees on the type, mutability, serializability, or thread-safety of the Map or List objects returned.

Receive values as List from this Signal.

Receive values as Map from this Signal.

Receive values as Map from this Signal.

Receive values as Set from this Signal.

Returns Signal that emits a Boolean that indicates whether all the items emitted by the source Signal satisfy a condition.

Returns a Signal that emits true if any item emitted by the source Signal satisfies a specified condition, otherwise false. Note: this always emits false if the source Signal is empty.

Filters the values of an Signal sequence based on the specified type.

It accumulates all the elements and flows them together as List buffer upon completion.

 ───①───②───③──╂
 ↓ ↓ ↓ ↓
 ┌─────────────┐
 buffer (all)
 └─────────────┘
 ↓
 ────────────[①②③]╂
 

It accumulates elements, and whenever it reaches the specified size, it flows them together as List buffer. Note that if the elements have not accumulated to the specified size at the time of completion, they will all be discarded.

 ───①─②─③─④─⑤─⑥─⑦╂
 ↓ ↓ ↓ ↓ ↓ ↓ ↓
 ┌──────────────┐
 buffer (3)
 └──────────────┘
 ↓ ↓
 ──────[①②③]──[④⑤⑥]─╂
 

It accumulates elements at the specified intervals, and whenever it reaches the specified size, it flows them together as List buffer. Note that if the elements have not accumulated to the specified size at the time of completion, they will all be discarded.

 ───①───②───③───④───⑤─╂
 ↓ ↓ ↓ ↓ ↓
 ┌───────────────────┐
 buffer (2, 1)
 └───────────────────┘
 ↓ ↓ ↓ ↓
 ───────[①②]─[②③]─[③④]─[④⑤]─╂
 

It accumulates elements and flows them together as List buffer at each specified timing. Note that all unflowed accumulated elements at the time of completion will be discarded.

 ────────▽──────────▽─╂ timing
 ↓ ↓
 ───①──②────③────④⑤───╂ signal
 ↓ ↓ ↓ ↓↓
 ┌───────────────────┐
 buffer (timing)
 └───────────────────┘
 ↓ ↓
 ───────[①②]────────[③④⑤]╂
 

It flows the pair of each elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in every signals.

 ───①②──────③─────④⑤──╂ signal
 ↓↓ ↓ ↓↓
 ─────❶───❷──❸──❹─────╂ other
 ↓ ↓ ↓ ↓
 ┌───────────────────┐
 combine (other)
 └───────────────────┘
 ↓ ↓ ↓ ↓
 ─────[①❶]─[②❷]─[③❸]──[④❹]──╂
 

It flows the pair of each elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in every signals.

 ───①②──────③─────④⑤──╂ signal
 ↓↓ ↓ ↓↓
 ─────❶───❷──❸──❹─────╂ other
 ↓ ↓ ↓ ↓
 ──Ⓐ───────Ⓑ────────Ⓒ─╂ another
 ↓ ↓ ↓
 ┌───────────────────┐
 combine (other, another)
 └───────────────────┘
 ↓ ↓ ↓
 ────[①❶Ⓐ]─[②❷Ⓑ]─────[③❸Ⓒ]─╂
 

It flows the pair of each elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in every signals.

 ───①②──────③─────④⑤─╂ signal
 ↓↓ ↓ ↓↓
 ─────○───●──◎──●────╂ other
 ↓ ↓ ↓ ↓
 ┌──────────────────┐
 combine (other, a and b)
 └──────────────────┘
 ↓ ↓ ↓ ↓
 ─────①───❷──⓷────❹──╂
 

It flows the pair of each elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in every signals.

 ───①②──────③─────④⑤─╂ signal
 ↓↓ ↓ ↓↓
 ─────○───●──◎──●────╂ other
 ↓ ↓ ↓ ↓
 ┌──────────────────┐
 combine (other, a and b)
 └──────────────────┘
 ↓ ↓ ↓ ↓
 ─────①───❷──⓷────❹──╂
 

It flows the pair of each latest elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in any signal.

 ───①②───────③───④──╂ signal
 ↓↓ ↓ ↓
 ─────❶───❷─────────╂ other
 ↓ ↓
 ┌─────────────────┐
 combineLatest (other)
 └─────────────────┘
 ↓ ↓ ↓ ↓
 ────[②❶]─[②❷]─[③❷]─[④❷]──╂
 

It flows the pair of each latest elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in any signal.

 ───①②─────────③──────╂ signal
 ↓↓ ↓
 ─────❶────❷──────────╂ other
 ↓ ↓
 ──Ⓐ────────────────Ⓑ─╂ another
 ↓ ↓
 ┌───────────────────┐
 combineLatest (other, another)
 └───────────────────┘
 ↓ ↓ ↓ ↓
 ────[②❶Ⓐ]─[②❷Ⓐ]─[③❷Ⓐ]─[③❷Ⓑ]╂
 

It flows the pair of each latest elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in any signal.

 ───①②───────③───④──╂ signal
 ↓↓ ↓ ↓
 ─────◎───●─────○───╂ other
 ↓ ↓ ↓
 ┌─────────────────┐
 combineLatest (other, A and B)
 └─────────────────┘
 ↓ ↓ ↓ ↓↓
 ─────⓶───❷──❸──③④─╂
 

It flows the pair of each latest elements coming from all signals. In order to flow a new pair, there must be at least one or more unflowed elements in any signal.

 ───①②───────③───④──╂ signal
 ↓↓ ↓ ↓
 ─────◎───●─────○───╂ other
 ↓ ↓ ↓
 ┌─────────────────┐
 combineLatest (others, A and B)
 └─────────────────┘
 ↓ ↓ ↓ ↓↓
 ─────⓶───❷──❸──③④──╂
 

Start the specified signal after the current signal is completed.

 ───①②──③──╂ signal
 ↓↓ ↓ ↓
 ─④───⑤⑥─╂ other
 ↓ ↓↓ ↓
 ┌─────────────────┐
 concat (other)
 └─────────────────┘
 ↓↓ ↓ ↓ ↓↓
 ───①②──③───④───⑤⑥─╂
 

Start the specified signal after the current signal is completed.

 ───①②──③──╂ signal
 ↓↓ ↓ ↓
 ─④───⑤⑥─╂ other
 ↓ ↓↓ ↓
 ┌─────────────────┐
 concat (other)
 └─────────────────┘
 ↓↓ ↓ ↓ ↓↓
 ───①②──③───④───⑤⑥─╂
 

Returns a new Signal that emits items resulting from applying a function that you supply to each item emitted by the current Signal, where that function returns an Signal, and then emitting the items that result from concatenating those returned Signal.

Returns a Signal that counts the total number of items emitted by the source Signal and emits this count as a 64-bit Long.

Drops values that are followed by newer values before a timeout. The timer resets on each value emission.

Drops values that are followed by newer values before a timeout. The timer resets on each value emission.

Drops values that are followed by newer values before a timeout. The timer resets on each value emission.

Collect values that are followed by newer values before a timeout. The timer resets on each value emission.

Collect values that are followed by newer values before a timeout. The timer resets on each value emission.

Returns Signal that emits the items emitted by the source Signal shifted forward in time by a specified delay at parallel thread. Error notifications from the source Signal are not delayed.

Returns Signal that emits the items emitted by the source Signal shifted forward in time by a specified delay at parallel thread. Error notifications from the source Signal are not delayed.

Returns Signal that emits the items emitted by the source Signal shifted forward in time by a specified delay at parallel thread. Error notifications from the source Signal are not delayed.

Returns an Signal that emits all items emitted by the source Signal that are distinct from their immediate predecessors based on Object#equals(Object) comparison.

It is recommended the elements' class V in the flow overrides the default Object.equals() to provide meaningful comparison between items as the default Java implementation only considers reference equivalence. Alternatively, use the #diff(BiPredicate) overload and provide a comparison function in case the class V can't be overridden preassign custom equals() or the comparison itself should happen on different terms or properties of the class V.

Returns an Signal that emits all items emitted by the source Signal that are distinct from their immediate predecessors when compared preassign each other via the provided comparator function.

Returns an Signal consisting of the distinct values (according to Object#equals(Object)) of this stream.

Returns an Signal consisting of the distinct values (according to Object#equals(Object)) of this stream.

Modifies the source Signal so that it invokes an effect when it calls Observer#accept(Object).

Modifies the source Signal so that it invokes an effect when it calls Observer#accept(Object).

Modifies the source Signal so that it invokes an effect when it calls Observer#accept(Object).

Modifies the source Signal so that it invokes an effect when it calls Observer#accept(Object).

Modifies the source Signal so that it invokes an effect only once when it calls Observer#accept(Object).

Modifies the source Signal so that it invokes an effect only once when it calls Observer#accept(Object).

Modifies the source Signal so that it invokes an effect when it calls Observer#complete().

Modifies the source Signal so that it invokes an effect when it calls Disposable#dispose().

Modifies the source Signal so that it invokes an effect when it calls Observer#error(Throwable).

Modifies the source Signal so that it invokes an effect when it calls Observer#error(Throwable).

Modifies the source Signal so that it invokes an effect when it calls Observer#accept(Object).

Modifies the source Signal so that it invokes the given effect when it is observed from its observers. Each observation will result in an invocation of the given action except when the source Signal is reference counted, in which case the source Signal will invoke the given action for the first observation.

Modifies the source Signal so that it invokes the given effect when it is observed from its observers. Each observation will result in an invocation of the given action except when the source Signal is reference counted, in which case the source Signal will invoke the given action for the first observation.

Modifies the source Signal so that it invokes an effect when it calls Observer#error(Throwable) or Observer#complete().

Returns Signal that emits only the very first item emitted by the source Signal, or completes if the source Signal is empty.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Append index (starting from the specified value).

Ensure the interval time for each values in Signal sequence.

Returns an Signal that applies the given Predicate function to each value emitted by an Signal and emits the result.

Returns an Signal that applies the given Predicate function to each value emitted by an Signal and emits the result.

Returns Signal that emits true that indicates whether the source Signal is completed.

Returns Signal that emits true that indicates whether the source Signal emits any value.

Returns Signal that emits true that indicates whether the source Signal is completed preassignout any value emitted.

Returns Signal that emits true that indicates whether the source Signal is erred.

Returns Signal that emits true that indicates whether the source Signal is emitted, erred or completed.

Returns Signal that emits true that indicates whether the source Signal is erred or completed.

Returns a new Signal that invokes the mapper action in parallel thread and waits all of them until all actions are completed.

Executes all tasks in parallel and returns their results only if all succeed. If any task fails, all remaining tasks are cancelled and the exception is propagated.

Returns a new Signal that invokes the mapper action in parallel thread and waits until any single action is completed. All other actions will be cancelled.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Returns a Signal that emits the last item emitted by this Signal or completes if this Signal is empty.

Returns an Signal that applies the given function to each value emitted by an Signal and emits the result.

 ───①───②───③───④───⑤──┼
 ↓ ↓ ↓ ↓ ↓ ↓
 ┌────────────────────┐
 map ○→●
 └────────────────────┘
 ↓ ↓ ↓ ↓ ↓ ↓
 ───❶───❷───❸───❹───❺──┼
 

#map(WiseFunction) preassign context.

 ───①───②───③───④───⑤──┼
 ↓ ↓ ↓ ↓ ↓
 ┌────────────────────┐
 map ○→●
 └────────────────────┘
 ↓ ↓ ↓ ↓ ↓ ↓
 ───❶───❷───❸───❹───❺──┼
 

Returns an Signal that applies the given constant to each item emitted by an Signal and emits the result.

Flattens a sequence of Signal emitted by an Signal into one Signal, preassignout any transformation.

 ───①───②───③───④───⑤──┼
 ↓ ↓ ↓ ↓ ↓
 ─────❶────❷────❸────┼
 ↓ ↓ ↓
 ┌────────────────────┐
 merge
 └────────────────────┘
 ↓ ↓ ↓ ↓↓ ↓ ↓ ↓
 ───①─❶─②──❷③───④❸──⑤──┼
 

Flattens a sequence of Signal emitted by an Signal into one Signal, preassignout any transformation.

Switch event stream context.

 ───①───②───③───④───⑤──┼
 ↓ ↓ ↓ ↓ ↓
 ┌────────────────────┐
 on ━
 └────────────────────┘
 ↓ ↓ ↓ ↓ ↓ ↓
 ━━━❶━━━❷━━━❸━━━❹━━━❺━━╋
 

Generates an Signal sequence that guarantee one item at least.

Generates an Signal sequence that guarantee one item at least.

Generates an Signal sequence that guarantee one item at least.

Helps to insert Signal chain from outside.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging those resulting Signal and emitting the results of this merger.

Recover the source Signal on the specified error by the specified value. Unspecified error types will pass through the source Signal.

Recover the source Signal on the specified error by the notifier emitting values. Unspecified errors will pass through the source Signal.

• Next - Replace source error and propagate values to source signal.
• Error - Propagate to source error and dispose them.
• Complete - Terminate notifier signal. Source signal will never recover errors.

Generates an Signal sequence that repeats the given value infinitely.

Returns an Signal that emits the same values as the source signal preassign the exception to an Observer#error(Throwable). An error notification from the source will result in the emission of a Throwable item to the Signal provided as an argument to the notificationHandler function. If that Signal calls Observer#complete() or Observer#error(Throwable) then retry will call Observer#complete() or Observer#error(Throwable) on the child subscription. Otherwise, this Signal will resubscribe to the source Signal.

Retry the source Signal infinitely whenever any error is occurred.

Retry the source Signal when the specified error is occurred. Unspecified errors will pass through the source Signal.

• Next - Retry source Signal.
• Error - Propagate to source error and dispose them.
• Complete - Terminate notifier signal. Source signal will never retry errors.

Buffer all values until complete, then all buffered values are emitted in descending order.

Returns an Signal that, when the specified sampler Signal emits an item, emits the most recently emitted item (if any) emitted by the source Signal since the previous emission from the sampler Signal.

Returns an Signal that applies a function of your choosing to the first item emitted by a source Signal and a seed value, then feeds the result of that function along preassign the second item emitted by the source Signal into the same function, and so on until all items have been emitted by the source Signal, emitting the result of each of these iterations.

Returns an Signal that applies a function of your choosing to the first item emitted by a source Signal and a seed value, then feeds the result of that function along preassign the second item emitted by the source Signal into the same function, and so on until all items have been emitted by the source Signal, emitting the result of each of these iterations.

Returns an Signal that applies a function of your choosing to the first item emitted by a source Signal and a seed value, then feeds the result of that function along preassign the second item emitted by the source Signal into the same function, and so on until all items have been emitted by the source Signal, emitting the result of each of these iterations.

Maps a sequence of values into Signal and concatenates these Signal eagerly into a single Signal. Eager concatenation means that once a subscriber subscribes, this operator subscribes to all the source Signal. The operator buffers the values emitted by these Signal and then drains them in order, each one after the previous one completes.

Returns a new Signal that multicasts (shares) the original Signal. As long as there is at least one Observer this Signal will be subscribed and emitting data. When all observers have disposed it will disposes from the source Signal.

Bypasses a specified number of values in an Signal sequence and then returns the remaining values.

Alias for skip(I.set(excludes)).

Alias for take(condition.negate()).

Alias for take(init, condition.negate()).

Returns an Signal consisting of the values of this Signal that match the given predicate.

Returns a specified index values from the start of an Signal sequence.

Returns an Signal that emits items emitted by the source Signal, checks the specified predicate for each item, and then completes if the condition is not signaled.

Return the Signal which ignores the specified error.

Return the Signal which ignores complete event.

Alias for skip(Objects::isNull).

Returns an Signal that skips all items emitted by the source Signal as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.

Returns the values from the source Signal sequence only after the other Signal sequence produces a value.

Returns an Signal that skips all items emitted by the source Signal as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.

Buffer all items until complete event and then sorted items will be emitted sequentially.

Emit a specified sequence of items before beginning to emit the items from the source Signal.

If you want an Signal to emit a specific sequence of items before it begins emitting the items normally expected from it, apply the StartWith operator to it.

If, on the other hand, you want to append a sequence of items to the end of those normally emitted by an Signal, you want the #sequenceMap(WiseFunction) operator.

Emit a specified sequence of items before beginning to emit the items from the source Signal.

If you want an Signal to emit a specific sequence of items before it begins emitting the items normally expected from it, apply the StartWith operator to it.

If, on the other hand, you want to append a sequence of items to the end of those normally emitted by an Signal, you want the #sequenceMap(WiseFunction) operator.

Emit a specified sequence of items before beginning to emit the items from the source Signal.

If you want an Signal to emit a specific sequence of items before it begins emitting the items normally expected from it, apply the StartWith operator to it.

If, on the other hand, you want to append a sequence of items to the end of those normally emitted by an Signal, you want the #sequenceMap(WiseFunction) operator.

Emit a specified sequence of items before beginning to emit the items from the source Signal.

Emit null item before beginning to emit the items from the source Signal.

Return the Signal which replaces the specified error by complete event.

Asynchronously subscribes Observer to this Signal on the specified scheduler.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging the latest resulting Signal and emitting the results of this merger.

Returns an Signal that emits items based on applying a function that you supply to each item emitted by the source Signal, where that function returns an Signal , and then merging the latest resulting Signal and emitting the results of this merger.

Return an Signal that is observed as long as the specified timing Signal indicates false. When the timing Signal returns true, the currently subscribed Signal is immediately disposed.

Return an Signal that is observed as long as the specified timing Signal indicates true. When the timing Signal returns false, the currently subscribed Signal is immediately disposed.

Returns a specified number of contiguous values from the start of an Signal sequence.

Alias for take(I.set(includes)).

Returns an Signal consisting of the values of this Signal that match the given predicate.

Returns an Signal consisting of the values of this Signal that match the given predicate.

Returns an Signal consisting of the values of this Signal that match the given predicate.

Returns a specified index values from the start of an Signal sequence.

Returns an Signal that emits items emitted by the source Signal, checks the specified predicate for each item, and then completes if the condition is signaled.

Returns an Signal that emits items emitted by the source Signal, checks the specified predicate for each item, and then completes if the condition is satisfied.