com.github.davidmoten.rx2.flowable

Class Transformers

java.lang.Object

com.github.davidmoten.rx2.flowable.Transformers

public final class Transformers
extends Object

Method Summary

Modifier and Type	Method and Description
static <T> io.reactivex.FlowableTransformer<T,List<T>>	buffer(int maxSize, io.reactivex.functions.Function<? super T,? extends Long> duration, TimeUnit unit) Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration.
static <T> io.reactivex.FlowableTransformer<T,List<T>>	buffer(int maxSize, io.reactivex.functions.Function<? super T,? extends Long> duration, TimeUnit unit, io.reactivex.Scheduler scheduler) Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration.
static <T> io.reactivex.FlowableTransformer<T,List<T>>	buffer(int maxSize, long duration, TimeUnit unit) Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration.
static <T> io.reactivex.FlowableTransformer<T,List<T>>	buffer(int maxSize, long duration, TimeUnit unit, io.reactivex.Scheduler scheduler) Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration.
static <T> io.reactivex.FlowableTransformer<T,List<T>>	bufferWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition)
static <T> io.reactivex.FlowableTransformer<T,List<T>>	bufferWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder)
static <T extends Number> io.reactivex.FlowableTransformer<T,Statistics>	collectStats() Converts a stream of Number to a stream of Statistics about those numbers.
static <T,R extends Number> io.reactivex.FlowableTransformer<T,Pair<T,Statistics>>	collectStats(io.reactivex.functions.Function<? super T,? extends R> function)
static <T,R> io.reactivex.FlowableTransformer<T,R>	collectWhile(Callable<R> collectionFactory, io.reactivex.functions.BiFunction<? super R,? super T,? extends R> add, io.reactivex.functions.BiPredicate<? super R,? super T> condition)
static <T,R> io.reactivex.FlowableTransformer<T,R>	collectWhile(Callable<R> collectionFactory, io.reactivex.functions.BiFunction<? super R,? super T,? extends R> add, io.reactivex.functions.BiPredicate<? super R,? super T> condition, boolean emitRemainder) Returns a transformer that emits collections of items with the collection boundaries determined by the given BiPredicate.
static <T> io.reactivex.FlowableTransformer<T,T>	doOnEmpty(io.reactivex.functions.Action action) Returns a transformer that when a stream is empty runs the given Action.
static <T,R> io.reactivex.FlowableTransformer<T,R>	flatMapInterleaved(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency)
static <T,R> io.reactivex.FlowableTransformer<T,R>	flatMapInterleaved(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency, int bufferSize, boolean delayErrors)
static <T> io.reactivex.FlowableTransformer<T,T>	insert(io.reactivex.functions.Function<? super T,? extends Long> timeout, TimeUnit unit, io.reactivex.functions.Function<? super T,? extends T> value)
static <T> io.reactivex.FlowableTransformer<T,T>	insert(io.reactivex.functions.Function<? super T,? extends Long> timeout, TimeUnit unit, io.reactivex.functions.Function<? super T,? extends T> value, io.reactivex.Scheduler scheduler)
static <T> io.reactivex.FlowableTransformer<T,T>	insert(io.reactivex.functions.Function<? super T,? extends Long> timeout, TimeUnit unit, T value)
static <T> io.reactivex.FlowableTransformer<T,T>	insert(io.reactivex.functions.Function<? super T,? extends io.reactivex.Maybe<? extends T>> valueToInsert) For every onNext emission from the source stream, the valueToInsert Maybe is subscribed to.
static <T> io.reactivex.FlowableTransformer<T,T>	insert(long timeout, TimeUnit unit, T value)
static <T> io.reactivex.FlowableTransformer<T,T>	insert(io.reactivex.Maybe<? extends T> valueToInsert)
static <T> io.reactivex.FlowableTransformer<T,T>	mapLast(io.reactivex.functions.Function<? super T,? extends T> function)
static <A,B,K,C> io.reactivex.Flowable<C>	match(io.reactivex.Flowable<A> a, io.reactivex.Flowable<B> b, io.reactivex.functions.Function<? super A,K> aKey, io.reactivex.functions.Function<? super B,K> bKey, io.reactivex.functions.BiFunction<? super A,? super B,C> combiner, int requestSize)
static <A,B,C,K> io.reactivex.FlowableTransformer<A,C>	matchWith(io.reactivex.Flowable<B> b, io.reactivex.functions.Function<? super A,K> aKey, io.reactivex.functions.Function<? super B,K> bKey, io.reactivex.functions.BiFunction<? super A,? super B,C> combiner)
static <A,B,C,K> io.reactivex.FlowableTransformer<A,C>	matchWith(io.reactivex.Flowable<B> b, io.reactivex.functions.Function<? super A,K> aKey, io.reactivex.functions.Function<? super B,K> bKey, io.reactivex.functions.BiFunction<? super A,? super B,C> combiner, int requestSize)
static <T> io.reactivex.FlowableTransformer<T,T>	maxRequest(long... maxRequest)
static <T> io.reactivex.FlowableTransformer<T,T>	minRequest(int... minRequests)
static Options.BuilderFlowable	onBackpressureBufferToFile()
static <T> io.reactivex.FlowableTransformer<T,T>	rebatchRequests(int minRequest, long maxRequest)
static <T> io.reactivex.FlowableTransformer<T,T>	rebatchRequests(int minRequest, long maxRequest, boolean constrainFirstRequestMin)
static <T> io.reactivex.functions.Function<io.reactivex.Flowable<T>,io.reactivex.Flowable<T>>	reduce(io.reactivex.functions.Function<? super io.reactivex.Flowable<T>,? extends io.reactivex.Flowable<T>> reducer, int maxChained)
static <T> io.reactivex.functions.Function<io.reactivex.Flowable<T>,io.reactivex.Flowable<T>>	reduce(io.reactivex.functions.Function<? super io.reactivex.Flowable<T>,? extends io.reactivex.Flowable<T>> reducer, int maxChained, long maxIterations)
static <T> io.reactivex.functions.Function<io.reactivex.Flowable<T>,io.reactivex.Flowable<T>>	repeat(io.reactivex.functions.Function<? super io.reactivex.Flowable<T>,? extends io.reactivex.Flowable<T>> transform, int maxChained, long maxIterations, io.reactivex.functions.Function<io.reactivex.Observable<T>,io.reactivex.Observable<?>> tester)
static <T> io.reactivex.FlowableTransformer<T,T>	reverse()
static StateMachine.Builder	stateMachine()
static <State,In,Out> io.reactivex.FlowableTransformer<In,Out>	stateMachine(Callable<? extends State> initialState, io.reactivex.functions.Function3<? super State,? super In,? super io.reactivex.FlowableEmitter<Out>,? extends State> transition, io.reactivex.functions.BiPredicate<? super State,? super io.reactivex.FlowableEmitter<Out>> completion, io.reactivex.BackpressureStrategy backpressureStrategy, int requestBatchSize)
static StateMachine2.Builder	stateMachine2()
static <T> io.reactivex.FlowableTransformer<T,List<T>>	toListWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition)
static <T> io.reactivex.FlowableTransformer<T,List<T>>	toListWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder)
static <T extends Comparable<T>> io.reactivex.FlowableTransformer<T,T>	windowMax(int windowSize)
static <T> io.reactivex.FlowableTransformer<T,T>	windowMax(int windowSize, Comparator<? super T> comparator)
static <T extends Comparable<T>> io.reactivex.FlowableTransformer<T,T>	windowMin(int windowSize)
static <T> io.reactivex.FlowableTransformer<T,T>	windowMin(int windowSize, Comparator<? super T> comparator)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

