Uses of Interface
org.reactfx.EventStream

Packages that use EventStream

Package	Description
org.reactfx
org.reactfx.collection
org.reactfx.value

Uses of EventStream in org.reactfx

Subinterfaces of EventStream in org.reactfx

Modifier and Type	Interface	Description
interface	AwaitingEventStream<T>	An event stream that indicates whether there is a pending event that can be expected to be emitted in the future.
interface	CompletionStageStream<T>
interface	ConnectableEventStream<T>
interface	ProperEventStream<T>	Trait to be mixed into ObservableBase to obtain default implementation of some EventStream methods on top of Observable methods and get additional helper methods for proper event streams implemented as default methods on top of ProperObservable methods.
interface	SuspendableEventStream<T>	An event stream whose emission of events can be suspended temporarily.
interface	SuspenderStream<T, S extends Suspendable>	An event stream that suspends a suspendable object during emission.
interface	TaskStream<T>

Classes in org.reactfx that implement EventStream

Modifier and Type	Class	Description
(package private) class	AbstractReducibleEventStream<T>
(package private) class	AccumulateBetweenStream<T,A>
(package private) class	AccumulateUntilLaterStream<T,A>
(package private) class	AccumulatingStream<T,U>	See EventStream.accumulate(BiFunction, Function)
(package private) final class	AccumulativeEventStream<T,A>
(package private) class	Await<T,F>
(package private) class	AwaitLatest<T,F>
final class	ConnectableEventSource<T>
(package private) class	DefaultEventStream<T>
(package private) class	DistinctStream<T>	See EventStream.distinct()
(package private) class	EmitBothOnEachStream<A,I>	EventStream.emitBothOnEach(EventStream)
(package private) class	EmitOnEachStream<T>	See EventStream.emitOnEach(EventStream)
(package private) class	EmitOnStream<T>
class	EventSource<T>	EventSource is an EventSink that serves also as an EventStream - every value pushed to EventSource is immediately emitted by it.
class	EventStreamBase<T>	Base class for event streams.
private static final class	EventStreams.Never<T>
(package private) class	FilterMapStream<T,U>
(package private) class	FilterStream<T>
(package private) class	FlatMapOptStream<T,U>
(package private) class	FlatMapStream<T,U>	See EventStream.flatMap(Function)
(package private) final class	ForgetfulEventStream<T>	See EventStream.forgetful()
(package private) class	HookStream<T>
(package private) class	LatestNStream<T>	See EventStream.latestN(int)
(package private) class	MappedStream<T,U>	See EventStream.map(Function)
(package private) class	MappedToCompletionStageStream<T,U>
(package private) class	MappedToTaskStream<T,U>
(package private) final class	PausableEventStream<T>	See EventStream.pausable()
(package private) class	RecursiveStream<T>
(package private) final class	ReducibleEventStream<T>	See EventStream.reducible(BinaryOperator)
(package private) class	RepeatOnStream<T>	See EventStream.repeatOn(EventStream)
(package private) class	StatefulStream<S,O>
(package private) class	StateStream<S>
(package private) class	SuccessionReducingStream<I,O>
(package private) final class	SuppressibleEventStream<T>
(package private) class	SuspendableEventStreamBase<T,A>
(package private) class	SuspendedWhenStream<T>
(package private) class	SuspenderStreamImpl<T, S extends Suspendable>
(package private) class	ThenAccumulateForStream<T,A>
(package private) class	ThreadBridge<T>

Fields in org.reactfx declared as EventStream

Modifier and Type	Field	Description
private final EventStream<?>	AwaitLatest.cancelImpulse
private final EventStream<I>	EmitBothOnEachStream.impulse
private final EventStream<?>	EmitOnEachStream.impulse
private final EventStream<?>	EmitOnStream.impulse
private final EventStream<?>	RepeatOnStream.impulse
private final EventStream<T>	AccumulatingStream.input
private final EventStream<T>	DefaultEventStream.input
private final EventStream<T>	DistinctStream.input
private final EventStream<T>	MappedStream.input
private final EventStream<I>	ObservableStateBuilderOnImpl.input
private final EventStream<T>	RecursiveStream.input
private final EventStream<I>	StatefulStreamBuilderOnImpl.input
private final EventStream<I>	SuccessionReducingStream.input
private final EventStream<T>	SuspendableBase.input
private final EventStream<T>	ThenAccumulateForStream.input
private final EventStream<T>	ThreadBridge.input
private static final EventStream<?>	EventStreams.NEVER
private final EventStream<T>	AccumulateBetweenStream.source
private final EventStream<T>	AccumulateUntilLaterStream.source
private final EventStream<F>	Await.source
private final EventStream<F>	AwaitLatest.source
private final EventStream<A>	EmitBothOnEachStream.source
private final EventStream<T>	EmitOnEachStream.source
private final EventStream<T>	EmitOnStream.source
private final EventStream<T>	FilterMapStream.source
private final EventStream<T>	FilterStream.source
private final EventStream<T>	FlatMapOptStream.source
private final EventStream<T>	FlatMapStream.source
private final EventStream<T>	HookStream.source
private final EventStream<T>	LatestNStream.source
private final EventStream<T>	RepeatOnStream.source
private final EventStream<T>	SuspenderStreamImpl.source
private final EventStream<?>	AccumulateBetweenStream.ticks

