FlowableTransformers (rxjava2-extensions 0.18.0 API)

java.lang.Object
- hu.akarnokd.rxjava2.operators.FlowableTransformers

```
public final class FlowableTransformers
extends java.lang.Object
```
Additional operators in the form of FlowableTransformer, use Flowable.compose(FlowableTransformer) to apply the operators to an existing sequence.

Since:

0.7.2

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> io.reactivex.FlowableTransformer<T,java.util.List<T>>`	`bufferSplit(io.reactivex.functions.Predicate<? super T> predicate)` Buffers elements into a List until the given predicate returns true at which point a new empty buffer is started; the particular item will be dropped.
`static <T,C extends java.util.Collection<? super T>> io.reactivex.FlowableTransformer<T,C>`	`bufferSplit(io.reactivex.functions.Predicate<? super T> predicate, java.util.concurrent.Callable<C> bufferSupplier)` Buffers elements into a custom collection until the given predicate returns true at which point a new empty custom collection is started; the particular item will be dropped.
`static <T> io.reactivex.FlowableTransformer<T,java.util.List<T>>`	`bufferUntil(io.reactivex.functions.Predicate<? super T> predicate)` Buffers elements into a List until the given predicate returns true at which point a new empty buffer is started.
`static <T,C extends java.util.Collection<? super T>> io.reactivex.FlowableTransformer<T,C>`	`bufferUntil(io.reactivex.functions.Predicate<? super T> predicate, java.util.concurrent.Callable<C> bufferSupplier)` Buffers elements into a custom collection until the given predicate returns true at which point a new empty custom collection is started.
`static <T> io.reactivex.FlowableTransformer<T,java.util.List<T>>`	`bufferWhile(io.reactivex.functions.Predicate<? super T> predicate)` Buffers elements into a List while the given predicate returns true; if the predicate returns false for an item, a new buffer is created with the specified item.
`static <T,C extends java.util.Collection<? super T>> io.reactivex.FlowableTransformer<T,C>`	`bufferWhile(io.reactivex.functions.Predicate<? super T> predicate, java.util.concurrent.Callable<C> bufferSupplier)` Buffers elements into a custom collection while the given predicate returns true; if the predicate returns false for an item, a new collection is created with the specified item.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`cacheLast()` Cache the very last value of the flow and relay/replay it to Subscribers.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`coalesce(java.util.concurrent.Callable<R> containerSupplier, io.reactivex.functions.BiConsumer<R,T> coalescer)` Coalesces items from upstream into a container via a consumer and emits the container if there is a downstream demand, otherwise it keeps coalescing into the same container.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`coalesce(java.util.concurrent.Callable<R> containerSupplier, io.reactivex.functions.BiConsumer<R,T> coalescer, int bufferSize)` Coalesces items from upstream into a container via a consumer and emits the container if there is a downstream demand, otherwise it keeps coalescing into the same container.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`debounceFirst(long timeout, java.util.concurrent.TimeUnit unit)` Debounces the upstream by taking an item and dropping subsequent items until the specified amount of time elapses after the last item, after which the process repeats.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`debounceFirst(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Debounces the upstream by taking an item and dropping subsequent items until the specified amount of time elapses after the last item, after which the process repeats.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`every(long keep)` Relays every Nth item from upstream.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`expand(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends T>> expander)` Emits elements from the source and then expands them into another layer of Publishers, emitting those items recursively until all Publishers become empty in a depth-first manner.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`expand(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends T>> expander, ExpandStrategy strategy)` Emits elements from the source and then expands them into another layer of Publishers, emitting those items recursively until all Publishers become empty with the specified strategy.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`expand(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends T>> expander, ExpandStrategy strategy, int capacityHint)` Emits elements from the source and then expands them into another layer of Publishers, emitting those items recursively until all Publishers become empty with the specified strategy.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`filterAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<java.lang.Boolean>> asyncPredicate)` Maps each upstream value into a single `true` or `false` value provided by a generated Publisher for that input value and emits the input value if the inner Publisher returned `true`.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`filterAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<java.lang.Boolean>> asyncPredicate, int bufferSize)` Maps each upstream value into a single `true` or `false` value provided by a generated Publisher for that input value and emits the input value if the inner Publisher returned `true`.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`flatMapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, io.reactivex.Scheduler scheduler)` Maps the upstream values into Publisher and merges at most 32 of them at once, collects and emits the items on the specified scheduler.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`flatMapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, io.reactivex.Scheduler scheduler, boolean depthFirst)` Maps the upstream values into Publisher and merges at most 32 of them at once, collects and emits the items on the specified scheduler.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`flatMapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, io.reactivex.Scheduler scheduler, int maxConcurrency, int bufferSize, boolean depthFirst)` Maps the upstream values into Publisher and merges at most 32 of them at once, collects and emits the items on the specified scheduler.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`flatMapSync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)` Maps the upstream values into Publisher and merges at most 32 of them at once, optimized for mainly synchronous sources.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`flatMapSync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, boolean depthFirst)` Maps the upstream values into Publisher and merges at most maxConcurrency of them at once, optimized for mainly synchronous sources.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`flatMapSync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency, int bufferSize, boolean depthFirst)` Maps the upstream values into Publisher and merges at most maxConcurrency of them at once, optimized for mainly synchronous sources.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)` Maps each upstream value into a single value provided by a generated Publisher for that input value to be emitted to downstream.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize)` Maps each upstream value into a single value provided by a generated Publisher for that input value to be emitted to downstream.
`static <T,U,R> io.reactivex.FlowableTransformer<T,R>`	`mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, io.reactivex.functions.BiFunction<? super T,? super U,? extends R> combiner)` Maps each upstream value into a single value provided by a generated Publisher for that input value and combines the original and generated single value into a final result item to be emitted to downstream.
`static <T,U,R> io.reactivex.FlowableTransformer<T,R>`	`mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, io.reactivex.functions.BiFunction<? super T,? super U,? extends R> combiner, int bufferSize)` Maps each upstream value into a single value provided by a generated Publisher for that input value and combines the original and generated single value into a final result item to be emitted to downstream.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`mapFilter(io.reactivex.functions.BiConsumer<? super T,? super BasicEmitter<R>> consumer)` Allows mapping or filtering an upstream value through an emitter.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`onBackpressureTimeout(int maxSize, long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler, io.reactivex.functions.Consumer<? super T> onEvict)` Buffers the incoming values from upstream up to a maximum size or timeout if the downstream can't keep up.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`onBackpressureTimeout(long timeout, java.util.concurrent.TimeUnit unit)` Buffers the incoming values from upstream up to a maximum timeout if the downstream can't keep up.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`onBackpressureTimeout(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Buffers the incoming values from upstream up to a maximum timeout if the downstream can't keep up, running on a custom scheduler.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`onBackpressureTimeout(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler, io.reactivex.functions.Consumer<? super T> onEvict)` Buffers the incoming values from upstream up to a maximum size or timeout if the downstream can't keep up.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`refCount(int subscriberCount)` Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`refCount(int subscriberCount, long timeout, java.util.concurrent.TimeUnit unit)` Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`refCount(int subscriberCount, long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`refCount(long timeout, java.util.concurrent.TimeUnit unit)` Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`refCount(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long initialDelay, long betweenDelay, java.util.concurrent.TimeUnit unit)` Inserts a time delay between emissions from the upstream source, including an initial delay.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long initialDelay, long betweenDelay, java.util.concurrent.TimeUnit unit, boolean delayError)` Inserts a time delay between emissions from the upstream source, including an initial delay.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long initialDelay, long betweenDelay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Inserts a time delay between emissions from the upstream source, including an initial delay.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long initialDelay, long betweenDelay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler, boolean delayError)` Inserts a time delay between emissions from the upstream source, including an initial delay.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long betweenDelay, java.util.concurrent.TimeUnit unit)` Inserts a time delay between emissions from the upstream source.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long betweenDelay, java.util.concurrent.TimeUnit unit, boolean delayError)` Inserts a time delay between emissions from the upstream source, including an initial delay.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long betweenDelay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Inserts a time delay between emissions from the upstream source.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`spanout(long betweenDelay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler, boolean delayError)` Inserts a time delay between emissions from the upstream source, including an initial delay.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`switchFlatMap(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxActive)` Combination of switchMap and flatMap where there is a limit on the number of concurrent sources to be flattened into a single sequence and if the operator is at the given maximum active count, a newer source Publisher will switch out the oldest active source Publisher being merged.
`static <T,R> io.reactivex.FlowableTransformer<T,R>`	`switchFlatMap(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxActive, int bufferSize)` Combination of switchMap and flatMap where there is a limit on the number of concurrent sources to be flattened into a single sequence and if the operator is at the given maximum active count, a newer source Publisher will switch out the oldest active source Publisher being merged.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`switchIfEmpty(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> alternatives)` If the upstream turns out to be empty, it keeps switching to the alternative sources until one of them is non-empty or there are no more alternatives remaining.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`switchIfEmptyArray(org.reactivestreams.Publisher<? extends T>... alternatives)` If the upstream turns out to be empty, it keeps switching to the alternative sources until one of them is non-empty or there are no more alternatives remaining.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`timeoutLast(long timeout, java.util.concurrent.TimeUnit unit)` Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the last received item.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`timeoutLast(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the last received item.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`timeoutLastAbsolute(long timeout, java.util.concurrent.TimeUnit unit)` Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the start of the sequence.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`timeoutLastAbsolute(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the start of the sequence.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`valve(org.reactivestreams.Publisher<java.lang.Boolean> other)` Relays values until the other Publisher signals false and resumes if the other Publisher signals true again, like closing and opening a valve and not losing any items from the main source.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`valve(org.reactivestreams.Publisher<java.lang.Boolean> other, boolean defaultOpen)` Relays values until the other Publisher signals false and resumes if the other Publisher signals true again, like closing and opening a valve and not losing any items from the main source and starts with the specivied valve state.
`static <T> io.reactivex.FlowableTransformer<T,T>`	`valve(org.reactivestreams.Publisher<java.lang.Boolean> other, boolean defaultOpen, int bufferSize)` Relays values until the other Publisher signals false and resumes if the other Publisher signals true again, like closing and opening a valve and not losing any items from the main source and starts with the specivied valve state and the specified buffer size hint.
`static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>>`	`windowSplit(io.reactivex.functions.Predicate<? super T> predicate)` Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted; the particular item will be dropped.
`static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>>`	`windowSplit(io.reactivex.functions.Predicate<? super T> predicate, int bufferSize)` Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted; the particular item will be dropped.
`static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>>`	`windowUntil(io.reactivex.functions.Predicate<? super T> predicate)` Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted.
`static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>>`	`windowUntil(io.reactivex.functions.Predicate<? super T> predicate, int bufferSize)` Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted.
`static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>>`	`windowWhile(io.reactivex.functions.Predicate<? super T> predicate)` Emits elements into a Flowable window while the given predicate returns true.
`static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>>`	`windowWhile(io.reactivex.functions.Predicate<? super T> predicate, int bufferSize)` Emits elements into a Flowable window while the given predicate returns true.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - valve
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public static <T> io.reactivex.FlowableTransformer<T,T> valve(org.reactivestreams.Publisher<java.lang.Boolean> other)
```
    Relays values until the other Publisher signals false and resumes if the other Publisher signals true again, like closing and opening a valve and not losing any items from the main source.
    Properties:
    - The operator starts with an open valve.
    - If the other Publisher completes, the sequence terminates with an IllegalStateException.
    - The operator doesn't run on any particular Scheduler.
    - The operator is a pass-through for backpressure and uses an internal unbounded buffer of size Flowable.bufferSize() to hold onto values if the valve is closed.
    Type Parameters:
    
    T - the value type of the main source
    
    Parameters:
    
    other - the other source
    
    Returns:
    
    the new FlowableTransformer instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
    
    Since:
    
    0.7.2
  - valve
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public static <T> io.reactivex.FlowableTransformer<T,T> valve(org.reactivestreams.Publisher<java.lang.Boolean> other,
                                                                                                                                          boolean defaultOpen)
```
    Relays values until the other Publisher signals false and resumes if the other Publisher signals true again, like closing and opening a valve and not losing any items from the main source and starts with the specivied valve state.
    Properties:
    - If the other Publisher completes, the sequence terminates with an IllegalStateException.
    - The operator doesn't run on any particular Scheduler.
    - The operator is a pass-through for backpressure and uses an internal unbounded buffer of size Flowable.bufferSize() to hold onto values if the valve is closed.
    Type Parameters:
    
    T - the value type of the main source
    
    Parameters:
    
    other - the other source
    
    defaultOpen - should the valve start as open?
    
    Returns:
    
    the new FlowableTransformer instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
    
    Since:
    
    0.7.2
  - valve
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public static <T> io.reactivex.FlowableTransformer<T,T> valve(org.reactivestreams.Publisher<java.lang.Boolean> other,
                                                                                                                                          boolean defaultOpen,
                                                                                                                                          int bufferSize)
```
    Relays values until the other Publisher signals false and resumes if the other Publisher signals true again, like closing and opening a valve and not losing any items from the main source and starts with the specivied valve state and the specified buffer size hint.
    Properties:
    - If the other Publisher completes, the sequence terminates with an IllegalStateException.
    - The operator doesn't run on any particular Scheduler.
    Type Parameters:
    
    T - the value type of the main source
    
    Parameters:
    
    other - the other source
    
    defaultOpen - should the valve start as open?
    
    bufferSize - the buffer size hint (the chunk size of the underlying unbounded buffer)
    
    Returns:
    
    the new FlowableTransformer instance
    
    Throws:
    
    java.lang.IllegalArgumentException - if bufferSize <= 0
    
    java.lang.NullPointerException - if other is null
    
    Since:
    
    0.7.2
  - bufferWhile
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,java.util.List<T>> bufferWhile(io.reactivex.functions.Predicate<? super T> predicate)
```
    Buffers elements into a List while the given predicate returns true; if the predicate returns false for an item, a new buffer is created with the specified item.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current value and if returns false, a new buffer is created with the specified item
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.8.0
  - bufferWhile
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T,C extends java.util.Collection<? super T>> io.reactivex.FlowableTransformer<T,C> bufferWhile(io.reactivex.functions.Predicate<? super T> predicate,
                                                                                                                                                                                  java.util.concurrent.Callable<C> bufferSupplier)
```
    Buffers elements into a custom collection while the given predicate returns true; if the predicate returns false for an item, a new collection is created with the specified item.
    
    Type Parameters:
    
    T - the source value type
    
    C - the collection type
    
    Parameters:
    
    predicate - the predicate receiving the current value and if returns false, a new collection is created with the specified item
    
    bufferSupplier - the callable that returns a fresh collection
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.8.0
  - bufferUntil
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,java.util.List<T>> bufferUntil(io.reactivex.functions.Predicate<? super T> predicate)
```
    Buffers elements into a List until the given predicate returns true at which point a new empty buffer is started.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current buffer is emitted and a fresh empty buffer is created
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.8.0
  - bufferUntil
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T,C extends java.util.Collection<? super T>> io.reactivex.FlowableTransformer<T,C> bufferUntil(io.reactivex.functions.Predicate<? super T> predicate,
                                                                                                                                                                                  java.util.concurrent.Callable<C> bufferSupplier)
```
    Buffers elements into a custom collection until the given predicate returns true at which point a new empty custom collection is started.
    
    Type Parameters:
    
    T - the source value type
    
    C - the collection type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current collection is emitted and a fresh empty collection is created
    
    bufferSupplier - the callable that returns a fresh collection
    
    Returns:
    
    the new Flowable instance
    
    Since:
    
    0.8.0
  - bufferSplit
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,java.util.List<T>> bufferSplit(io.reactivex.functions.Predicate<? super T> predicate)
```
    Buffers elements into a List until the given predicate returns true at which point a new empty buffer is started; the particular item will be dropped.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current buffer is emitted and a fresh empty buffer is created
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.14.3
  - bufferSplit
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T,C extends java.util.Collection<? super T>> io.reactivex.FlowableTransformer<T,C> bufferSplit(io.reactivex.functions.Predicate<? super T> predicate,
                                                                                                                                                                                  java.util.concurrent.Callable<C> bufferSupplier)
```
    Buffers elements into a custom collection until the given predicate returns true at which point a new empty custom collection is started; the particular item will be dropped.
    
    Type Parameters:
    
    T - the source value type
    
    C - the collection type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current collection is emitted and a fresh empty collection is created
    
    bufferSupplier - the callable that returns a fresh collection
    
    Returns:
    
    the new Flowable instance
    
    Since:
    
    0.14.3
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long betweenDelay,
                                                                                                                                                                java.util.concurrent.TimeUnit unit)
```
    Inserts a time delay between emissions from the upstream source.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses the computation Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long betweenDelay,
                                                                                                                                              java.util.concurrent.TimeUnit unit,
                                                                                                                                              io.reactivex.Scheduler scheduler)