stateMachine

public static <State,In,Out> io.reactivex.FlowableTransformer<In,Out> stateMachine(Callable<? extends State> initialState,
                                                                                   io.reactivex.functions.Function3<? super State,? super In,? super io.reactivex.FlowableEmitter<Out>,? extends State> transition,
                                                                                   io.reactivex.functions.BiPredicate<? super State,? super io.reactivex.FlowableEmitter<Out>> completion,
                                                                                   io.reactivex.BackpressureStrategy backpressureStrategy,
                                                                                   int requestBatchSize)

stateMachine

public static StateMachine.Builder stateMachine()

stateMachine2

public static StateMachine2.Builder stateMachine2()

doOnEmpty

public static <T> io.reactivex.FlowableTransformer<T,T> doOnEmpty(io.reactivex.functions.Action action)

Returns a transformer that when a stream is empty runs the given Action.

Type Parameters:

T - item type

Parameters:

action - to be called when the stream is determined to be empty.

Returns:

a transformer that when a stream is empty runs the given action.

reverse

public static <T> io.reactivex.FlowableTransformer<T,T> reverse()

mapLast

public static <T> io.reactivex.FlowableTransformer<T,T> mapLast(io.reactivex.functions.Function<? super T,? extends T> function)

match

public static <A,B,K,C> io.reactivex.Flowable<C> match(io.reactivex.Flowable<A> a,
                                                       io.reactivex.Flowable<B> b,
                                                       io.reactivex.functions.Function<? super A,K> aKey,
                                                       io.reactivex.functions.Function<? super B,K> bKey,
                                                       io.reactivex.functions.BiFunction<? super A,? super B,C> combiner,
                                                       int requestSize)

matchWith