Fields in org.reactfx with type parameters of type EventStream

Modifier and Type	Field	Description
private final Function<? super T, ? extends EventStream<U>>	FlatMapStream.mapper
private MapHelper<EventStream<? extends T>, Subscription>	ConnectableEventSource.subscriptions

Methods in org.reactfx that return EventStream

Modifier and Type	Method	Description
default <U> EventStream<U>	EventStream.accumulate(BiFunction<? super U, ? super T, ? extends U> reduction, Function<? super T, ? extends U> initialTransformation)	Returns an event stream that accumulates events emitted from this event stream and emits the accumulated value every time this stream emits a value.
default EventStream<T>	EventStream.accumulate(BinaryOperator<T> reduction)	Returns an event stream that accumulates events emitted from this event stream and emits the accumulated value every time this stream emits a value.
default <U> EventStream<U>	EventStream.accumulate(U unit, BiFunction<? super U, ? super T, ? extends U> reduction)	Returns an event stream that accumulates events emitted from this event stream and emits the accumulated value every time this stream emits a value.
default <A> EventStream<T>	EventStream.accumulateBetween(EventStream<?> ticks, Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction)	Returns an event stream that, when an event arrives from this stream, transforms it into a cumulative value using the initialTransformation function.
default <A> EventStream<T>	EventStream.accumulateBetween(EventStream<?> ticks, Supplier<? extends A> unit, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction)	A variation on EventStream.accumulateBetween(EventStream, Function, BiFunction, Function) to use when it is more convenient to provide a unit element of the accumulation than to transform the initial event to a cumulative value.
default <A> EventStream<T>	EventStream.accumulateUntilLater(Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction)	Returns an event stream that, when an event is emitted from this stream, transforms the event to a cumulative value using the initialTransformation function and schedules emission using Platform.runLater(Runnable), if not already scheduled.
default <A> EventStream<T>	EventStream.accumulateUntilLater(Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction, Executor eventThreadExecutor)	Version of EventStream.accumulateUntilLater(Function, BiFunction, Function) for event streams that don't live on the JavaFX application thread.
default <A> EventStream<T>	EventStream.accumulateUntilLater(Supplier<? extends A> unit, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction)	A variation on EventStream.accumulateUntilLater(Function, BiFunction, Function) to use when it is more convenient to provide a unit element of the accumulation than to transform the initial event to a cumulative value.
default <A> EventStream<T>	EventStream.accumulateUntilLater(Supplier<? extends A> unit, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction, Executor eventThreadExecutor)	Version of EventStream.accumulateUntilLater(Supplier, BiFunction, Function) for event streams that don't live on the JavaFX application thread.
default <A> EventStream<T>	EventStream.accumulateWhen(javafx.beans.value.ObservableValue<Boolean> condition, Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, AccumulatorSize> size, Function<? super A, ? extends T> head, Function<? super A, ? extends A> tail)	Shortcut for
default <A> EventStream<T>	EventStream.accumulateWhen(javafx.beans.value.ObservableValue<Boolean> condition, Supplier<? extends A> unit, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, AccumulatorSize> size, Function<? super A, ? extends T> head, Function<? super A, ? extends A> tail)	Shortcut for
static EventStream<Long>	EventStreams.animationFrames()	Returns a stream that, on each animation frame, emits the duration elapsed since the previous animation frame, in nanoseconds.
static EventStream<Long>	EventStreams.animationTicks()	Returns an event stream that emits a timestamp of the current frame in nanoseconds on every frame.
default <U extends T> EventStream<U>	EventStream.cast(Class<U> subtype)	Returns a new event stream that emits events emitted by this stream cast to the given type.
static <T> EventStream<Change<T>>	EventStreams.changesOf(javafx.beans.value.ObservableValue<T> observable)
static <T> EventStream<javafx.collections.ListChangeListener.Change<? extends T>>	EventStreams.changesOf(javafx.collections.ObservableList<T> list)
static <K,V> EventStream<javafx.collections.MapChangeListener.Change<? extends K, ? extends V>>	EventStreams.changesOf(javafx.collections.ObservableMap<K,V> map)
static <T> EventStream<javafx.collections.SetChangeListener.Change<? extends T>>	EventStreams.changesOf(javafx.collections.ObservableSet<T> set)
static <A,B> EventStream<Tuple2<A,B>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB)
static <A,B,C> EventStream<Tuple3<A,B,C>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC)
static <A,B,C,D> EventStream<Tuple4<A,B,C,D>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC, EventStream<D> srcD)
static <A,B,C,D,E> EventStream<Tuple5<A,B,C,D,E>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC, EventStream<D> srcD, EventStream<E> srcE)
static <A,B,C,D,E,F> EventStream<Tuple6<A,B,C,D,E,F>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC, EventStream<D> srcD, EventStream<E> srcE, EventStream<F> srcF)
default EventStream<T>	EventStream.conditionOn(javafx.beans.value.ObservableValue<Boolean> condition)	Returns a new EventStream that only observes this EventStream when condition is true.
default EventStream<T>	EventStream.conditionOnShowing(javafx.scene.Node node)	Equivalent to EventStream.conditionOn(ObservableValue) where the condition is that node is showing: it is part of a scene graph (Node.sceneProperty() is not null), its scene is part of a window (Scene.windowProperty() is not null) and the window is showing (Window.showingProperty() is true).
private static <T> EventStream<T>	EventStreams.create(Supplier<? extends T> computeValue, javafx.beans.Observable... dependencies)
default EventStream<T>	EventStream.distinct()	Returns a new event stream that emits repetitive events only once.
default <I> EventStream<Tuple2<T,I>>	EventStream.emitBothOnEach(EventStream<I> impulse)	Similar to EventStream.emitOnEach(EventStream), but also includes the impulse in the emitted value.
default EventStream<T>	EventStream.emitOn(EventStream<?> impulse)	Returns a new event stream that, when an event arrives from the impulse stream, emits the most recent event emitted by this stream.
default EventStream<T>	EventStream.emitOnEach(EventStream<?> impulse)	Returns a new event stream that, when an event arrives from the impulse stream, emits the most recent event emitted by this stream.
static <T extends javafx.event.Event> EventStream<T>	EventStreams.eventsOf(javafx.scene.control.MenuItem menuItem, javafx.event.EventType<T> eventType)
static <T extends javafx.event.Event> EventStream<T>	EventStreams.eventsOf(javafx.scene.Node node, javafx.event.EventType<T> eventType)
static <T extends javafx.event.Event> EventStream<T>	EventStreams.eventsOf(javafx.scene.Scene scene, javafx.event.EventType<T> eventType)
static <T extends javafx.event.Event> EventStream<T>	EventStreams.eventsOf(javafx.stage.Window window, javafx.event.EventType<T> eventType)
default <U extends T> EventStream<U>	EventStream.filter(Class<U> subtype)	Filters this event stream by the runtime type of the values.
default EventStream<T>	EventStream.filter(Predicate<? super T> predicate)	Returns a new event stream that emits events emitted from this stream that satisfy the given predicate.
default <U> EventStream<U>	EventStream.filterMap(Function<? super T, Optional<U>> f)	Equivalent to
default <U> EventStream<U>	EventStream.filterMap(Predicate<? super T> predicate, Function<? super T, ? extends U> f)	A more efficient equivalent to filter(predicate).map(f).
default <U> EventStream<U>	EventStream.flatMap(Function<? super T, ? extends EventStream<U>> f)	Returns a new event stream that, for each event x emitted from this stream, obtains the event stream f(x) and keeps emitting its events until the next event is emitted from this stream.
default EventStream<T>	EventStream.guardedBy(Guardian... guardians)	Deprecated. Use EventStream.suspenderOf(Suspendable) instead.
default EventStream<T>	EventStream.hook(Consumer<? super T> sideEffect)	Returns an event stream that emits the same(*) events as this stream, but before emitting each event performs the given side effect.
static EventStream<Void>	EventStreams.invalidationsOf(javafx.beans.Observable observable)	Creates an event stream that emits an impulse on every invalidation of the given observable.
default EventStream<List<T>>	EventStream.latestN(int n)	Returns an event stream that emits lists of n latest events emitted from this stream.
default <U> EventStream<U>	EventStream.map(Function<? super T, ? extends U> f)	Returns a new event stream that applies the given function to every value emitted from this stream and emits the result.
static <T> EventStream<T>	EventStreams.merge(javafx.collections.ObservableSet<? extends EventStream<T>> set)	Returns an event stream that emits all the events emitted from any of the event streams in the given observable set.
static <T,U> EventStream<U>	EventStreams.merge(javafx.collections.ObservableSet<? extends T> set, Function<? super T, ? extends EventStream<U>> f)	A more general version of EventStreams.merge(ObservableSet) for a set of arbitrary element type and a function to obtain an event stream from the element.
static <T> EventStream<T>	EventStreams.merge(EventStream<? extends T>... inputs)	Returns an event stream that emits all the events emitted from any of the inputs.
static <T> EventStream<T>	EventStreams.never()	Returns an event stream that never emits any value.
EventStream<?>	SuspendableBoolean.noes()
static <T> EventStream<T>	EventStreams.nonNullValuesOf(javafx.beans.value.ObservableValue<T> observable)
EventStream<Void>	Indicator.offs()	Deprecated.
default <A> EventStream<T>	EventStream.onRecurseAccumulate(Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> reduction, Function<? super A, AccumulatorSize> size, Function<? super A, ? extends T> head, Function<? super A, ? extends A> tail)
default <A> EventStream<T>	EventStream.onRecurseAccumulate(Supplier<? extends A> unit, BiFunction<? super A, ? super T, ? extends A> reduction, Function<? super A, AccumulatorSize> size, Function<? super A, ? extends T> head, Function<? super A, ? extends A> tail)
default EventStream<T>	EventStream.onRecurseQueue()
default EventStream<T>	EventStream.onRecurseReduce(BinaryOperator<T> reduction)
default EventStream<T>	EventStream.onRecurseRetainLatest()
EventStream<Void>	Indicator.ons()	Deprecated.
default <U> EventStream<Either<T,U>>	EventStream.or(EventStream<? extends U> right)	Returns an event stream that emits all the events emitted from either this stream or the right stream.
default EventStream<T>	EventStream.pauseWhen(javafx.beans.value.ObservableValue<Boolean> condition)	Shortcut for pausable().suspendedWhen(condition).
default EventStream<T>	EventStream.queueBetween(EventStream<?> ticks)	Returns an event stream that, when an event arrives from this stream, enqueues it for emission.
default EventStream<T>	EventStream.queueUntilLater()	Returns an event stream that, when an event is emitted from this stream, enqueues the event for emission and schedules emission using Platform.runLater(Runnable), if not already scheduled.
default EventStream<T>	EventStream.queueUntilLater(Executor eventThreadExecutor)	Version of EventStream.queueUntilLater() for event streams that don't live on the JavaFX application thread.
default EventStream<T>	EventStream.reduceBetween(EventStream<?> ticks, BinaryOperator<T> reduction)	Returns an event stream that, when an event arrives from this stream, stores it for emission.
default EventStream<T>	EventStream.reduceUntilLater(BinaryOperator<T> reduction)	Returns an event stream that, when an event is emitted from this stream, stores the event for emission and schedules emission using Platform.runLater(Runnable), if not already scheduled.
default EventStream<T>	EventStream.reduceUntilLater(BinaryOperator<T> reduction, Executor eventThreadExecutor)	Version of EventStream.reduceUntilLater(BinaryOperator) for event streams that don't live on the JavaFX application thread.
default EventStream<T>	EventStream.reduceWhen(javafx.beans.value.ObservableValue<Boolean> condition, BinaryOperator<T> reduction)	Shortcut for reducible(reduction).suspendedWhen(condition).
default EventStream<T>	EventStream.repeatOn(EventStream<?> impulse)	Returns a new event stream that emits all the events emitted from this stream and in addition to that re-emits the most recent event on every event emitted from impulse.
static <O extends javafx.beans.Observable> EventStream<O>	EventStreams.repeatOnInvalidation(O observable)	Creates an event stream that emits the given observable immediately for every subscriber and re-emits it on every subsequent invalidation of the observable.
static EventStream<?>	EventStreams.restartableTicks(Duration interval, EventStream<?> impulse)	Returns a EventStreams.ticks(Duration) EventStream whose timer restarts whenever impulse emits an event.
static EventStream<?>	EventStreams.restartableTicks0(Duration interval, EventStream<?> impulse)	Returns a EventStreams.ticks0(Duration) EventStream whose timer restarts whenever impulse emits an event.
default EventStream<T>	EventStream.retainLatestBetween(EventStream<?> ticks)	Equivalent to EventStream.emitOn(EventStream).
default EventStream<T>	EventStream.retainLatestUntilLater()	Returns an event stream that, when an event is emitted from this stream, stores the event for emission and schedules emission using Platform.runLater(Runnable), if not already scheduled.
default EventStream<T>	EventStream.retainLatestUntilLater(Executor eventThreadExecutor)	Version of EventStream.retainLatestUntilLater() for event streams that don't live on the JavaFX application thread.
default EventStream<T>	EventStream.retainLatestWhen(javafx.beans.value.ObservableValue<Boolean> condition)	Shortcut for forgetful().suspendedWhen(condition).
static <T> EventStream<ListModification<? extends T>>	EventStreams.simpleChangesOf(javafx.collections.ObservableList<T> list)	Use only when the subscriber does not cause list modification of the underlying list.
static <C extends Collection<?> & javafx.beans.Observable> EventStream<Integer>	EventStreams.sizeOf(C collection)
static EventStream<Integer>	EventStreams.sizeOf(javafx.collections.ObservableMap<?,?> map)
default EventStream<Either<T,T>>	EventStream.splitBy(Predicate<? super T> test)	Returns a new event stream that, for event e emitted from this stream, emits left(e) if e passes the given test, and emits right(e) if e does not pass the test.
default <U> EventStream<U>	EventStream.supply(Supplier<? extends U> f)	Returns an event stream that emits a value obtained from the given supplier every time this event stream emits a value.
default <U> EventStream<U>	EventStream.supply(U value)	Returns an event stream that emits the given constant value every time this stream emits a value.
default EventStream<T>	EventStream.suppressWhen(javafx.beans.value.ObservableValue<Boolean> condition)	Shortcut for suppressible().suspendedWhen(condition).
default EventStream<T>	SuspendableEventStream.suspendedWhen(javafx.beans.value.ObservableValue<Boolean> condition)	Returns an event stream that is suspended when the given condition is true and emits normally when condition is false.
default EventStream<T>	EventStream.threadBridge(Executor sourceThreadExecutor, Executor targetThreadExecutor)	Transfers events from one thread to another.
default EventStream<T>	EventStream.threadBridgeFromFx(Executor targetThreadExecutor)	Transfers events from the JavaFX application thread to another thread.
default EventStream<T>	EventStream.threadBridgeToFx(Executor sourceThreadExecutor)	Transfers events to the JavaFX application thread.
static EventStream<?>	EventStreams.ticks(Duration interval)	Returns an event stream that emits periodic ticks.
static EventStream<?>	EventStreams.ticks(Duration interval, ScheduledExecutorService scheduler, Executor eventThreadExecutor)	Returns an event stream that emits periodic ticks on the given eventThreadExecutor.
static EventStream<?>	EventStreams.ticks0(Duration interval)	Returns an event stream that emits periodic ticks.
EventStream<O>	StatefulStreamBuilderImpl.toEventStream()
EventStream<O>	StateMachine.StatefulStreamBuilder.toEventStream()	Returns an event stream that emits a value when one of the state machine's input streams causes the state machine to emit a value.
EventStream<S>	ObservableStateBuilderImpl.toStateStream()
EventStream<S>	StateMachine.ObservableStateBuilder.toStateStream()	Returns an event stream that emits the current state of the state machine every time it changes.
static <T> EventStream<T>	EventStreams.valuesOf(javafx.beans.value.ObservableValue<T> observable)	Creates an event stream that emits the value of the given ObservableValue immediately for every subscriber and then on every change.
default EventStream<T>	EventStream.withDefaultEvent(T defaultEvent)	Returns an event stream that immediately emits its event when something subscribes to it.
EventStream<?>	SuspendableBoolean.yeses()
static <A,B> EventStream<Tuple2<A,B>>	EventStreams.zip(EventStream<A> srcA, EventStream<B> srcB)
static <A,B,C> EventStream<Tuple3<A,B,C>>	EventStreams.zip(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC)