```
    Inserts a time delay between emissions from the upstream source.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses a custom Scheduler you provide.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    scheduler - the scheduler to delay and emit the values on
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long initialDelay,
                                                                                                                                                                long betweenDelay,
                                                                                                                                                                java.util.concurrent.TimeUnit unit)
```
    Inserts a time delay between emissions from the upstream source, including an initial delay.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses the computation Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    initialDelay - the initial delay
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long initialDelay,
                                                                                                                                              long betweenDelay,
                                                                                                                                              java.util.concurrent.TimeUnit unit,
                                                                                                                                              io.reactivex.Scheduler scheduler)
```
    Inserts a time delay between emissions from the upstream source, including an initial delay.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses a custom Scheduler you provide.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    initialDelay - the initial delay
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    scheduler - the scheduler to delay and emit the values on
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long betweenDelay,
                                                                                                                                                                java.util.concurrent.TimeUnit unit,
                                                                                                                                                                boolean delayError)
```
    Inserts a time delay between emissions from the upstream source, including an initial delay.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses the computation Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    delayError - delay the onError event from upstream
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long betweenDelay,
                                                                                                                                              java.util.concurrent.TimeUnit unit,
                                                                                                                                              io.reactivex.Scheduler scheduler,
                                                                                                                                              boolean delayError)