public static <A,B,C,K> io.reactivex.FlowableTransformer<A,C> matchWith(io.reactivex.Flowable<B> b,
                                                                        io.reactivex.functions.Function<? super A,K> aKey,
                                                                        io.reactivex.functions.Function<? super B,K> bKey,
                                                                        io.reactivex.functions.BiFunction<? super A,? super B,C> combiner,
                                                                        int requestSize)

matchWith

public static <A,B,C,K> io.reactivex.FlowableTransformer<A,C> matchWith(io.reactivex.Flowable<B> b,
                                                                        io.reactivex.functions.Function<? super A,K> aKey,
                                                                        io.reactivex.functions.Function<? super B,K> bKey,
                                                                        io.reactivex.functions.BiFunction<? super A,? super B,C> combiner)

onBackpressureBufferToFile

public static Options.BuilderFlowable onBackpressureBufferToFile()

collectStats

public static <T extends Number> io.reactivex.FlowableTransformer<T,Statistics> collectStats()

Converts a stream of Number to a stream of Statistics about those numbers.

Type Parameters:

T - item type

Returns:

transformer that converts a stream of Number to a stream of Statistics

collectStats

public static <T,R extends Number> io.reactivex.FlowableTransformer<T,Pair<T,Statistics>> collectStats(io.reactivex.functions.Function<? super T,? extends R> function)

collectWhile

public static <T,R> io.reactivex.FlowableTransformer<T,R> collectWhile(Callable<R> collectionFactory,
                                                                       io.reactivex.functions.BiFunction<? super R,? super T,? extends R> add,
                                                                       io.reactivex.functions.BiPredicate<? super R,? super T> condition,
                                                                       boolean emitRemainder)

Returns a transformer that emits collections of items with the collection boundaries determined by the given BiPredicate.

Type Parameters:

T - item type

R - collection type

Parameters:

collectionFactory - factory to create a new collection

add - method to add an item to a collection

condition - while true will continue to add to the current collection. Do not modify the given collection!

emitRemainder - whether to emit the remainder as a collection

Returns:

transform that collects while some conditions is returned then starts a new collection

collectWhile

public static <T,R> io.reactivex.FlowableTransformer<T,R> collectWhile(Callable<R> collectionFactory,
                                                                       io.reactivex.functions.BiFunction<? super R,? super T,? extends R> add,
                                                                       io.reactivex.functions.BiPredicate<? super R,? super T> condition)

toListWhile

public static <T> io.reactivex.FlowableTransformer<T,List<T>> toListWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition,
                                                                          boolean emitRemainder)

toListWhile

public static <T> io.reactivex.FlowableTransformer<T,List<T>> toListWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition)

bufferWhile

public static <T> io.reactivex.FlowableTransformer<T,List<T>> bufferWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition,
                                                                          boolean emitRemainder)

bufferWhile

public static <T> io.reactivex.FlowableTransformer<T,List<T>> bufferWhile(io.reactivex.functions.BiPredicate<? super List<T>,? super T> condition)

windowMax

public static <T extends Comparable<T>> io.reactivex.FlowableTransformer<T,T> windowMax(int windowSize)

windowMax

public static <T> io.reactivex.FlowableTransformer<T,T> windowMax(int windowSize,
                                                                  Comparator<? super T> comparator)

windowMin

public static <T extends Comparable<T>> io.reactivex.FlowableTransformer<T,T> windowMin(int windowSize)

windowMin

public static <T> io.reactivex.FlowableTransformer<T,T> windowMin(int windowSize,
                                                                  Comparator<? super T> comparator)

maxRequest

public static <T> io.reactivex.FlowableTransformer<T,T> maxRequest(long... maxRequest)

minRequest

public static <T> io.reactivex.FlowableTransformer<T,T> minRequest(int... minRequests)

rebatchRequests

public static <T> io.reactivex.FlowableTransformer<T,T> rebatchRequests(int minRequest,
                                                                        long maxRequest,
                                                                        boolean constrainFirstRequestMin)

rebatchRequests

public static <T> io.reactivex.FlowableTransformer<T,T> rebatchRequests(int minRequest,
                                                                        long maxRequest)

repeat

public static <T> io.reactivex.functions.Function<io.reactivex.Flowable<T>,io.reactivex.Flowable<T>> repeat(io.reactivex.functions.Function<? super io.reactivex.Flowable<T>,? extends io.reactivex.Flowable<T>> transform,
                                                                                                            int maxChained,
                                                                                                            long maxIterations,
                                                                                                            io.reactivex.functions.Function<io.reactivex.Observable<T>,io.reactivex.Observable<?>> tester)

reduce

public static <T> io.reactivex.functions.Function<io.reactivex.Flowable<T>,io.reactivex.Flowable<T>> reduce(io.reactivex.functions.Function<? super io.reactivex.Flowable<T>,? extends io.reactivex.Flowable<T>> reducer,
                                                                                                            int maxChained,
                                                                                                            long maxIterations)

