Package | Description |
---|---|
reactor.groovy.ext | |
reactor.io.net |
Reactive network components are located in this package scope implementing the following exposed contract:
A
ReactorPeer NetServer/NetClient is a Publisher of
ReactorChannel that are themselves Publisher of input data. |
reactor.io.net.http |
Components for writing HTTP-based clients and servers using Reactor abstractions.
|
reactor.io.net.impl.netty |
Implementations of the various TCP abstractions based on Netty.
|
reactor.io.net.impl.netty.http | |
reactor.io.net.impl.netty.tcp | |
reactor.io.net.impl.zmq | |
reactor.io.net.impl.zmq.tcp | |
reactor.rx |
Streams are reactive components derived from Reactive Extensions and implementing Reactive Streams specification.
|
reactor.rx.action |
Actions are Reactive Streams components derived from Reactive Extensions and beyond.
|
reactor.rx.action.aggregation | |
reactor.rx.action.combination | |
reactor.rx.action.conditional | |
reactor.rx.action.control | |
reactor.rx.action.error | |
reactor.rx.action.filter | |
reactor.rx.action.metrics | |
reactor.rx.action.pair | |
reactor.rx.action.passive | |
reactor.rx.action.terminal | |
reactor.rx.action.transformation | |
reactor.rx.broadcast |
Broadcasters are akin to Reactive Extensions Subject.
|
reactor.rx.stream | |
reactor.rx.stream.io |
Stream implementations that provide for IO access, for instance read/read-write persisting streams |
reactor.rx.subscription | |
reactor.rx.subscription.support |
Modifier and Type | Method and Description |
---|---|
static <T> Stream<T> |
StreamExtensions.and(Promise<T> selfType,
Predicate<T> other) |
static <T> Stream<T> |
StreamExtensions.and(Stream<T> selfType,
Predicate<T> other) |
static <SRC,IN> Stream<IN> |
StreamExtensions.decode(org.reactivestreams.Publisher<? extends SRC> publisher,
Codec<SRC,IN,?> codec) |
static <T> Stream<T> |
StreamExtensions.mod(Stream<T> selfType,
BiFunction<T,T,T> other) |
static <T,V> Stream<V> |
StreamExtensions.or(Promise<T> selfType,
Function<T,V> other) |
static <T,V> Stream<V> |
StreamExtensions.or(Stream<T> selfType,
Function<T,V> other) |
static <K,V> Stream<Tuple2<K,V>> |
StreamExtensions.reduceByKey(org.reactivestreams.Publisher<? extends Tuple2<K,V>> selfType,
BiFunction<V,V,V> accumulator) |
static <K,V> Stream<Tuple2<K,V>> |
StreamExtensions.scanByKey(org.reactivestreams.Publisher<? extends Tuple2<K,V>> selfType,
BiFunction<V,V,V> accumulator) |
Modifier and Type | Method and Description |
---|---|
static <T> Stream<T> |
StreamExtensions.and(Stream<T> selfType,
Predicate<T> other) |
static <T> Control |
StreamExtensions.leftShift(Stream<T> selfType,
Consumer<T> other) |
static <T> Stream<T> |
StreamExtensions.mod(Stream<T> selfType,
BiFunction<T,T,T> other) |
static <O,E extends org.reactivestreams.Subscriber<? super O>> |
StreamExtensions.or(Stream<O> selfType,
E other) |
static <T,V> Stream<V> |
StreamExtensions.or(Stream<T> selfType,
Function<T,V> other) |
Modifier and Type | Class and Description |
---|---|
class |
ChannelStream<IN,OUT>
An abstract
ReactorChannel implementation that handles the basic interaction and behave as a Stream . |
Modifier and Type | Method and Description |
---|---|
protected abstract Stream<Tuple2<InetSocketAddress,Integer>> |
ReactorClient.doStart(ReactorChannelHandler<IN,OUT,CONN> handler,
Reconnect reconnect) |
Stream<Tuple2<InetSocketAddress,Integer>> |
ReactorClient.start(ReactorChannelHandler<IN,OUT,CONN> handler,
Reconnect reconnect)
Open a channel to the configured address and return a
Stream that will be populated
by the ChannelStream every time a connection or reconnection is made. |
Stream<Void> |
ChannelStream.writeBufferWith(org.reactivestreams.Publisher<? extends Buffer> source)
Write Buffer directly to be encoded if any codec has been setup
|
Stream<Void> |
ChannelStream.writeWith(org.reactivestreams.Publisher<? extends OUT> source) |
Modifier and Type | Class and Description |
---|---|
class |
HttpChannel<IN,OUT>
A Request/Response
ChannelStream extension that provides for several helpers to control HTTP behavior and
observe its metadata. |
Modifier and Type | Class and Description |
---|---|
class |
NettyChannelStream<IN,OUT>
ReactorChannel implementation that delegates to Netty. |
Modifier and Type | Class and Description |
---|---|
class |
NettyHttpChannel<IN,OUT> |
Modifier and Type | Method and Description |
---|---|
protected Stream<Tuple2<InetSocketAddress,Integer>> |
NettyHttpClient.doStart(ReactorChannelHandler<IN,OUT,HttpChannel<IN,OUT>> handler,
Reconnect reconnect) |
Modifier and Type | Method and Description |
---|---|
protected Stream<Tuple2<InetSocketAddress,Integer>> |
NettyTcpClient.doStart(ReactorChannelHandler<IN,OUT,ChannelStream<IN,OUT>> handler,
Reconnect reconnect) |
Modifier and Type | Class and Description |
---|---|
class |
ZeroMQChannelStream<IN,OUT> |
Modifier and Type | Method and Description |
---|---|
protected Stream<Tuple2<InetSocketAddress,Integer>> |
ZeroMQTcpClient.doStart(ReactorChannelHandler handler,
Reconnect reconnect) |
Modifier and Type | Method and Description |
---|---|
Stream<Void> |
Stream.after()
Only forward onError and onComplete signals into the returned stream.
|
Stream<O> |
Stream.broadcast()
Subscribe a new
Broadcaster and return it for future subscribers interactions. |
Stream<O> |
Stream.broadcastOn(Dispatcher dispatcher)
Subscribe a new
Broadcaster and return it for future subscribers interactions. |
Stream<List<O>> |
Stream.buffer()
Collect incoming values into a
List that will be pushed into the returned Stream every
time getCapacity() has been reached, or flush is triggered. |
Stream<List<O>> |
Stream.buffer(int maxSize)
Collect incoming values into multiple
List buckets that will be pushed into the returned Stream
every time getCapacity() has been reached. |
Stream<List<O>> |
Stream.buffer(int maxSize,
int skip)
Collect incoming values into a
List that will be pushed into the returned Stream every time maxSize has been reached by any of them. |
Stream<List<O>> |
Stream.buffer(int maxSize,
long timespan,
TimeUnit unit)
Collect incoming values into a
List that will be pushed into the returned Stream every
timespan OR maxSize items. |
Stream<List<O>> |
Stream.buffer(int maxSize,
long timespan,
TimeUnit unit,
Timer timer)
Collect incoming values into a
List that will be pushed into the returned Stream every
timespan OR maxSize items |
Stream<List<O>> |
Stream.buffer(long timespan,
long timeshift,
TimeUnit unit)
Collect incoming values into multiple
List buckets created every timeshift that will be pushed
into the returned Stream every
timespan. |
Stream<List<O>> |
Stream.buffer(long timespan,
long timeshift,
TimeUnit unit,
Timer timer)
Collect incoming values into multiple
List buckets created every timeshift that will be pushed
into the returned Stream every
timespan. |
Stream<List<O>> |
Stream.buffer(long timespan,
TimeUnit unit)
Collect incoming values into a
List that will be pushed into the returned Stream every
timespan. |
Stream<List<O>> |
Stream.buffer(long timespan,
TimeUnit unit,
Timer timer)
Collect incoming values into a
List that will be pushed into the returned Stream every
timespan. |
Stream<List<O>> |
Stream.buffer(org.reactivestreams.Publisher<?> bucketOpening,
Supplier<? extends org.reactivestreams.Publisher<?>> boundarySupplier)
Collect incoming values into a
List that will be moved into the returned Stream every time the
passed boundary publisher emits an item. |
Stream<List<O>> |
Stream.buffer(Supplier<? extends org.reactivestreams.Publisher<?>> boundarySupplier)
Collect incoming values into a
List that will be moved into the returned Stream every time the
passed boundary publisher emits an item. |
Stream<O> |
Stream.cache()
Cache all signal to this
Stream and release them on request that will observe any values accepted by this
Stream . |
Stream<O> |
Stream.capacity(long elements)
Bind the stream to a given volume of in-flight data:
- An
Action will request up to the defined volume upstream |
<E> Stream<E> |
Stream.cast(Class<E> stream)
Cast the current Stream flowing data type into a target class type.
|
static <TUPLE extends Tuple,V> |
Streams.combineLatest(List<? extends org.reactivestreams.Publisher<?>> sources,
Function<TUPLE,? extends V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <E,TUPLE extends Tuple,V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<E>> sources,
Function<TUPLE,? extends V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T1,T2,V> Stream<V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
Function<Tuple2<T1,T2>,? extends V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T1,T2,T3,V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
Function<Tuple3<T1,T2,T3>,? extends V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T1,T2,T3,T4,V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
Function<Tuple4<T1,T2,T3,T4>,V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T1,T2,T3,T4,T5,V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
Function<Tuple5<T1,T2,T3,T4,T5>,V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T1,T2,T3,T4,T5,T6,V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
Function<Tuple6<T1,T2,T3,T4,T5,T6>,V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T1,T2,T3,T4,T5,T6,T7,V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
Function<Tuple7<T1,T2,T3,T4,T5,T6,T7>,V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,V> |
Streams.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
org.reactivestreams.Publisher<? extends T8> source8,
Function<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>,? extends V> combinator)
Build a Stream whose data are generated by the combination of the most recent published values from
all publishers.
|
static <T> Stream<T> |
Streams.concat(Iterable<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> concatdPublishers)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6,
org.reactivestreams.Publisher<? extends T> source7)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6,
org.reactivestreams.Publisher<? extends T> source7,
org.reactivestreams.Publisher<? extends T> source8)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
<V> Stream<V> |
Stream.concatMap(Function<? super O,org.reactivestreams.Publisher<? extends V>> fn)
Assign the given
Function to transform the incoming value T into a Stream<O,V> and pass
it into another Stream . |
Stream<O> |
Stream.concatWith(org.reactivestreams.Publisher<? extends O> publisher)
lift(Supplier) all the nested Publisher values from this current upstream and then on
complete consume from the
passed publisher. |
Stream<Long> |
Stream.count()
Count accepted events for each batch and pass each accumulated long to the .
|
Stream<Long> |
Stream.count(long i)
Count accepted events for each batch and pass each accumulated long to the .
|
static <T> Stream<T> |
Streams.create(org.reactivestreams.Publisher<T> publisher)
Build a custom sequence Stream from the passed
Publisher that will be
subscribed on the
first
request from the new subscriber. |
static <T,C> Stream<T> |
Streams.createWith(BiConsumer<Long,SubscriberWithContext<T,C>> requestConsumer,
Function<org.reactivestreams.Subscriber<? super T>,C> contextFactory)
Create a
Stream reacting on requests with the passed BiConsumer
The argument contextFactory is executed once by new subscriber to generate a context shared by every
request calls. |
static <T,C> Stream<T> |
Streams.createWith(BiConsumer<Long,SubscriberWithContext<T,C>> requestConsumer,
Function<org.reactivestreams.Subscriber<? super T>,C> contextFactory,
Consumer<C> shutdownConsumer)
Create a
Stream reacting on requests with the passed BiConsumer . |
static <T> Stream<T> |
Streams.createWith(BiConsumer<Long,SubscriberWithContext<T,Void>> requestConsumer)
Create a
Stream reacting on requests with the passed BiConsumer |
<V> Stream<V> |
Stream.decode(Codec<O,V,?> codec)
Transform a sequence of codec source elements into codec input elements through
Codec.decode(Publisher) |
static <SRC,IN> Stream<IN> |
IOStreams.decode(Codec<SRC,IN,?> codec,
org.reactivestreams.Publisher<? extends SRC> publisher)
|
Stream<O> |
Stream.defaultIfEmpty(O defaultValue)
Create an operation that returns the passed value if the Stream has completed without any emitted signals.
|
static <T> Stream<T> |
Streams.defer(Supplier<? extends org.reactivestreams.Publisher<T>> supplier)
Supply a
Publisher everytime subscribe is called on the returned stream. |
<X> Stream<X> |
Stream.dematerialize()
Transform the incoming onSubscribe, onNext, onError and onComplete signals into
Signal . |
Stream<O> |
Stream.dispatchOn(Dispatcher dispatcher)
Assign a new Dispatcher to the returned Stream.
|
Stream<O> |
Stream.dispatchOn(Environment environment)
Assign a new Environment and its default Dispatcher to the returned Stream.
|
Stream<O> |
Stream.dispatchOn(Environment environment,
Dispatcher dispatcher)
Assign the a new Dispatcher and an Environment to the returned Stream.
|
Stream<O> |
Stream.distinct()
Create a new
Stream that filters in only unique values. |
<V> Stream<O> |
Stream.distinct(Function<? super O,? extends V> keySelector)
Create a new
Stream that filters in only values having distinct keys computed by function |
Stream<O> |
Stream.distinctUntilChanged()
Create a new
Stream that filters out consecutive equals values. |
<V> Stream<O> |
Stream.distinctUntilChanged(Function<? super O,? extends V> keySelector)
Create a new
Stream that filters out consecutive values having equal keys computed by function |
Stream<Tuple2<Long,O>> |
Stream.elapsed()
|
Stream<O> |
Stream.elementAt(int index)
Create a new
Stream that emits an item at a specified index from a source Stream |
Stream<O> |
Stream.elementAtOrDefault(int index,
O defaultValue)
Create a new
Stream that emits an item at a specified index from a source Stream
or default value when index is out of bounds |
static <T> Stream<T> |
Streams.empty()
Build a Stream that will only emit a complete signal to any new subscriber.
|
<V> Stream<V> |
Stream.encode(Codec<V,?,O> codec)
Transform a sequence of codec output elements into codec source elements through
Codec.encode(Publisher) |
Stream<O> |
Stream.env(Environment environment)
Assign an Environment to be provided to this Stream Subscribers
|
Stream<Boolean> |
Stream.exists(Predicate<? super O> predicate)
Create a new
Stream that emits true when any value satisfies a predicate
and false otherwise |
static <O,T extends Throwable> |
Streams.fail(T throwable)
Build a Stream that will only emit an error signal to any new subscriber.
|
<T,V> Stream<V> |
Stream.fanIn(FanInAction<T,?,V,? extends FanInAction.InnerSubscriber<T,?,V>> fanInAction)
lift(Supplier) all the nested Publisher values to a new Stream calling the logic
inside the provided fanInAction for complex merging strategies. |
Stream<Boolean> |
Stream.filter()
Evaluate each accepted boolean value.
|
Stream<O> |
Stream.filter(Predicate<? super O> p)
Evaluate each accepted value against the given
Predicate . |
Stream<O> |
Stream.finallyDo(Consumer<Signal<O>> consumer)
Attach a
Consumer to this Stream that will observe terminal signal complete|error. |
<V> Stream<V> |
Stream.flatMap(Function<? super O,? extends org.reactivestreams.Publisher<? extends V>> fn)
Assign the given
Function to transform the incoming value T into a Stream<O,V> and pass
it into another Stream . |
static <T> Stream<T> |
Streams.from(Future<? extends T> future)
Build a Stream that will only emit the result of the future and then complete.
|
static <T> Stream<T> |
Streams.from(Future<? extends T> future,
long time,
TimeUnit unit)
Build a Stream that will only emit the result of the future and then complete.
|
static <T> Stream<T> |
Streams.from(Iterable<? extends T> values)
Build a Stream whom data is sourced by each element of the passed iterable on subscription request.
|
static <T> Stream<T> |
Streams.from(T[] values)
Build a Stream whom data is sourced by each element of the passed array on subscription request.
|
static <T> Stream<T> |
Streams.generate(Supplier<? extends T> value)
Build a Stream whose data is generated by the passed supplier on subscription request.
|
<K> Stream<GroupedStream<K,O>> |
Stream.groupBy(Function<? super O,? extends K> keyMapper)
Re-route incoming values into a dynamically created
Stream for each unique key evaluated by the
{param keyMapper}. |
Stream<O> |
Stream.ignoreError()
Connect an error-proof action that will transform an incoming error signal into a complete signal.
|
<E> Stream<O> |
Stream.ignoreError(Predicate<? super Throwable> ignorePredicate)
Connect an error-proof action based on the given predicate matching the current error.
|
<V> Stream<List<V>> |
Stream.join()
|
static <T> Stream<List<T>> |
Streams.join(List<? extends org.reactivestreams.Publisher<? extends T>> sources)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<T>> source)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6,
org.reactivestreams.Publisher<? extends T> source7)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
static <T> Stream<List<T>> |
Streams.join(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6,
org.reactivestreams.Publisher<? extends T> source7,
org.reactivestreams.Publisher<? extends T> source8)
Build a Synchronous Stream whose data are aggregated from the passed publishers
(1 element consumed for each merged publisher. resulting in an array of size of .
|
<V> Stream<List<V>> |
Stream.joinWith(org.reactivestreams.Publisher<? extends V> publisher)
|
static <T> Stream<T> |
Streams.just(T value1)
Build a Stream whom data is sourced by the passed element on subscription
request.
|
static <T> Stream<T> |
Streams.just(T value1,
T value2)
Build a Stream whom data is sourced by each element of the passed iterable on subscription
request.
|
static <T> Stream<T> |
Streams.just(T value1,
T value2,
T value3)
Build a Stream whom data is sourced by each element of the passed iterable on subscription
request.
|
static <T> Stream<T> |
Streams.just(T value1,
T value2,
T value3,
T value4)
Build a Stream whom data is sourced by each element of the passed iterable on subscription
request.
|
static <T> Stream<T> |
Streams.just(T value1,
T value2,
T value3,
T value4,
T value5)
Build a Stream whom data is sourced by each element of the passed iterable on subscription
request.
|
static <T> Stream<T> |
Streams.just(T value1,
T value2,
T value3,
T value4,
T value5,
T value6)
Build a Stream whom data is sourced by each element of the passed iterable on subscription
request.
|
static <T> Stream<T> |
Streams.just(T value1,
T value2,
T value3,
T value4,
T value5,
T value6,
T value7)
Build a Stream whom data is sourced by each element of the passed iterable on subscription
request.
|
static <T> Stream<T> |
Streams.just(T value1,
T value2,
T value3,
T value4,
T value5,
T value6,
T value7,
T value8)
Build a Stream whom data is sourced by each element of the passed iterable on subscription
request.
|
Stream<O> |
Stream.keepAlive()
Prevent a
Stream to be cancelled. |
Stream<O> |
Stream.last()
Create a new
Stream that will signal the last element observed before complete signal. |
<V> Stream<V> |
Stream.lift(Supplier<? extends Action<O,V>> action)
Defer the subscription of an
Action to the actual pipeline. |
Stream<O> |
Stream.log()
Attach a
Logger to this Stream that will observe any signal emitted. |
Stream<O> |
Stream.log(String name)
Attach a
Logger to this Stream that will observe any signal emitted. |
<V> Stream<V> |
Stream.map(Function<? super O,? extends V> fn)
Assign the given
Function to transform the incoming value T into a V and pass it into
another Stream . |
Stream<Signal<O>> |
Stream.materialize()
Transform the incoming onSubscribe, onNext, onError and onComplete signals into
Signal . |
<V> Stream<V> |
Stream.merge()
|
static <T> Stream<T> |
Streams.merge(Iterable<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T,E extends T> |
Streams.merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<E>> mergedPublishers)
Build a Synchronous Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2)
Build a Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3)
Build a Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4)
Build a Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5)
Build a Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6)
Build a Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6,
org.reactivestreams.Publisher<? extends T> source7)
Build a Stream whose data are generated by the passed publishers.
|
static <T> Stream<T> |
Streams.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4,
org.reactivestreams.Publisher<? extends T> source5,
org.reactivestreams.Publisher<? extends T> source6,
org.reactivestreams.Publisher<? extends T> source7,
org.reactivestreams.Publisher<? extends T> source8)
Build a Stream whose data are generated by the passed publishers.
|
Stream<O> |
Stream.mergeWith(org.reactivestreams.Publisher<? extends O> publisher)
lift(Supplier) all the nested Publisher values from this current upstream and from the
passed publisher. |
Stream<Stream<O>> |
Stream.nest()
Create a new
Stream whose only value will be the current instance of the Stream . |
static <T> Stream<T> |
Streams.never()
Build a Stream that will never emit anything.
|
Stream<O> |
Stream.observe(Consumer<? super O> consumer)
|
Stream<O> |
Stream.observeCancel(Consumer<Void> consumer)
Attach a
Consumer to this Stream that will observe any cancel signal |
Stream<O> |
Stream.observeComplete(Consumer<Void> consumer)
Attach a
Consumer to this Stream that will observe any complete signal |
<E extends Throwable> |
Stream.observeError(Class<E> exceptionType,
BiConsumer<Object,? super E> onError)
Assign an error handler that will pass eventual associated values and exceptions of the given type.
|
Stream<O> |
Stream.observeStart(Consumer<? super org.reactivestreams.Subscription> consumer)
Attach a
Consumer to this Stream that will observe any onSubscribe signal |
Stream<O> |
Stream.observeSubscribe(Consumer<? super org.reactivestreams.Subscriber<? super O>> consumer)
Attach a
Consumer to this Stream that will observe any subscribe signal |
<E extends Throwable> |
Stream.onErrorResumeNext(Class<E> exceptionType,
org.reactivestreams.Publisher<? extends O> fallback)
Subscribe to a fallback publisher when exceptions of the given type occur, otherwise propagate the error.
|
Stream<O> |
Stream.onErrorResumeNext(org.reactivestreams.Publisher<? extends O> fallback)
Subscribe to a fallback publisher when any exception occurs.
|
<E extends Throwable> |
Stream.onErrorReturn(Class<E> exceptionType,
Function<E,? extends O> fallback)
Produce a default value when exceptions of the given type occur, otherwise propagate the error.
|
Stream<O> |
Stream.onErrorReturn(Function<Throwable,? extends O> fallback)
Produce a default value if any exception occurs.
|
Stream<O> |
Stream.onOverflowBuffer()
Attach a No-Op Action that only serves the purpose of buffering incoming values if not enough demand is signaled
downstream.
|
Stream<O> |
Stream.onOverflowBuffer(Supplier<? extends CompletableQueue<O>> queueSupplier)
Attach a No-Op Action that only serves the purpose of buffering incoming values if not enough demand is signaled
downstream.
|
Stream<O> |
Stream.onOverflowDrop()
Attach a No-Op Action that only serves the purpose of dropping incoming values if not enough demand is signaled
downstream.
|
Stream<GroupedStream<Integer,O>> |
Stream.partition()
Re-route incoming values into a dynamically created
Stream for each unique key evaluated by the
{param keyMapper}. |
Stream<GroupedStream<Integer,O>> |
Stream.partition(int buckets)
Re-route incoming values into a dynamically created
Stream for each unique key evaluated by the
{param keyMapper}. |
static Stream<Long> |
Streams.period(long period)
Build a Stream that will emit ever increasing counter from 0 after on each period from the subscribe
call.
|
static Stream<Long> |
Streams.period(long delay,
long period)
Build a Stream that will emit ever increasing counter from 0 after the time delay on each period.
|
static Stream<Long> |
Streams.period(long delay,
long period,
TimeUnit unit)
Build a Stream that will emit ever increasing counter from 0 after the subscribe call on each period.
|
static Stream<Long> |
Streams.period(long period,
TimeUnit unit)
Build a Stream that will emit ever increasing counter from 0 after the subscribe call on each period.
|
static Stream<Long> |
Streams.period(Timer timer,
long period)
Build a Stream that will emit ever increasing counter from 0 after on each period from the subscribe
call.
|
static Stream<Long> |
Streams.period(Timer timer,
long delay,
long period)
Build a Stream that will emit ever increasing counter from 0 after the time delay on each period.
|
static Stream<Long> |
Streams.period(Timer timer,
long delay,
long period,
TimeUnit unit)
Build a Stream that will emit ever increasing counter from 0 after the time delay on each period.
|
static Stream<Long> |
Streams.period(Timer timer,
long period,
TimeUnit unit)
Build a Stream that will emit ever increasing counter from 0 after the subscribe call on each period.
|
<E> Stream<E> |
Stream.process(org.reactivestreams.Processor<O,E> processor)
Create a
Tap that maintains a reference to the last value seen by this Stream . |
static Stream<Long> |
Streams.range(long start,
long end)
Build a Stream that will only emit a sequence of longs within the specified range and then
complete.
|
Stream<O> |
Stream.recover(Class<? extends Throwable> exceptionType,
org.reactivestreams.Subscriber<Object> recoveredValuesSink)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair if the exception is of
the given type. |
<A> Stream<A> |
Stream.reduce(A initial,
BiFunction<A,? super O,A> fn)
Reduce the values passing through this
Stream into an object A . |
Stream<O> |
Stream.reduce(BiFunction<O,O,O> fn)
Reduce the values passing through this
Stream into an object T . |
static <KEY,VALUE> |
BiStreams.reduceByKey(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
static <KEY,VALUE> |
BiStreams.reduceByKey(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
Map<KEY,VALUE> store,
org.reactivestreams.Publisher<? extends MapStream.Signal<KEY,VALUE>> listener,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
static <KEY,VALUE> |
BiStreams.reduceByKey(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
MapStream<KEY,VALUE> mapStream,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
static <KEY,VALUE> |
BiStreams.reduceByKeyOn(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
Map<KEY,VALUE> store,
org.reactivestreams.Publisher<? extends MapStream.Signal<KEY,VALUE>> listener,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
Stream<O> |
Stream.repeat()
Create a new
Stream which will keep re-subscribing its oldest parent-child stream pair on complete. |
Stream<O> |
Stream.repeat(int numRepeat)
Create a new
Stream which will keep re-subscribing its oldest parent-child stream pair on complete. |
Stream<O> |
Stream.repeatWhen(Function<? super Stream<? extends Long>,? extends org.reactivestreams.Publisher<?>> backOffStream)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair if the backOff stream
produced by the passed mapper emits any next signal. |
Stream<O> |
Stream.requestWhen(Function<? super Stream<? extends Long>,? extends org.reactivestreams.Publisher<? extends Long>> throttleStream)
Request the parent stream every time the passed throttleStream signals a Long request volume.
|
Stream<O> |
Stream.retry()
Create a new
Stream which will re-subscribe its oldest parent-child stream pair. |
Stream<O> |
Stream.retry(int numRetries)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair. |
Stream<O> |
Stream.retry(int numRetries,
Predicate<Throwable> retryMatcher)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair. |
Stream<O> |
Stream.retry(Predicate<Throwable> retryMatcher)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair. |
Stream<O> |
Stream.retryWhen(Function<? super Stream<? extends Throwable>,? extends org.reactivestreams.Publisher<?>> backOffStream)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair if the backOff stream
produced by the passed mapper emits any next data or complete signal. |
Stream<O> |
Stream.sample()
Create a new
Stream whose values will be only the last value of each batch. |
Stream<O> |
Stream.sample(int batchSize)
Create a new
Stream whose values will be only the last value of each batch. |
Stream<O> |
Stream.sample(int maxSize,
long timespan,
TimeUnit unit)
Create a new
Stream whose values will be only the last value of each batch. |
Stream<O> |
Stream.sample(int maxSize,
long timespan,
TimeUnit unit,
Timer timer)
Create a new
Stream whose values will be only the last value of each batch. |
Stream<O> |
Stream.sample(long timespan,
TimeUnit unit)
Create a new
Stream whose values will be only the last value of each batch. |
Stream<O> |
Stream.sample(long timespan,
TimeUnit unit,
Timer timer)
Create a new
Stream whose values will be only the last value of each batch. |
Stream<O> |
Stream.sampleFirst()
Create a new
Stream whose values will be only the first value of each batch. |
Stream<O> |
Stream.sampleFirst(int batchSize)
Create a new
Stream whose values will be only the first value of each batch. |
Stream<O> |
Stream.sampleFirst(int maxSize,
long timespan,
TimeUnit unit)
Create a new
Stream whose values will be only the first value of each batch. |
Stream<O> |
Stream.sampleFirst(int maxSize,
long timespan,
TimeUnit unit,
Timer timer)
Create a new
Stream whose values will be only the first value of each batch. |
Stream<O> |
Stream.sampleFirst(long timespan,
TimeUnit unit)
Create a new
Stream whose values will be only the first value of each batch. |
Stream<O> |
Stream.sampleFirst(long timespan,
TimeUnit unit,
Timer timer)
Create a new
Stream whose values will be only the first value of each batch. |
<A> Stream<A> |
Stream.scan(A initial,
BiFunction<A,? super O,A> fn)
Scan the values passing through this
Stream into an object A . |
Stream<O> |
Stream.scan(BiFunction<O,O,O> fn)
Scan the values passing through this
Stream into an object A . |
static <KEY,VALUE> |
BiStreams.scanByKey(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
static <KEY,VALUE> |
BiStreams.scanByKey(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
Map<KEY,VALUE> store,
org.reactivestreams.Publisher<? extends MapStream.Signal<KEY,VALUE>> listener,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
static <KEY,VALUE> |
BiStreams.scanByKey(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
MapStream<KEY,VALUE> mapStream,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
static <KEY,VALUE> |
BiStreams.scanByKeyOn(org.reactivestreams.Publisher<Tuple2<KEY,VALUE>> publisher,
Map<KEY,VALUE> store,
org.reactivestreams.Publisher<? extends MapStream.Signal<KEY,VALUE>> listener,
BiFunction<VALUE,VALUE,VALUE> accumulator) |
Stream<O> |
Stream.skip(long max)
Create a new
Stream that will NOT signal next elements up to times. |
Stream<O> |
Stream.skip(long time,
TimeUnit unit)
Create a new
Stream that will NOT signal next elements up to the specified . |
Stream<O> |
Stream.skip(long time,
TimeUnit unit,
Timer timer)
Create a new
Stream that will NOT signal next elements up to the specified . |
Stream<O> |
Stream.skipWhile(long max,
Predicate<O> limitMatcher)
Create a new
Stream that will NOT signal next elements while is true or
up to times. |
Stream<O> |
Stream.skipWhile(Predicate<O> limitMatcher)
Create a new
Stream that will NOT signal next elements while is true. |
Stream<O> |
Stream.sort()
Stage incoming values into a
PriorityQueue<O> that will be re-ordered and signaled to the
returned fresh Stream . |
Stream<O> |
Stream.sort(Comparator<? super O> comparator)
Stage incoming values into a
PriorityQueue<O> that will be re-ordered and signaled to the
returned fresh Stream . |
Stream<O> |
Stream.sort(int maxCapacity)
Stage incoming values into a
PriorityQueue<O> that will be re-ordered and signaled to the
returned fresh Stream . |
Stream<O> |
Stream.sort(int maxCapacity,
Comparator<? super O> comparator)
Stage incoming values into a
PriorityQueue<O> that will be re-ordered and signaled to the
returned fresh Stream . |
<V> Stream<V> |
Stream.split()
Create a new
Stream whose values will be each element E of any IterableStream . |
<V> Stream<V> |
Stream.split(long batchSize)
Create a new
Stream whose values will be each element E of any IterableStream . |
Stream<O> |
Stream.startWith(Iterable<O> iterable)
Start emitting all items from the passed publisher then emits from the current stream.
|
Stream<O> |
Stream.startWith(O value)
Start emitting all items from the passed publisher then emits from the current stream.
|
Stream<O> |
Stream.startWith(org.reactivestreams.Publisher<? extends O> publisher)
Start emitting all items from the passed publisher then emits from the current stream.
|
Stream<O> |
Promise.stream() |
Stream<O> |
Stream.subscribeOn(Dispatcher currentDispatcher)
Assign a new Dispatcher to handle upstream request to the returned Stream.
|
Stream<O> |
Stream.subscribeOn(Environment environment)
Assign a new Dispatcher to handle upstream request to the returned Stream.
|
<V> Stream<V> |
Stream.switchMap(Function<? super O,org.reactivestreams.Publisher<? extends V>> fn)
Assign the given
Function to transform the incoming value T into a Stream<O,V> and pass
it into another Stream . |
static <T> Stream<T> |
Streams.switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers)
Build a Synchronous Stream whose data are emitted by the most recent passed publisher.
|
static <T> Stream<T> |
Streams.switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers,
Dispatcher dispatcher)
Build a Stream whose data are emitted by the most recent passed publisher.
|
Stream<O> |
Stream.take(long max)
Create a new
Stream that will signal next elements up to times. |
Stream<O> |
Stream.take(long time,
TimeUnit unit)
Create a new
Stream that will signal next elements up to the specified . |
Stream<O> |
Stream.take(long time,
TimeUnit unit,
Timer timer)
Create a new
Stream that will signal next elements up to the specified . |
Stream<O> |
Stream.takeWhile(Predicate<O> limitMatcher)
Create a new
Stream that will signal next elements while is true. |
Stream<O> |
Stream.throttle(long period)
Request once the parent stream every milliseconds.
|
Stream<O> |
Stream.throttle(long period,
Timer timer)
Request once the parent stream every milliseconds after an initial .
|
Stream<O> |
Stream.timeout(long timeout)
Signal an error if no data has been emitted for milliseconds.
|
Stream<O> |
Stream.timeout(long timeout,
TimeUnit unit)
Signal an error if no data has been emitted for milliseconds.
|
Stream<O> |
Stream.timeout(long timeout,
TimeUnit unit,
org.reactivestreams.Publisher<? extends O> fallback)
Switch to the fallback Publisher if no data has been emitted for milliseconds.
|
Stream<O> |
Stream.timeout(long timeout,
TimeUnit unit,
org.reactivestreams.Publisher<? extends O> fallback,
Timer timer)
Signal an error if no data has been emitted for milliseconds.
|
static Stream<Long> |
Streams.timer(long delay)
Build a Stream that will only emit 0l after the time delay and then complete.
|
static Stream<Long> |
Streams.timer(long delay,
TimeUnit unit)
Build a Stream that will only emit 0l after the time delay and then complete.
|
static Stream<Long> |
Streams.timer(Timer timer,
long delay)
Build a Stream that will only emit 0l after the time delay and then complete.
|
static Stream<Long> |
Streams.timer(Timer timer,
long delay,
TimeUnit unit)
Build a Stream that will only emit 0l after the time delay and then complete.
|
Stream<Tuple2<Long,O>> |
Stream.timestamp()
|
Stream<O> |
Stream.unbounded()
Make this Stream subscribers unbounded
|
<E extends Throwable> |
Stream.when(Class<E> exceptionType,
Consumer<E> onError)
Assign an error handler to exceptions of the given type.
|
Stream<Stream<O>> |
Stream.window()
Re-route incoming values into a dynamically created
Stream every pre-defined getCapacity()
times. |
Stream<Stream<O>> |
Stream.window(int backlog)
Re-route incoming values into a dynamically created
Stream every pre-defined times. |
Stream<Stream<O>> |
Stream.window(int maxSize,
int skip)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every skip and complete every time maxSize has been reached by any of them. |
Stream<Stream<O>> |
Stream.window(int maxSize,
long timespan,
TimeUnit unit)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan OR maxSize items. |
Stream<Stream<O>> |
Stream.window(int maxSize,
long timespan,
TimeUnit unit,
Timer timer)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan OR maxSize items. |
Stream<Stream<O>> |
Stream.window(long timespan,
long timeshift,
TimeUnit unit)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every timeshift period. |
Stream<Stream<O>> |
Stream.window(long timespan,
long timeshift,
TimeUnit unit,
Timer timer)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every timeshift period. |
Stream<Stream<O>> |
Stream.window(long timespan,
TimeUnit unit)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan. |
Stream<Stream<O>> |
Stream.window(long timespan,
TimeUnit unit,
Timer timer)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan. |
Stream<Stream<O>> |
Stream.window(org.reactivestreams.Publisher<?> bucketOpening,
Supplier<? extends org.reactivestreams.Publisher<?>> boundarySupplier)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every and
complete every time boundarySupplier stream emits an item. |
Stream<Stream<O>> |
Stream.window(Supplier<? extends org.reactivestreams.Publisher<?>> boundarySupplier)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every and
complete every time boundarySupplier stream emits an item. |
static <T> Stream<T> |
Streams.wrap(org.reactivestreams.Publisher<T> publisher)
A simple decoration of the given
Publisher to expose Stream API and proxy any subscribe call to
the publisher. |
<V> Stream<V> |
Stream.zip(Function<TupleN,? extends V> zipper)
|
static <TUPLE extends Tuple,V> |
Streams.zip(List<? extends org.reactivestreams.Publisher<?>> sources,
Function<TUPLE,? extends V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <E,TUPLE extends Tuple,V> |
Streams.zip(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<E>> sources,
Function<TUPLE,? extends V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <T1,T2,V> Stream<V> |
Streams.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
Function<Tuple2<T1,T2>,? extends V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <T1,T2,T3,V> |
Streams.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
Function<Tuple3<T1,T2,T3>,? extends V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <T1,T2,T3,T4,V> |
Streams.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
Function<Tuple4<T1,T2,T3,T4>,V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <T1,T2,T3,T4,T5,V> |
Streams.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
Function<Tuple5<T1,T2,T3,T4,T5>,V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <T1,T2,T3,T4,T5,T6,V> |
Streams.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
Function<Tuple6<T1,T2,T3,T4,T5,T6>,V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <T1,T2,T3,T4,T5,T6,T7,V> |
Streams.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
Function<Tuple7<T1,T2,T3,T4,T5,T6,T7>,V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,V> |
Streams.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
org.reactivestreams.Publisher<? extends T8> source8,
Function<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>,? extends V> combinator)
Build a Stream whose data are generated by the passed publishers.
|
<T2,V> Stream<V> |
Stream.zipWith(Iterable<? extends T2> iterable,
Function<Tuple2<O,T2>,V> zipper)
|
<T2,V> Stream<V> |
Stream.zipWith(org.reactivestreams.Publisher<? extends T2> publisher,
Function<Tuple2<O,T2>,V> zipper)
|
Modifier and Type | Method and Description |
---|---|
Stream<Stream<O>> |
Stream.nest()
Create a new
Stream whose only value will be the current instance of the Stream . |
Stream<Stream<O>> |
Stream.window()
Re-route incoming values into a dynamically created
Stream every pre-defined getCapacity()
times. |
Stream<Stream<O>> |
Stream.window(int backlog)
Re-route incoming values into a dynamically created
Stream every pre-defined times. |
Stream<Stream<O>> |
Stream.window(int maxSize,
int skip)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every skip and complete every time maxSize has been reached by any of them. |
Stream<Stream<O>> |
Stream.window(int maxSize,
long timespan,
TimeUnit unit)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan OR maxSize items. |
Stream<Stream<O>> |
Stream.window(int maxSize,
long timespan,
TimeUnit unit,
Timer timer)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan OR maxSize items. |
Stream<Stream<O>> |
Stream.window(long timespan,
long timeshift,
TimeUnit unit)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every timeshift period. |
Stream<Stream<O>> |
Stream.window(long timespan,
long timeshift,
TimeUnit unit,
Timer timer)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every timeshift period. |
Stream<Stream<O>> |
Stream.window(long timespan,
TimeUnit unit)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan. |
Stream<Stream<O>> |
Stream.window(long timespan,
TimeUnit unit,
Timer timer)
Re-route incoming values into a dynamically created
Stream every pre-defined timespan. |
Stream<Stream<O>> |
Stream.window(org.reactivestreams.Publisher<?> bucketOpening,
Supplier<? extends org.reactivestreams.Publisher<?>> boundarySupplier)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every and
complete every time boundarySupplier stream emits an item. |
Stream<Stream<O>> |
Stream.window(Supplier<? extends org.reactivestreams.Publisher<?>> boundarySupplier)
Re-route incoming values into bucket streams that will be pushed into the returned
Stream every and
complete every time boundarySupplier stream emits an item. |
Modifier and Type | Method and Description |
---|---|
void |
StreamUtils.StreamVisitor.accept(Stream<?> composable) |
static <O> StreamUtils.StreamVisitor |
StreamUtils.browse(Stream<O> composable) |
static <O> StreamUtils.StreamVisitor |
StreamUtils.browse(Stream<O> composable,
reactor.rx.StreamUtils.DebugVisitor visitor) |
Modifier and Type | Method and Description |
---|---|
Control |
Stream.adaptiveConsume(Consumer<? super O> consumer,
Function<Stream<Long>,? extends org.reactivestreams.Publisher<? extends Long>> requestMapper)
|
Control |
Stream.adaptiveConsumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Function<Stream<Long>,? extends org.reactivestreams.Publisher<? extends Long>> requestMapper)
|
Stream<O> |
Stream.repeatWhen(Function<? super Stream<? extends Long>,? extends org.reactivestreams.Publisher<?>> backOffStream)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair if the backOff stream
produced by the passed mapper emits any next signal. |
Stream<O> |
Stream.requestWhen(Function<? super Stream<? extends Long>,? extends org.reactivestreams.Publisher<? extends Long>> throttleStream)
Request the parent stream every time the passed throttleStream signals a Long request volume.
|
Stream<O> |
Stream.retryWhen(Function<? super Stream<? extends Throwable>,? extends org.reactivestreams.Publisher<?>> backOffStream)
Create a new
Stream which will re-subscribe its oldest parent-child stream pair if the backOff stream
produced by the passed mapper emits any next data or complete signal. |
Modifier and Type | Class and Description |
---|---|
class |
Action<I,O>
An Action is a reactive component to subscribe to a
Publisher and in particular
to a Stream . |
class |
CompositeAction<E,O>
Create a Processor where a given head/tail couple is provided as a Stream (Input upstream) and Action (Output
downstream).
|
Modifier and Type | Method and Description |
---|---|
Stream<O> |
Action.onOverflowBuffer(Supplier<? extends CompletableQueue<O>> queueSupplier) |
Stream<O> |
CompositeAction.output() |
Modifier and Type | Method and Description |
---|---|
<E> Action<I,O> |
Action.control(Stream<E> controlStream,
Consumer<Tuple2<Action<I,O>,? super E>> controller)
Consume a Stream to allow for dynamic
Action update. |
Modifier and Type | Class and Description |
---|---|
class |
BatchAction<T,V> |
class |
BufferAction<T> |
class |
BufferShiftAction<T> |
class |
BufferShiftWhenAction<T> |
class |
BufferWhenAction<T> |
class |
CacheAction<T> |
class |
LastAction<T> |
class |
SampleAction<T> |
class |
SortAction<T> |
class |
WindowAction<T>
WindowAction is forwarding events on a steam until is reached,
after that streams collected events further, complete it and create a fresh new stream.
|
class |
WindowShiftAction<T>
WindowAction is forwarding events on a steam until is reached,
after that streams collected events further, complete it and create a fresh new stream.
|
class |
WindowShiftWhenAction<T>
WindowAction is forwarding events on a steam until is reached,
after that streams collected events further, complete it and create a fresh new stream.
|
class |
WindowWhenAction<T>
WindowAction is forwarding events on a steam until returned stream emits a signal,
after that streams collected events further, complete it and create a fresh new stream.
|
Modifier and Type | Method and Description |
---|---|
protected Stream<T> |
WindowAction.createWindowStream() |
protected Stream<T> |
WindowWhenAction.createWindowStream(T first) |
Modifier and Type | Class and Description |
---|---|
class |
CombineLatestAction<O,V,TUPLE extends Tuple> |
class |
ConcatAction<T> |
class |
DynamicMergeAction<I,O> |
class |
FanInAction<I,E,O,SUBSCRIBER extends FanInAction.InnerSubscriber<I,E,O>>
The best moment of my life so far, not.
|
class |
MergeAction<O> |
class |
SwitchAction<T> |
class |
ZipAction<O,V,TUPLE extends Tuple> |
Modifier and Type | Class and Description |
---|---|
class |
ExistsAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
DispatcherAction<T> |
class |
FlowControlAction<O> |
class |
RepeatAction<T> |
class |
RepeatWhenAction<T> |
class |
ThrottleRequestAction<T> |
class |
ThrottleRequestWhenAction<T> |
Constructor and Description |
---|
RepeatWhenAction(Dispatcher dispatcher,
Function<? super Stream<? extends Long>,? extends org.reactivestreams.Publisher<?>> predicate,
org.reactivestreams.Publisher<? extends T> rootPublisher) |
ThrottleRequestWhenAction(Dispatcher dispatcher,
Function<? super Stream<? extends Long>,? extends org.reactivestreams.Publisher<? extends Long>> predicate) |
Modifier and Type | Class and Description |
---|---|
class |
ErrorAction<T,E extends Throwable> |
class |
ErrorReturnAction<T,E extends Throwable> |
class |
ErrorWithValueAction<T,E extends Throwable> |
class |
FallbackAction<T> |
class |
IgnoreErrorAction<T> |
class |
RetryAction<T> |
class |
RetryWhenAction<T> |
class |
TimeoutAction<T> |
Constructor and Description |
---|
RetryWhenAction(Dispatcher dispatcher,
Function<? super Stream<? extends Throwable>,? extends org.reactivestreams.Publisher<?>> predicate,
org.reactivestreams.Publisher<? extends T> rootPublisher) |
Modifier and Type | Class and Description |
---|---|
class |
DistinctAction<T,V> |
class |
DistinctUntilChangedAction<T,V> |
class |
ElementAtAction<T> |
class |
FilterAction<T> |
class |
SkipAction<T> |
class |
SkipUntilTimeout<T> |
class |
TakeAction<T> |
class |
TakeUntilTimeout<T> |
class |
TakeWhileAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
CountAction<T> |
class |
ElapsedAction<T> |
class |
TimestampAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
ReduceByKeyAction<K,V> |
class |
ScanByKeyAction<K,V> |
Modifier and Type | Class and Description |
---|---|
class |
AfterAction<T> |
class |
CallbackAction<T> |
class |
FinallyAction<T> |
class |
LoggerAction<T> |
class |
StreamStateCallbackAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
AdaptiveConsumerAction<T> |
class |
ConsumerAction<T> |
Constructor and Description |
---|
AdaptiveConsumerAction(Dispatcher dispatcher,
long initCapacity,
Consumer<? super T> consumer,
Function<Stream<Long>,? extends org.reactivestreams.Publisher<? extends Long>> requestMapper) |
Modifier and Type | Class and Description |
---|---|
class |
DefaultIfEmptyAction<T> |
class |
DematerializeAction<T> |
class |
GroupByAction<T,K>
Manage a dynamic registry of substreams for a given key extracted from the incoming data.
|
class |
MapAction<T,V> |
class |
MaterializeAction<T> |
class |
ScanAction<T,A> |
class |
SplitAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
BehaviorBroadcaster<O>
A
Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline. |
class |
Broadcaster<O>
A
Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline. |
class |
SerializedBroadcaster<O>
A
Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline. |
Modifier and Type | Class and Description |
---|---|
class |
BarrierStream
|
class |
DeferredStream<T>
A
Publisher supplier that will call the passed supplier on each subscribe call. |
class |
ErrorStream<O,T extends Throwable>
A Stream that emits a sigle error signal.
|
class |
FutureStream<T>
A Stream that emits a result of a
Future and then complete. |
class |
GroupedStream<K,T>
The Stream will complete or fail whever the parent groupBy action terminates itself.
|
class |
LiftStream<O,V>
A Stream wrapper that defers a parent stream subscription to the child action subscribe() call.
|
class |
MapStream<K,V>
A SubscribableMap is an event-driven Map that signals logged operations to its subscribers.
|
class |
PeriodicTimerStream
A Stream that emits
0 after an initial delay and ever incrementing long counter if the period argument is
specified. |
class |
PublisherStream<T>
A
Publisher wrapper that takes care of lazy subscribing. |
class |
SingleTimerStream
A Stream that emits
0 after an initial delay and then complete
The SingleTimerStream will manage dedicated timers for new subscriber assigned via
this#subscribe(org.reactivestreams.Subscriber) . |
class |
SingleValueStream<T>
A Stream that emits only one value and then complete.
|
class |
SupplierStream<T>
A Stream that returns the result from
Supplier.get() everytime it is requested via
Subscription.request(long) . |
Modifier and Type | Method and Description |
---|---|
static <T> Stream<T> |
IterableStream.create(Iterable<? extends T> defaultValues)
Create an Iterable Stream Publisher
|
static Stream<Long> |
RangeStream.create(long min,
long max)
Create a Range Stream Publisher
|
Stream<Tuple2<K,V>> |
MapStream.onPut()
Return a Stream of key/value tuples for only new or updated entries.
|
Stream<K> |
MapStream.onRemove()
Return a Stream of key/value tuples for only removed entries.
|
Constructor and Description |
---|
LiftStream(Stream<O> thiz,
Supplier<? extends Action<O,V>> action) |
Modifier and Type | Class and Description |
---|---|
class |
ChronicleReaderStream<K,V>
Implementation of a
Dispatcher that uses a IndexedChronicle to
queue tasks to execute. |
class |
ChronicleStream<K,V> |
Modifier and Type | Field and Description |
---|---|
protected Stream<O> |
PushSubscription.publisher |
Modifier and Type | Method and Description |
---|---|
Stream<O> |
PushSubscription.getPublisher() |
Constructor and Description |
---|
DropSubscription(Stream<O> publisher,
org.reactivestreams.Subscriber<? super O> subscriber) |
FanOutSubscription(Stream<O> publisher,
PushSubscription<O> reactiveSubscriptionA,
PushSubscription<O> reactiveSubscriptionB) |
PushSubscription(Stream<O> publisher,
org.reactivestreams.Subscriber<? super O> subscriber) |
ReactiveSubscription(Stream<O> publisher,
org.reactivestreams.Subscriber<? super O> subscriber) |
ReactiveSubscription(Stream<O> publisher,
org.reactivestreams.Subscriber<? super O> subscriber,
CompletableQueue<O> buffer) |
Modifier and Type | Method and Description |
---|---|
Stream<O> |
WrappedSubscription.getPublisher() |
Copyright © 2016. All rights reserved.