```
    Inserts a time delay between emissions from the upstream source, including an initial delay.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses a custom Scheduler you provide.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    scheduler - the scheduler to delay and emit the values on
    
    delayError - delay the onError event from upstream
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long initialDelay,
                                                                                                                                                                long betweenDelay,
                                                                                                                                                                java.util.concurrent.TimeUnit unit,
                                                                                                                                                                boolean delayError)
```
    Inserts a time delay between emissions from the upstream source, including an initial delay.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses the computation Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    initialDelay - the initial delay
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    delayError - delay the onError event from upstream
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - spanout
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> spanout(long initialDelay,
                                                                                                                                              long betweenDelay,
                                                                                                                                              java.util.concurrent.TimeUnit unit,
                                                                                                                                              io.reactivex.Scheduler scheduler,
                                                                                                                                              boolean delayError)
```
    Inserts a time delay between emissions from the upstream source, including an initial delay.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure and uses an unbounded internal buffer to store elements that need delay.
    
    Scheduler:
    
    The operator uses a custom Scheduler you provide.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    initialDelay - the initial delay
    
    betweenDelay - the (minimum) delay time between elements
    
    unit - the time unit of the initial delay and the between delay values
    
    scheduler - the scheduler to delay and emit the values on
    
    delayError - delay the onError event from upstream
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.9.0
  - mapFilter
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T,R> io.reactivex.FlowableTransformer<T,R> mapFilter(io.reactivex.functions.BiConsumer<? super T,? super BasicEmitter<R>> consumer)
```
    Allows mapping or filtering an upstream value through an emitter.
    
    Type Parameters:
    
    T - the input value type
    
    R - the output value type
    
    Parameters:
    
    consumer - the consumer that is called for each upstream value and should call one of the doXXX methods on the BasicEmitter it receives (individual to each Subscriber).
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.10.0
  - onBackpressureTimeout
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> onBackpressureTimeout(long timeout,
                                                                                                                                                                              java.util.concurrent.TimeUnit unit)