Methods in org.reactfx that return types with arguments of type EventStream

Modifier and Type	Method	Description
default Tuple2<EventStream<T>, EventStream<T>>	EventStream.fork(Predicate<? super T> test)	Returns two event streams, the first one emitting events of this stream that satisfy the given test and the second one emitting events of this stream that do not satisfy the test.
default Tuple2<EventStream<T>, EventStream<T>>	EventStream.fork(Predicate<? super T> test)	Returns two event streams, the first one emitting events of this stream that satisfy the given test and the second one emitting events of this stream that do not satisfy the test.
static <L,R> Tuple2<EventStream<L>, EventStream<R>>	EventStreams.fork(EventStream<? extends Either<L,R>> stream)
static <L,R> Tuple2<EventStream<L>, EventStream<R>>	EventStreams.fork(EventStream<? extends Either<L,R>> stream)

Methods in org.reactfx with parameters of type EventStream

Modifier and Type	Method	Description
default <A> EventStream<T>	EventStream.accumulateBetween(EventStream<?> ticks, Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction)	Returns an event stream that, when an event arrives from this stream, transforms it into a cumulative value using the initialTransformation function.
default <A> EventStream<T>	EventStream.accumulateBetween(EventStream<?> ticks, Supplier<? extends A> unit, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction)	A variation on EventStream.accumulateBetween(EventStream, Function, BiFunction, Function) to use when it is more convenient to provide a unit element of the accumulation than to transform the initial event to a cumulative value.
static <T> AwaitingEventStream<Try<T>>	Await.awaitCompletionStage(EventStream<CompletionStage<T>> source, Executor clientThreadExecutor)
static <T> AwaitingEventStream<Try<T>>	AwaitLatest.awaitCompletionStage(EventStream<CompletionStage<T>> source, Executor clientThreadExecutor)
static <T> AwaitingEventStream<Try<T>>	AwaitLatest.awaitCompletionStage(EventStream<CompletionStage<T>> source, EventStream<?> cancelImpulse, Executor clientThreadExecutor)
default AwaitingEventStream<Try<T>>	CompletionStageStream.awaitLatest(EventStream<?> canceller)	Similar to CompletionStageStream.awaitLatest(), with one addition: When an event is emitted from canceller, if the completion stage most recently emitted from this stream has not yet completed, its result is discarded (i.e.
default AwaitingEventStream<Try<T>>	CompletionStageStream.awaitLatest(EventStream<?> canceller, Executor clientThreadExecutor)	A variant of CompletionStageStream.awaitLatest(EventStream) for streams that do not live on the JavaFX application thread.
default AwaitingEventStream<Try<T>>	TaskStream.awaitLatest(EventStream<?> canceller)	Similar to TaskStream.awaitLatest(), with one addition: When an event is emitted from canceller, if the task most recently emitted from this stream has not yet completed, it is cancelled and its result discarded (i.e.
static <T> AwaitingEventStream<Try<T>>	Await.awaitTask(EventStream<javafx.concurrent.Task<T>> source)
static <T> AwaitingEventStream<Try<T>>	AwaitLatest.awaitTask(EventStream<javafx.concurrent.Task<T>> source)
static <T> AwaitingEventStream<Try<T>>	AwaitLatest.awaitTask(EventStream<javafx.concurrent.Task<T>> source, EventStream<?> cancelImpulse)
static <A,B> EventStream<Tuple2<A,B>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB)
static <A,B,C> EventStream<Tuple3<A,B,C>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC)
static <A,B,C,D> EventStream<Tuple4<A,B,C,D>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC, EventStream<D> srcD)
static <A,B,C,D,E> EventStream<Tuple5<A,B,C,D,E>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC, EventStream<D> srcD, EventStream<E> srcE)
static <A,B,C,D,E,F> EventStream<Tuple6<A,B,C,D,E,F>>	EventStreams.combine(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC, EventStream<D> srcD, EventStream<E> srcE, EventStream<F> srcF)
Subscription	Connectable.connectTo(EventStream<? extends T> source)	Connects this connectable object to source event stream.
Subscription	ConnectableEventSource.connectTo(EventStream<? extends T> input)
default <I> EventStream<Tuple2<T,I>>	EventStream.emitBothOnEach(EventStream<I> impulse)	Similar to EventStream.emitOnEach(EventStream), but also includes the impulse in the emitted value.
default EventStream<T>	EventStream.emitOn(EventStream<?> impulse)	Returns a new event stream that, when an event arrives from the impulse stream, emits the most recent event emitted by this stream.
default EventStream<T>	EventStream.emitOnEach(EventStream<?> impulse)	Returns a new event stream that, when an event arrives from the impulse stream, emits the most recent event emitted by this stream.
default Subscription	EventSink.feedFrom(EventStream<? extends T> source)	Starts pushing all events emitted by source to this event sink.
static <L,R> Tuple2<EventStream<L>, EventStream<R>>	EventStreams.fork(EventStream<? extends Either<L,R>> stream)
static <T> EventStream<T>	EventStreams.merge(EventStream<? extends T>... inputs)	Returns an event stream that emits all the events emitted from any of the inputs.
<I> StateMachine.ObservableStateBuilderOn<S,I>	InitialStateImpl.on(EventStream<I> input)
<I> StateMachine.ObservableStateBuilderOn<S,I>	ObservableStateBuilderImpl.on(EventStream<I> input)
<I> StateMachine.StatefulStreamBuilderOn<S,O,I>	StatefulStreamBuilderImpl.on(EventStream<I> input)
<I> StateMachine.ObservableStateBuilderOn<S,I>	StateMachine.InitialState.on(EventStream<I> input)
<I> StateMachine.ObservableStateBuilderOn<S,I>	StateMachine.ObservableStateBuilder.on(EventStream<I> input)
<I> StateMachine.StatefulStreamBuilderOn<S,O,I>	StateMachine.StatefulStreamBuilder.on(EventStream<I> input)
default <U> EventStream<Either<T,U>>	EventStream.or(EventStream<? extends U> right)	Returns an event stream that emits all the events emitted from either this stream or the right stream.
default EventStream<T>	EventStream.queueBetween(EventStream<?> ticks)	Returns an event stream that, when an event arrives from this stream, enqueues it for emission.
default EventStream<T>	EventStream.reduceBetween(EventStream<?> ticks, BinaryOperator<T> reduction)	Returns an event stream that, when an event arrives from this stream, stores it for emission.
default EventStream<T>	EventStream.repeatOn(EventStream<?> impulse)	Returns a new event stream that emits all the events emitted from this stream and in addition to that re-emits the most recent event on every event emitted from impulse.
static EventStream<?>	EventStreams.restartableTicks(Duration interval, EventStream<?> impulse)	Returns a EventStreams.ticks(Duration) EventStream whose timer restarts whenever impulse emits an event.
static EventStream<?>	EventStreams.restartableTicks0(Duration interval, EventStream<?> impulse)	Returns a EventStreams.ticks0(Duration) EventStream whose timer restarts whenever impulse emits an event.
default EventStream<T>	EventStream.retainLatestBetween(EventStream<?> ticks)	Equivalent to EventStream.emitOn(EventStream).
(package private) Subscription	LimitedInvocationSubscriber.subscribeTo(EventStream<? extends T> stream)
private final Subscription	ConnectableEventSource.subscribeToInput(EventStream<? extends T> input)
static <A,B> EventStream<Tuple2<A,B>>	EventStreams.zip(EventStream<A> srcA, EventStream<B> srcB)
static <A,B,C> EventStream<Tuple3<A,B,C>>	EventStreams.zip(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC)