reduce

public static <T> io.reactivex.functions.Function<io.reactivex.Flowable<T>,io.reactivex.Flowable<T>> reduce(io.reactivex.functions.Function<? super io.reactivex.Flowable<T>,? extends io.reactivex.Flowable<T>> reducer,
                                                                                                            int maxChained)

flatMapInterleaved

public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapInterleaved(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                             int maxConcurrency)

flatMapInterleaved

public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapInterleaved(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                             int maxConcurrency,
                                                                             int bufferSize,
                                                                             boolean delayErrors)

insert

public static <T> io.reactivex.FlowableTransformer<T,T> insert(io.reactivex.functions.Function<? super T,? extends io.reactivex.Maybe<? extends T>> valueToInsert)

For every onNext emission from the source stream, the valueToInsert Maybe is subscribed to. If the Maybe emits before the next upstream emission then the result from the Maybe will be inserted into the stream. If the Maybe does not emit before the next upstream emission then it is cancelled (and no value is inserted).

Type Parameters:

T - stream element type

Parameters:

valueToInsert - a Maybe is calculated from last source emission and subscribed to. If succeeds before next source emission then result is inserted into stream.

Returns:

source with operator insert applied

insert

public static <T> io.reactivex.FlowableTransformer<T,T> insert(long timeout,
                                                               TimeUnit unit,
                                                               T value)

insert

public static <T> io.reactivex.FlowableTransformer<T,T> insert(io.reactivex.functions.Function<? super T,? extends Long> timeout,
                                                               TimeUnit unit,
                                                               T value)

insert

public static <T> io.reactivex.FlowableTransformer<T,T> insert(io.reactivex.functions.Function<? super T,? extends Long> timeout,
                                                               TimeUnit unit,
                                                               io.reactivex.functions.Function<? super T,? extends T> value)

insert

public static <T> io.reactivex.FlowableTransformer<T,T> insert(io.reactivex.functions.Function<? super T,? extends Long> timeout,
                                                               TimeUnit unit,
                                                               io.reactivex.functions.Function<? super T,? extends T> value,
                                                               io.reactivex.Scheduler scheduler)

insert

public static <T> io.reactivex.FlowableTransformer<T,T> insert(io.reactivex.Maybe<? extends T> valueToInsert)

buffer

public static <T> io.reactivex.FlowableTransformer<T,List<T>> buffer(int maxSize,
                                                                     long duration,
                                                                     TimeUnit unit)

Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration. Schedulers.computation() is used for scheduling an inserted emission.

Type Parameters:

T - type of the source stream items

Parameters:

maxSize - max size of emitted lists

duration - buffered list is emitted if the elapsed time since last emission from the source reaches this duration

unit - unit of duration

Returns:

source with operator applied

buffer

public static <T> io.reactivex.FlowableTransformer<T,List<T>> buffer(int maxSize,
                                                                     long duration,
                                                                     TimeUnit unit,
                                                                     io.reactivex.Scheduler scheduler)

Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration.

Type Parameters:

T - type of the source stream items

Parameters:

maxSize - max size of emitted lists

duration - buffered list is emitted if the elapsed time since last emission from the source reaches this duration

unit - unit of duration

scheduler - scheduler to use to schedule emission of a buffer (as a list) if the time since last emission from the source reaches duration

Returns:

source with operator applied

buffer

public static <T> io.reactivex.FlowableTransformer<T,List<T>> buffer(int maxSize,
                                                                     io.reactivex.functions.Function<? super T,? extends Long> duration,
                                                                     TimeUnit unit)

Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration. An emission on timeout is scheduled on Schedulers.computation().

Type Parameters:

T - type of the source stream items

Parameters:

maxSize - max size of emitted lists

duration - function that based on the last emission calculates the elapsed time to be used before emitting a buffered list

unit - unit of duration

Returns:

source with operator applied

buffer

public static <T> io.reactivex.FlowableTransformer<T,List<T>> buffer(int maxSize,
                                                                     io.reactivex.functions.Function<? super T,? extends Long> duration,
                                                                     TimeUnit unit,
                                                                     io.reactivex.Scheduler scheduler)

Buffers the source Flowable into Lists, emitting Lists when the size of a list reaches maxSize or if the elapsed time since last emission from the source reaches the given duration.

Type Parameters:

T - type of the source stream items

Parameters:

maxSize - max size of emitted lists

duration - function that based on the last emission calculates the elapsed time to be used before emitting a buffered list

unit - unit of duration

scheduler - scheduler to use to schedule emission of a buffer (as a list) if the time since last emission from the source reaches duration

Returns:

source with operator applied