```
    Buffers the incoming values from upstream up to a maximum timeout if the downstream can't keep up.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the maximum age of an element in the buffer
    
    unit - the time unit of the timeout
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.13.0
    
    See Also:
    
    for more options
  - onBackpressureTimeout
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> onBackpressureTimeout(long timeout,
                                                                                                                                                            java.util.concurrent.TimeUnit unit,
                                                                                                                                                            io.reactivex.Scheduler scheduler,
                                                                                                                                                            io.reactivex.functions.Consumer<? super T> onEvict)
```
    Buffers the incoming values from upstream up to a maximum size or timeout if the downstream can't keep up.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the maximum age of an element in the buffer
    
    unit - the time unit of the timeout
    
    scheduler - the scheduler to be used as time source and to trigger the timeout & eviction
    
    onEvict - called when an element is evicted, maybe concurrently
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.13.0
  - onBackpressureTimeout
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> onBackpressureTimeout(long timeout,
                                                                                                                                                            java.util.concurrent.TimeUnit unit,
                                                                                                                                                            io.reactivex.Scheduler scheduler)
```
    Buffers the incoming values from upstream up to a maximum timeout if the downstream can't keep up, running on a custom scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the maximum age of an element in the buffer
    
    unit - the time unit of the timeout
    
    scheduler - the scheduler to be used as time source and to trigger the timeout & eviction
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.13.0
    
    See Also:
    
    for more options
  - onBackpressureTimeout
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> onBackpressureTimeout(int maxSize,
                                                                                                                                                            long timeout,
                                                                                                                                                            java.util.concurrent.TimeUnit unit,
                                                                                                                                                            io.reactivex.Scheduler scheduler,
                                                                                                                                                            io.reactivex.functions.Consumer<? super T> onEvict)
```
    Buffers the incoming values from upstream up to a maximum size or timeout if the downstream can't keep up.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    maxSize - the maximum number of elements in the buffer, beyond that, the oldest element is evicted
    
    timeout - the maximum age of an element in the buffer
    
    unit - the time unit of the timeout
    
    scheduler - the scheduler to be used as time source and to trigger the timeout & eviction
    
    onEvict - called when an element is evicted, maybe concurrently
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.13.0
  - every