Method parameters in org.reactfx with type arguments of type EventStream

Modifier and Type	Method	Description
default <U> EventStream<U>	EventStream.flatMap(Function<? super T, ? extends EventStream<U>> f)	Returns a new event stream that, for each event x emitted from this stream, obtains the event stream f(x) and keeps emitting its events until the next event is emitted from this stream.
static <T> EventStream<T>	EventStreams.merge(javafx.collections.ObservableSet<? extends EventStream<T>> set)	Returns an event stream that emits all the events emitted from any of the event streams in the given observable set.
static <T,U> EventStream<U>	EventStreams.merge(javafx.collections.ObservableSet<? extends T> set, Function<? super T, ? extends EventStream<U>> f)	A more general version of EventStreams.merge(ObservableSet) for a set of arbitrary element type and a function to obtain an event stream from the element.

Constructors in org.reactfx with parameters of type EventStream

Modifier	Constructor	Description
protected	AbstractReducibleEventStream(EventStream<T> source, NotificationAccumulator<Consumer<? super T>, T, T> pn)
	AccumulateBetweenStream(EventStream<T> source, EventStream<?> ticks, Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction)
	AccumulateUntilLaterStream(EventStream<T> source, Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, List<T>> deconstruction, Executor eventThreadExecutor)
	AccumulatingStream(EventStream<T> input, Function<? super T, ? extends U> initial, BiFunction<? super U, ? super T, ? extends U> reduction)