```
@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.FlowableTransformer<T,T> every(long keep)
```
    Relays every Nth item from upstream.
    
    Backpressure:
    
    The operator requests keep times what the downstream requests and skips @code keep-1} items.
    
    Scheduler:
    
    The operator doesn't run on any particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    keep - the period of items to keep, i.e., this minus one items will be dropped before emitting an item directly
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.14.2
  - cacheLast
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.FlowableTransformer<T,T> cacheLast()
```
    Cache the very last value of the flow and relay/replay it to Subscribers.
    The operator subscribes to the upstream when the first downstream Subscriber arrives. Once connected, the upstream can't be stopped from the downstream even if all Subscribers cancel.
    A difference from replay(1) is that replay() is likely holding onto 2 references due to continuity requirements whereas this operator is guaranteed to hold only the very last item.
    
    Type Parameters:
    
    T - the value type emitted
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.15.0
  - timeoutLast
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> timeoutLast(long timeout,
                                                                                                                                                                    java.util.concurrent.TimeUnit unit)
```
    Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the last received item.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout time unit
    
    Returns:
    
    the new Flowable type
    
    Since:
    
    0.15.0
  - timeoutLast
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> timeoutLast(long timeout,
                                                                                                                                                  java.util.concurrent.TimeUnit unit,
                                                                                                                                                  io.reactivex.Scheduler scheduler)
```
    Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the last received item.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout time unit
    
    scheduler - the scheduler to run the timeout and possible emit the last/latest
    
    Returns:
    
    the new Flowable type
    
    Since:
    
    0.15.0
  - timeoutLastAbsolute
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> timeoutLastAbsolute(long timeout,
                                                                                                                                                                            java.util.concurrent.TimeUnit unit)
```
    Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the start of the sequence.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout time unit
    
    Returns:
    
    the new Flowable type
    
    Since:
    
    0.15.0
  - timeoutLastAbsolute
```
@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> timeoutLastAbsolute(long timeout,
                                                                                                                                                          java.util.concurrent.TimeUnit unit,
                                                                                                                                                          io.reactivex.Scheduler scheduler)
```
    Emit the last item when the upstream completes or the the latest received if the specified timeout elapses since the start of the sequence.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout time unit
    
    scheduler - the scheduler to run the timeout and possible emit the last/latest
    
    Returns:
    
    the new Flowable type
    
    Since:
    
    0.15.0
  - debounceFirst
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="io.reactivex:computation")
public static <T> io.reactivex.FlowableTransformer<T,T> debounceFirst(long timeout,
                                                                                                                                                                      java.util.concurrent.TimeUnit unit)
```
    Debounces the upstream by taking an item and dropping subsequent items until the specified amount of time elapses after the last item, after which the process repeats.
    Note that the operator uses the computation Scheduler for the source of time but doesn't use it to emit non-dropped items or terminal events. The operator uses calculation with the current time to decide if an upstream item may pass or not.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the timeout
    
    unit - the unit of measure of the timeout parameter
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.15.0
  - debounceFirst
```
@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="custom")
public static <T> io.reactivex.FlowableTransformer<T,T> debounceFirst(long timeout,
                                                                                                                                                    java.util.concurrent.TimeUnit unit,
                                                                                                                                                    io.reactivex.Scheduler scheduler)
```
    Debounces the upstream by taking an item and dropping subsequent items until the specified amount of time elapses after the last item, after which the process repeats.
    Note that the operator uses the computation Scheduler for the source of time but doesn't use it to emit non-dropped items or terminal events. The operator uses calculation with the current time to decide if an upstream item may pass or not.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the timeout
    
    unit - the unit of measure of the timeout parameter
    
    scheduler - the scheduler used for getting the current time when evaluating upstream items
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.15.0
  - switchFlatMap
```
@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,R> io.reactivex.FlowableTransformer<T,R> switchFlatMap(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                                                            int maxActive)
```
    Combination of switchMap and flatMap where there is a limit on the number of concurrent sources to be flattened into a single sequence and if the operator is at the given maximum active count, a newer source Publisher will switch out the oldest active source Publisher being merged.
    
    Type Parameters:
    
    T - the source value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function that maps an upstream value into a Publisher to be merged/switched
    
    maxActive - the maximum number of active inner Publishers
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.15.0
  - switchFlatMap
```
@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,R> io.reactivex.FlowableTransformer<T,R> switchFlatMap(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                                                            int maxActive,
                                                                                                                                            int bufferSize)
```
    Combination of switchMap and flatMap where there is a limit on the number of concurrent sources to be flattened into a single sequence and if the operator is at the given maximum active count, a newer source Publisher will switch out the oldest active source Publisher being merged.
    
    Type Parameters:
    
    T - the source value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function that maps an upstream value into a Publisher to be merged/switched
    
    maxActive - the maximum number of active inner Publishers
    
    bufferSize - the number of items to prefetch from each inner source
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.15.0
  - flatMapSync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapSync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
```
    Maps the upstream values into Publisher and merges at most 32 of them at once, optimized for mainly synchronous sources.
    
    Type Parameters:
    
    T - the input value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function mapping from a value into a Publisher
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - flatMapSync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapSync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                      boolean depthFirst)
```
    Maps the upstream values into Publisher and merges at most maxConcurrency of them at once, optimized for mainly synchronous sources.
    
    Type Parameters:
    
    T - the input value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function mapping from a value into a Publisher
    
    depthFirst - if true, the inner sources are drained as much as possible if false, the inner sources are consumed in a round-robin fashion
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - flatMapSync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapSync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                      int maxConcurrency,
                                                                      int bufferSize,
                                                                      boolean depthFirst)
```
    Maps the upstream values into Publisher and merges at most maxConcurrency of them at once, optimized for mainly synchronous sources.
    
    Type Parameters:
    
    T - the input value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function mapping from a value into a Publisher
    
    maxConcurrency - the maximum number of sources merged at once
    
    bufferSize - the prefetch on each inner source
    
    depthFirst - if true, the inner sources are drained as much as possible if false, the inner sources are consumed in a round-robin fashion
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - flatMapAsync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                       io.reactivex.Scheduler scheduler)
```
    Maps the upstream values into Publisher and merges at most 32 of them at once, collects and emits the items on the specified scheduler.
    This operator can be considered as a fusion between a flatMapSync and observeOn.
    
    Type Parameters:
    
    T - the input value type
    
    R - the output value type
    
    Parameters:
    
    mapper - the function mapping from a value into a Publisher
    
    scheduler - the Scheduler to use to collect and emit merged items
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - flatMapAsync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                       io.reactivex.Scheduler scheduler,
                                                                       boolean depthFirst)
```
    Maps the upstream values into Publisher and merges at most 32 of them at once, collects and emits the items on the specified scheduler.
    This operator can be considered as a fusion between a flatMapSync and observeOn.
    
    Type Parameters:
    
    T - the input value type
    
    R - the output value type
    
    Parameters:
    
    mapper - the function mapping from a value into a Publisher
    
    scheduler - the Scheduler to use to collect and emit merged items
    
    depthFirst - if true, the inner sources are drained as much as possible if false, the inner sources are consumed in a round-robin fashion
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - flatMapAsync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> flatMapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                       io.reactivex.Scheduler scheduler,
                                                                       int maxConcurrency,
                                                                       int bufferSize,
                                                                       boolean depthFirst)
```
    Maps the upstream values into Publisher and merges at most 32 of them at once, collects and emits the items on the specified scheduler.
    This operator can be considered as a fusion between a flatMapSync and observeOn.
    
    Type Parameters:
    
    T - the input value type
    
    R - the output value type
    
    Parameters:
    
    mapper - the function mapping from a value into a Publisher
    
    scheduler - the Scheduler to use to collect and emit merged items
    
    maxConcurrency - the maximum number of sources merged at once
    
    bufferSize - the prefetch on each inner source
    
    depthFirst - if true, the inner sources are drained as much as possible if false, the inner sources are consumed in a round-robin fashion
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - switchIfEmptyArray
```
public static <T> io.reactivex.FlowableTransformer<T,T> switchIfEmptyArray(org.reactivestreams.Publisher<? extends T>... alternatives)
```
    If the upstream turns out to be empty, it keeps switching to the alternative sources until one of them is non-empty or there are no more alternatives remaining.
    
    Type Parameters:
    
    T - the input and output value type
    
    Parameters:
    
    alternatives - the array of alternative Publishers.
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - switchIfEmpty
```
public static <T> io.reactivex.FlowableTransformer<T,T> switchIfEmpty(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> alternatives)
```
    If the upstream turns out to be empty, it keeps switching to the alternative sources until one of them is non-empty or there are no more alternatives remaining.
    
    Type Parameters:
    
    T - the input and output value type
    
    Parameters:
    
    alternatives - the Iterable of alternative Publishers.
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.0
  - expand
```
public static <T> io.reactivex.FlowableTransformer<T,T> expand(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends T>> expander)
```
    Emits elements from the source and then expands them into another layer of Publishers, emitting those items recursively until all Publishers become empty in a depth-first manner.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    expander - the function that converts an element into a Publisher to be expanded
    
    Returns:
    
    the new FlwoableTransformer instance
    
    Since:
    
    0.16.1
  - expand
```
public static <T> io.reactivex.FlowableTransformer<T,T> expand(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends T>> expander,
                                                               ExpandStrategy strategy)
```
    Emits elements from the source and then expands them into another layer of Publishers, emitting those items recursively until all Publishers become empty with the specified strategy.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    expander - the function that converts an element into a Publisher to be expanded
    
    strategy - the expansion strategy; depth-first will recursively expand the first item until there is no more expansion possible, then the second items, and so on; breadth-first will first expand the main source, then runs the expaned Publishers in sequence, then the 3rd level, and so on.
    
    Returns:
    
    the new FlwoableTransformer instance
    
    Since:
    
    0.16.1
  - expand
```
public static <T> io.reactivex.FlowableTransformer<T,T> expand(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends T>> expander,
                                                               ExpandStrategy strategy,
                                                               int capacityHint)