(package private)	AccumulativeEventStream(EventStream<T> source, Function<? super T, ? extends A> initialTransformation, BiFunction<? super A, ? super T, ? extends A> accumulation, Function<? super A, AccumulatorSize> size, Function<? super A, ? extends T> head, Function<? super A, ? extends A> tail)
private	Await(EventStream<F> source, BiConsumer<F, TriConsumer<T, Throwable, Boolean>> addCompletionHandler)
private	AwaitLatest(EventStream<F> source, EventStream<?> cancelImpulse, Consumer<F> canceller, BiConsumer<F, TriConsumer<T, Throwable, Boolean>> addCompletionHandler)
	DefaultEventStream(EventStream<T> input, T initial)
	DistinctStream(EventStream<T> input)
<I>	EmissionBuilder(EventStream<I> input, BiFunction<? super S, ? super I, ? extends Optional<O>> f)
	EmitBothOnEachStream(EventStream<A> source, EventStream<I> impulse)
	EmitOnEachStream(EventStream<T> source, EventStream<?> impulse)
	EmitOnStream(EventStream<T> source, EventStream<?> impulse)
	FilterMapStream(EventStream<T> source, Predicate<? super T> predicate, Function<? super T, ? extends U> f)
	FilterStream(EventStream<T> source, Predicate<? super T> predicate)
	FlatMapOptStream(EventStream<T> src, Function<? super T, Optional<U>> f)
	FlatMapStream(EventStream<T> src, Function<? super T, ? extends EventStream<U>> f)