```
    Emits elements from the source and then expands them into another layer of Publishers, emitting those items recursively until all Publishers become empty with the specified strategy.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    expander - the function that converts an element into a Publisher to be expanded
    
    strategy - the expansion strategy; depth-first will recursively expand the first item until there is no more expansion possible, then the second items, and so on; breadth-first will first expand the main source, then runs the expaned Publishers in sequence, then the 3rd level, and so on.
    
    capacityHint - the capacity hint for the breadth-first expansion
    
    Returns:
    
    the new FlwoableTransformer instance
    
    Since:
    
    0.16.1
  - mapAsync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
```
    Maps each upstream value into a single value provided by a generated Publisher for that input value to be emitted to downstream.
    Only the first item emitted by the inner Publisher's are considered. If the inner Publisher is empty, no resulting item is generated for that input value.
    The inner Publishers are consumed in order and one at a time.
    
    Type Parameters:
    
    T - the input value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function that receives the upstream value and returns a Publisher that should emit a single value to be emitted.
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.2
  - mapAsync
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                   int bufferSize)
```
    Maps each upstream value into a single value provided by a generated Publisher for that input value to be emitted to downstream.
    Only the first item emitted by the inner Publisher's are considered. If the inner Publisher is empty, no resulting item is generated for that input value.
    The inner Publishers are consumed in order and one at a time.
    
    Type Parameters:
    
    T - the input value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function that receives the upstream value and returns a Publisher
    
    bufferSize - the internal buffer size and prefetch amount to buffer items from upstream until their turn comes up that should emit a single value to be emitted.
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.2
  - mapAsync
```
public static <T,U,R> io.reactivex.FlowableTransformer<T,R> mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
                                                                     io.reactivex.functions.BiFunction<? super T,? super U,? extends R> combiner)
```
    Maps each upstream value into a single value provided by a generated Publisher for that input value and combines the original and generated single value into a final result item to be emitted to downstream.
    Only the first item emitted by the inner Publisher's are considered. If the inner Publisher is empty, no resulting item is generated for that input value.
    The inner Publishers are consumed in order and one at a time.
    
    Type Parameters:
    
    T - the input value type
    
    U - the intermediate value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function that receives the upstream value and returns a Publisher that should emit a single value to be emitted.
    
    combiner - the bi-function that receives the original upstream value and the single value emitted by the Publisher and returns a result value to be emitted to downstream.
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.2
  - mapAsync
```
public static <T,U,R> io.reactivex.FlowableTransformer<T,R> mapAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
                                                                     io.reactivex.functions.BiFunction<? super T,? super U,? extends R> combiner,
                                                                     int bufferSize)
```
    Maps each upstream value into a single value provided by a generated Publisher for that input value and combines the original and generated single value into a final result item to be emitted to downstream.
    Only the first item emitted by the inner Publisher's are considered. If the inner Publisher is empty, no resulting item is generated for that input value.
    The inner Publishers are consumed in order and one at a time.
    
    Type Parameters:
    
    T - the input value type
    
    U - the intermediate value type
    
    R - the result value type
    
    Parameters:
    
    mapper - the function that receives the upstream value and returns a Publisher that should emit a single value to be emitted.
    
    combiner - the bi-function that receives the original upstream value and the single value emitted by the Publisher and returns a result value to be emitted to downstream.
    
    bufferSize - the internal buffer size and prefetch amount to buffer items from upstream until their turn comes up
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.2
  - filterAsync
```
public static <T> io.reactivex.FlowableTransformer<T,T> filterAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<java.lang.Boolean>> asyncPredicate)
```
    Maps each upstream value into a single true or false value provided by a generated Publisher for that input value and emits the input value if the inner Publisher returned true.
    Only the first item emitted by the inner Publisher's are considered. If the inner Publisher is empty, no resulting item is generated for that input value.
    The inner Publishers are consumed in order and one at a time.
    
    Type Parameters:
    
    T - the input and output value type
    
    Parameters:
    
    asyncPredicate - the function that receives the upstream value and returns a Publisher that should emit a single truee to indicate the original value should pass.
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.2
  - filterAsync
```
public static <T> io.reactivex.FlowableTransformer<T,T> filterAsync(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<java.lang.Boolean>> asyncPredicate,
                                                                    int bufferSize)
```
    Maps each upstream value into a single true or false value provided by a generated Publisher for that input value and emits the input value if the inner Publisher returned true.
    Only the first item emitted by the inner Publisher's are considered. If the inner Publisher is empty, no resulting item is generated for that input value.
    The inner Publishers are consumed in order and one at a time.
    
    Type Parameters:
    
    T - the input and output value type
    
    Parameters:
    
    asyncPredicate - the function that receives the upstream value and returns a Publisher that should emit a single truee to indicate the original value should pass.
    
    bufferSize - the internal buffer size and prefetch amount to buffer items from upstream until their turn comes up
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.16.2
  - refCount
```
public static <T> io.reactivex.FlowableTransformer<T,T> refCount(int subscriberCount)
```
    Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.
    When applying this transformer via Flowable.compose(FlowableTransformer) and the upstream is not a ConnectableFlowable, an IllegalArgumentException is thrown.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    subscriberCount - the number of subscribers required to connect to the upstream
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.0
  - refCount
```
public static <T> io.reactivex.FlowableTransformer<T,T> refCount(long timeout,
                                                                 java.util.concurrent.TimeUnit unit)
```
    Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.
    When applying this transformer via Flowable.compose(FlowableTransformer) and the upstream is not a ConnectableFlowable, an IllegalArgumentException is thrown.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the time to wait before disconnecting after all subscribers unsubscribed
    
    unit - the time unit of the timeout
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.0
  - refCount
```
public static <T> io.reactivex.FlowableTransformer<T,T> refCount(long timeout,
                                                                 java.util.concurrent.TimeUnit unit,
                                                                 io.reactivex.Scheduler scheduler)
```
    Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.
    When applying this transformer via Flowable.compose(FlowableTransformer) and the upstream is not a ConnectableFlowable, an IllegalArgumentException is thrown.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    timeout - the time to wait before disconnecting after all subscribers unsubscribed
    
    unit - the time unit of the timeout
    
    scheduler - the target scheduler to wait on before disconnecting
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.0
  - refCount
```
public static <T> io.reactivex.FlowableTransformer<T,T> refCount(int subscriberCount,
                                                                 long timeout,
                                                                 java.util.concurrent.TimeUnit unit)