(package private)	ForgetfulEventStream(EventStream<T> source)
	HookStream(EventStream<T> source, Consumer<? super T> sideEffect)
<I>	InputHandlerBuilder(EventStream<I> input, BiFunction<? super S, ? super I, ? extends TGT> f)
	LatestNStream(EventStream<T> source, int n)
	MappedStream(EventStream<T> input, Function<? super T, ? extends U> f)
	MappedToCompletionStageStream(EventStream<T> input, Function<? super T, CompletionStage<U>> f)
	MappedToTaskStream(EventStream<T> input, Function<? super T, javafx.concurrent.Task<U>> f)
(package private)	ObservableStateBuilderOnImpl(S initialState, LL<TransitionBuilder<S>> transitions, EventStream<I> input)
(package private)	PausableEventStream(EventStream<T> source)
	RecursiveStream(EventStream<T> input, NotificationAccumulator<Consumer<? super T>, T, ?> pn)
	ReducibleEventStream(EventStream<T> source, BinaryOperator<T> reduction)
	RepeatOnStream(EventStream<T> source, EventStream<?> impulse)
(package private)	StatefulStreamBuilderOnImpl(S initialState, LL<TransitionBuilder<S>> transitions, LL<EmissionBuilder<S,O>> emissions, LL<TransmissionBuilder<S,O>> transmissions, EventStream<I> input)
	StreamBinding(EventStream<T> input, T initialValue)
	SuccessionReducingStream(EventStream<I> input, Function<? super I, ? extends O> initial, BiFunction<? super O, ? super I, ? extends O> reduction, Function<Runnable,Timer> timerFactory)
(package private)	SuppressibleEventStream(EventStream<T> source)
protected	SuspendableBase(EventStream<T> input, NotificationAccumulator<O,T,A> pn)
protected	SuspendableEventStreamBase(EventStream<T> source, NotificationAccumulator<Consumer<? super T>, T, A> pn)
	SuspenderStreamImpl(EventStream<T> source, S suspendable)
	ThenAccumulateForStream(EventStream<T> input, Function<? super T, ? extends A> initial, BiFunction<? super A, ? super T, ? extends A> reduction, Function<? super A, List<T>> deconstruction, Function<Runnable,Timer> timerFactory)
	ThreadBridge(EventStream<T> input, Executor sourceThreadExecutor, Executor targetThreadExecutor)
<I>	TransitionBuilder(EventStream<I> input, BiFunction<? super S, ? super I, ? extends S> f)
<I>	TransmissionBuilder(EventStream<I> input, BiFunction<? super S, ? super I, ? extends Tuple2<S, Optional<O>>> f)

Constructor parameters in org.reactfx with type arguments of type EventStream

Modifier	Constructor	Description
	FlatMapStream(EventStream<T> src, Function<? super T, ? extends EventStream<U>> f)

Uses of EventStream in org.reactfx.collection

Methods in org.reactfx.collection that return EventStream

Modifier and Type	Method	Description
default EventStream<ListChange<? extends E>>	LiveList.changes()
static <E> EventStream<ListChange<? extends E>>	LiveList.changesOf(javafx.collections.ObservableList<E> list)
default EventStream<ListModification<? extends E>>	LiveList.modifications()
default EventStream<QuasiListChange<? extends E>>	LiveList.quasiChanges()
static <E> EventStream<QuasiListChange<? extends E>>	LiveList.quasiChangesOf(javafx.collections.ObservableList<E> list)
default EventStream<QuasiListModification<? extends E>>	LiveList.quasiModifications()

Uses of EventStream in org.reactfx.value

Methods in org.reactfx.value that return EventStream

Modifier and Type	Method	Description
default EventStream<Change<T>>	Val.changes()	Returns a stream of changed values, which emits the changed value (i.e.
default EventStream<T>	Val.invalidations()	Returns a stream of invalidated values, which emits the invalidated value (i.e.
default EventStream<T>	Val.values()	Returns a stream of values of this Val.

Methods in org.reactfx.value with parameters of type EventStream

Modifier and Type	Method	Description
static <T> Val<T>	Val.create(Supplier<? extends T> computeValue, EventStream<?> invalidations)