```
    Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
    When applying this transformer via Flowable.compose(FlowableTransformer) and the upstream is not a ConnectableFlowable, an IllegalArgumentException is thrown.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    subscriberCount - the number of subscribers required to connect to the upstream
    
    timeout - the time to wait before disconnecting after all subscribers unsubscribed
    
    unit - the time unit of the timeout
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.0
  - refCount
```
public static <T> io.reactivex.FlowableTransformer<T,T> refCount(int subscriberCount,
                                                                 long timeout,
                                                                 java.util.concurrent.TimeUnit unit,
                                                                 io.reactivex.Scheduler scheduler)
```
    Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
    When applying this transformer via Flowable.compose(FlowableTransformer) and the upstream is not a ConnectableFlowable, an IllegalArgumentException is thrown.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    subscriberCount - the number of subscribers required to connect to the upstream
    
    timeout - the time to wait before disconnecting after all subscribers unsubscribed
    
    unit - the time unit of the timeout
    
    scheduler - the target scheduler to wait on before disconnecting
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.0
  - coalesce
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> coalesce(java.util.concurrent.Callable<R> containerSupplier,
                                                                   io.reactivex.functions.BiConsumer<R,T> coalescer)
```
    Coalesces items from upstream into a container via a consumer and emits the container if there is a downstream demand, otherwise it keeps coalescing into the same container.
    
    Type Parameters:
    
    T - the upstream value type
    
    R - the container and result type
    
    Parameters:
    
    containerSupplier - the function called and should return a fresh container to coalesce into
    
    coalescer - the consumer receiving the current container and upstream item to handle
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.3
  - coalesce
```
public static <T,R> io.reactivex.FlowableTransformer<T,R> coalesce(java.util.concurrent.Callable<R> containerSupplier,
                                                                   io.reactivex.functions.BiConsumer<R,T> coalescer,
                                                                   int bufferSize)
```
    Coalesces items from upstream into a container via a consumer and emits the container if there is a downstream demand, otherwise it keeps coalescing into the same container.
    
    Type Parameters:
    
    T - the upstream value type
    
    R - the container and result type
    
    Parameters:
    
    containerSupplier - the function called and should return a fresh container to coalesce into
    
    coalescer - the consumer receiving the current container and upstream item to handle
    
    bufferSize - the island size of the internal unbounded buffer
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.3
  - windowWhile
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>> windowWhile(io.reactivex.functions.Predicate<? super T> predicate)
```
    Emits elements into a Flowable window while the given predicate returns true. If the predicate returns false, a new Flowable window is emitted.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current value and if returns false, a new window is created with the specified item
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.7
  - windowWhile
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>> windowWhile(io.reactivex.functions.Predicate<? super T> predicate,
                                                                                                                                                               int bufferSize)
```
    Emits elements into a Flowable window while the given predicate returns true. If the predicate returns false, a new Flowable window is emitted.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current value and if returns false, a new window is created with the specified item
    
    bufferSize - the buffer size hint (the chunk size of the underlying unbounded buffer)
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.7
  - windowUntil
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>> windowUntil(io.reactivex.functions.Predicate<? super T> predicate)
```
    Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current window is completed and a new window is emitted
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.7
  - windowUntil
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>> windowUntil(io.reactivex.functions.Predicate<? super T> predicate,
                                                                                                                                                               int bufferSize)
```
    Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current window is completed and a new window is emitted
    
    bufferSize - the buffer size hint (the chunk size of the underlying unbounded buffer)
    
    Returns:
    
    the new Flowable instance
    
    Since:
    
    0.17.7
  - windowSplit
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>> windowSplit(io.reactivex.functions.Predicate<? super T> predicate)
```
    Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted; the particular item will be dropped.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current window is completed and a new window is emitted
    
    Returns:
    
    the new FlowableTransformer instance
    
    Since:
    
    0.17.7
  - windowSplit
```
@SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> io.reactivex.FlowableTransformer<T,io.reactivex.Flowable<T>> windowSplit(io.reactivex.functions.Predicate<? super T> predicate,
                                                                                                                                                               int bufferSize)
```
    Emits elements into a Flowable window until the given predicate returns true at which point a new Flowable window is emitted; the particular item will be dropped.
    
    Type Parameters:
    
    T - the source value type
    
    Parameters:
    
    predicate - the predicate receiving the current item and if returns true, the current window is completed and a new window is emitted
    
    bufferSize - the buffer size hint (the chunk size of the underlying unbounded buffer)
    
    Returns:
    
    the new Flowable instance
    
    Since:
    
    0.17.7

Class FlowableTransformers

Method Summary

Methods inherited from class java.lang.Object

Method Detail

valve

valve

valve

bufferWhile

bufferWhile

bufferUntil

bufferUntil

bufferSplit

bufferSplit

spanout

spanout

spanout

spanout

spanout

spanout

spanout

spanout

mapFilter

onBackpressureTimeout

onBackpressureTimeout

onBackpressureTimeout

onBackpressureTimeout

every

cacheLast

timeoutLast

timeoutLast

timeoutLastAbsolute

timeoutLastAbsolute

debounceFirst

debounceFirst

switchFlatMap

switchFlatMap

flatMapSync

flatMapSync

flatMapSync

flatMapAsync

flatMapAsync

flatMapAsync

switchIfEmptyArray

switchIfEmpty

expand

expand

expand

mapAsync

mapAsync

mapAsync

mapAsync

filterAsync

filterAsync

refCount

refCount

refCount

refCount

refCount

coalesce

coalesce

windowWhile

windowWhile

windowUntil

windowUntil

windowSplit

windowSplit