hu.akarnokd.rxjava2

Class Observable<T>

java.lang.Object

hu.akarnokd.rxjava2.Observable<T>

All Implemented Interfaces:

org.reactivestreams.Publisher<T>

Direct Known Subclasses:

CachedObservable, ConnectableObservable, GroupedObservable, ObservableScalarSource, Subject

public class Observable<T>
extends java.lang.Object
implements org.reactivestreams.Publisher<T>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	Observable.Operator<Downstream,Upstream> Interface to map/wrap a downstream subscriber to an upstream subscriber.
static interface	Observable.Transformer<T,R> Interface to compose observables.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Observable(org.reactivestreams.Publisher<T> onSubscribe)

Method Summary

Modifier and Type	Method and Description
Observable<java.lang.Boolean>	all(Predicate<? super T> predicate)
static <T> Observable<T>	amb(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	amb(org.reactivestreams.Publisher<? extends T>... sources)
Observable<T>	ambWith(org.reactivestreams.Publisher<? extends T> other)
Observable<java.lang.Boolean>	any(Predicate<? super T> predicate)
Observable<T>	asObservable()
Observable<java.util.List<T>>	buffer(int count)
Observable<java.util.List<T>>	buffer(int count, int skip)
<U extends java.util.Collection<? super T>> Observable<U>	buffer(int count, int skip, Supplier<U> bufferSupplier)
<U extends java.util.Collection<? super T>> Observable<U>	buffer(int count, Supplier<U> bufferSupplier)
Observable<java.util.List<T>>	buffer(long timespan, long timeskip, java.util.concurrent.TimeUnit unit)
Observable<java.util.List<T>>	buffer(long timespan, long timeskip, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<U extends java.util.Collection<? super T>> Observable<U>	buffer(long timespan, long timeskip, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Supplier<U> bufferSupplier)
Observable<java.util.List<T>>	buffer(long timespan, java.util.concurrent.TimeUnit unit)
Observable<java.util.List<T>>	buffer(long timespan, java.util.concurrent.TimeUnit unit, int count)
Observable<java.util.List<T>>	buffer(long timespan, java.util.concurrent.TimeUnit unit, int count, Scheduler scheduler)
<U extends java.util.Collection<? super T>> Observable<U>	buffer(long timespan, java.util.concurrent.TimeUnit unit, int count, Scheduler scheduler, Supplier<U> bufferSupplier, boolean restartTimerOnMaxSize)
Observable<java.util.List<T>>	buffer(long timespan, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<TOpening,TClosing> Observable<java.util.List<T>>	buffer(Observable<? extends TOpening> bufferOpenings, Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> bufferClosingSelector)
<TOpening,TClosing,U extends java.util.Collection<? super T>> Observable<U>	buffer(Observable<? extends TOpening> bufferOpenings, Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> bufferClosingSelector, Supplier<U> bufferSupplier)
<B> Observable<java.util.List<T>>	buffer(org.reactivestreams.Publisher<B> boundary)
<B> Observable<java.util.List<T>>	buffer(org.reactivestreams.Publisher<B> boundary, int initialCapacity)
<B,U extends java.util.Collection<? super T>> Observable<U>	buffer(org.reactivestreams.Publisher<B> boundary, Supplier<U> bufferSupplier)
<B> Observable<java.util.List<T>>	buffer(Supplier<? extends org.reactivestreams.Publisher<B>> boundarySupplier)
<B,U extends java.util.Collection<? super T>> Observable<U>	buffer(Supplier<? extends org.reactivestreams.Publisher<B>> boundarySupplier, Supplier<U> bufferSupplier)
static int	bufferSize()
Observable<T>	cache()
Observable<T>	cache(int capacityHint)
<U> Observable<U>	cast(java.lang.Class<U> clazz)
<U> Observable<U>	collect(Supplier<? extends U> initialValueSupplier, BiConsumer<? super U,? super T> collector)
<U> Observable<U>	collectInto(U initialValue, BiConsumer<? super U,? super T> collector)
static <T,R> Observable<R>	combineLatest(Function<? super java.lang.Object[],? extends R> combiner, boolean delayError, int bufferSize, org.reactivestreams.Publisher<? extends T>... sources)
static <T,R> Observable<R>	combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, Function<? super java.lang.Object[],? extends R> combiner)
static <T,R> Observable<R>	combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, Function<? super java.lang.Object[],? extends R> combiner, boolean delayError)
static <T,R> Observable<R>	combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, Function<? super java.lang.Object[],? extends R> combiner, boolean delayError, int bufferSize)
static <T,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T>[] sources, Function<? super java.lang.Object[],? extends R> combiner)
static <T,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T>[] sources, Function<? super java.lang.Object[],? extends R> combiner, boolean delayError)
static <T,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T>[] sources, Function<? super java.lang.Object[],? extends R> combiner, boolean delayError, int bufferSize)
static <T1,T2,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, BiFunction<? super T1,? super T2,? extends R> combiner)
static <T1,T2,T3,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, Function3<? super T1,? super T2,? super T3,? extends R> combiner)
static <T1,T2,T3,T4,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)
static <T1,T2,T3,T4,T5,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)
static <T1,T2,T3,T4,T5,T6,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)
static <T1,T2,T3,T4,T5,T6,T7,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, org.reactivestreams.Publisher<? extends T7> p7, Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, org.reactivestreams.Publisher<? extends T7> p7, org.reactivestreams.Publisher<? extends T8> p8, Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Observable<R>	combineLatest(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, org.reactivestreams.Publisher<? extends T7> p7, org.reactivestreams.Publisher<? extends T8> p8, org.reactivestreams.Publisher<? extends T9> p9, Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner)
<R> Observable<R>	compose(Observable.Transformer<T,R> composer)
static <T> Observable<T>	concat(int prefetch, java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	concat(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources, int bufferSize)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4, org.reactivestreams.Publisher<? extends T> p5)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4, org.reactivestreams.Publisher<? extends T> p5, org.reactivestreams.Publisher<? extends T> p6)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4, org.reactivestreams.Publisher<? extends T> p5, org.reactivestreams.Publisher<? extends T> p6, org.reactivestreams.Publisher<? extends T> p7)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4, org.reactivestreams.Publisher<? extends T> p5, org.reactivestreams.Publisher<? extends T> p6, org.reactivestreams.Publisher<? extends T> p7, org.reactivestreams.Publisher<? extends T> p8)
static <T> Observable<T>	concat(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4, org.reactivestreams.Publisher<? extends T> p5, org.reactivestreams.Publisher<? extends T> p6, org.reactivestreams.Publisher<? extends T> p7, org.reactivestreams.Publisher<? extends T> p8, org.reactivestreams.Publisher<? extends T> p9)
static <T> Observable<T>	concatArray(int prefetch, org.reactivestreams.Publisher<? extends T>... sources)
static <T> Observable<T>	concatArray(org.reactivestreams.Publisher<? extends T>... sources) Concatenates a variable number of Observable sources.
<R> Observable<R>	concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
<R> Observable<R>	concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch)
<U> Observable<U>	concatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
<U> Observable<U>	concatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper, int prefetch)
Observable<T>	concatWith(org.reactivestreams.Publisher<? extends T> other)
Observable<java.lang.Boolean>	contains(java.lang.Object o)
Observable<java.lang.Long>	count()
static <T> Observable<T>	create(org.reactivestreams.Publisher<T> onSubscribe)
<U> Observable<T>	debounce(Function<? super T,? extends org.reactivestreams.Publisher<U>> debounceSelector)
Observable<T>	debounce(long timeout, java.util.concurrent.TimeUnit unit)
Observable<T>	debounce(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	defaultIfEmpty(T value)
static <T> Observable<T>	defer(Supplier<? extends org.reactivestreams.Publisher<? extends T>> supplier)
<U> Observable<T>	delay(Function<? super T,? extends org.reactivestreams.Publisher<U>> itemDelay)
Observable<T>	delay(long delay, java.util.concurrent.TimeUnit unit)
Observable<T>	delay(long delay, java.util.concurrent.TimeUnit unit, boolean delayError)
Observable<T>	delay(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	delay(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
<U,V> Observable<T>	delay(Supplier<? extends org.reactivestreams.Publisher<U>> delaySupplier, Function<? super T,? extends org.reactivestreams.Publisher<V>> itemDelay)
Observable<T>	delaySubscription(long delay, java.util.concurrent.TimeUnit unit)
Observable<T>	delaySubscription(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<U> Observable<T>	delaySubscription(org.reactivestreams.Publisher<U> other) Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.
<U> Observable<T>	delaySubscription(Supplier<? extends org.reactivestreams.Publisher<U>> delaySupplier)
<T2> Observable<T2>	dematerialize()
Observable<T>	distinct()
<K> Observable<T>	distinct(Function<? super T,K> keySelector)
<K> Observable<T>	distinct(Function<? super T,K> keySelector, Supplier<? extends java.util.Collection<? super K>> collectionSupplier)
Observable<T>	distinctUntilChanged()
<K> Observable<T>	distinctUntilChanged(Function<? super T,K> keySelector)
Observable<T>	doOnCancel(java.lang.Runnable onCancel)
Observable<T>	doOnComplete(java.lang.Runnable onComplete)
Observable<T>	doOnEach(Consumer<? super Try<Optional<T>>> consumer)
Observable<T>	doOnEach(org.reactivestreams.Subscriber<? super T> observer)
Observable<T>	doOnError(Consumer<? super java.lang.Throwable> onError)
Observable<T>	doOnLifecycle(Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, java.lang.Runnable onCancel)
Observable<T>	doOnNext(Consumer<? super T> onNext)
Observable<T>	doOnRequest(LongConsumer onRequest)
Observable<T>	doOnSubscribe(Consumer<? super org.reactivestreams.Subscription> onSubscribe)
Observable<T>	doOnTerminate(java.lang.Runnable onTerminate)
Observable<T>	elementAt(long index)
Observable<T>	elementAt(long index, T defaultValue)
static <T> Observable<T>	empty()
Observable<T>	endWith(java.lang.Iterable<? extends T> values)
Observable<T>	endWith(org.reactivestreams.Publisher<? extends T> other)
Observable<T>	endWith(T value)
Observable<T>	endWithArray(T... values)
static <T> Observable<T>	error(Supplier<? extends java.lang.Throwable> errorSupplier)
static <T> Observable<T>	error(java.lang.Throwable e)
Observable<T>	filter(Predicate<? super T> predicate)
Observable<T>	finallyDo(java.lang.Runnable onFinally)
Observable<T>	first()
Observable<T>	first(T defaultValue)
<R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
<R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, boolean delayErrors)
<R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency)
<R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
<R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> onNextMapper, Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> onErrorMapper, Supplier<? extends org.reactivestreams.Publisher<? extends R>> onCompleteSupplier)
<R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> onNextMapper, Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> onErrorMapper, Supplier<? extends org.reactivestreams.Publisher<? extends R>> onCompleteSupplier, int maxConcurrency)
<R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency)
<U,R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
<U,R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, boolean delayError)
<U,R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, boolean delayError, int maxConcurrency)
<U,R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, boolean delayError, int maxConcurrency, int bufferSize)
<U,R> Observable<R>	flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, int maxConcurrency)
<U> Observable<U>	flatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
<U,V> Observable<V>	flatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper, BiFunction<? super T,? super U,? extends V> resultSelector)
<U> Observable<U>	flatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper, int bufferSize)
Disposable	forEach(Consumer<? super T> onNext)
Disposable	forEachWhile(Predicate<? super T> onNext)
Disposable	forEachWhile(Predicate<? super T> onNext, Consumer<? super java.lang.Throwable> onError)
Disposable	forEachWhile(Predicate<? super T> onNext, Consumer<? super java.lang.Throwable> onError, java.lang.Runnable onComplete)
static <T> Observable<T>	fromArray(T... values)
static <T> Observable<T>	fromCallable(java.util.concurrent.Callable<? extends T> supplier)
static <T> Observable<T>	fromFuture(java.util.concurrent.Future<? extends T> future)
static <T> Observable<T>	fromFuture(java.util.concurrent.Future<? extends T> future, long timeout, java.util.concurrent.TimeUnit unit)
static <T> Observable<T>	fromFuture(java.util.concurrent.Future<? extends T> future, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
static <T> Observable<T>	fromFuture(java.util.concurrent.Future<? extends T> future, Scheduler scheduler)
static <T> Observable<T>	fromIterable(java.lang.Iterable<? extends T> source)
static <T> Observable<T>	fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
static <T> Observable<T>	generate(Consumer<org.reactivestreams.Subscriber<T>> generator)
static <T,S> Observable<T>	generate(Supplier<S> initialState, BiConsumer<S,org.reactivestreams.Subscriber<T>> generator)
static <T,S> Observable<T>	generate(Supplier<S> initialState, BiConsumer<S,org.reactivestreams.Subscriber<T>> generator, Consumer<? super S> disposeState)
static <T,S> Observable<T>	generate(Supplier<S> initialState, BiFunction<S,org.reactivestreams.Subscriber<T>,S> generator)
static <T,S> Observable<T>	generate(Supplier<S> initialState, BiFunction<S,org.reactivestreams.Subscriber<T>,S> generator, Consumer<? super S> disposeState)
<K> Observable<GroupedObservable<K,T>>	groupBy(Function<? super T,? extends K> keySelector)
<K> Observable<GroupedObservable<K,T>>	groupBy(Function<? super T,? extends K> keySelector, boolean delayError)
<K,V> Observable<GroupedObservable<K,V>>	groupBy(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector)
<K,V> Observable<GroupedObservable<K,V>>	groupBy(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, boolean delayError)
<K,V> Observable<GroupedObservable<K,V>>	groupBy(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, boolean delayError, int bufferSize)
Observable<T>	ignoreElements()
static Observable<java.lang.Long>	interval(long initialDelay, long period, java.util.concurrent.TimeUnit unit)
static Observable<java.lang.Long>	interval(long initialDelay, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
static Observable<java.lang.Long>	interval(long period, java.util.concurrent.TimeUnit unit)
static Observable<java.lang.Long>	interval(long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
static Observable<java.lang.Long>	intervalRange(long start, long count, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
static Observable<java.lang.Long>	intervalRange(long start, long count, long initialDelay, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<java.lang.Boolean>	isEmpty()
static <T> Observable<T>	just(T value)
static <T> Observable<T>	just(T v1, T v2)
static <T> Observable<T>	just(T v1, T v2, T v3)
static <T> Observable<T>	just(T v1, T v2, T v3, T v4)
static <T> Observable<T>	just(T v1, T v2, T v3, T v4, T v5)
static <T> Observable<T>	just(T v1, T v2, T v3, T v4, T v5, T v6)
static <T> Observable<T>	just(T v1, T v2, T v3, T v4, T v5, T v6, T v7)
static <T> Observable<T>	just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8)
static <T> Observable<T>	just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9)
Observable<T>	last()
Observable<T>	last(T defaultValue)
<R> Observable<R>	lift(Observable.Operator<? extends R,? super T> lifter)
<R> Observable<R>	map(Function<? super T,? extends R> mapper)
Observable<Try<Optional<T>>>	materialize()
static <T> Observable<T>	merge(int maxConcurrency, int bufferSize, java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	merge(int maxConcurrency, int bufferSize, org.reactivestreams.Publisher<? extends T>... sources)
static <T> Observable<T>	merge(int maxConcurrency, org.reactivestreams.Publisher<? extends T>... sources)
static <T> Observable<T>	merge(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	merge(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, int maxConcurrency)
static <T> Observable<T>	merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources, int maxConcurrency)
static <T> Observable<T>	merge(org.reactivestreams.Publisher<? extends T>... sources)
static <T> Observable<T>	merge(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2)
static <T> Observable<T>	merge(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3)
static <T> Observable<T>	merge(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4)
static <T> Observable<T>	mergeDelayError(boolean delayErrors, java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	mergeDelayError(int maxConcurrency, int bufferSize, java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	mergeDelayError(int maxConcurrency, int bufferSize, org.reactivestreams.Publisher<? extends T>... sources)
static <T> Observable<T>	mergeDelayError(int maxConcurrency, java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	mergeDelayError(int maxConcurrency, org.reactivestreams.Publisher<? extends T>... sources)
static <T> Observable<T>	mergeDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	mergeDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources, int maxConcurrency)
static <T> Observable<T>	mergeDelayError(org.reactivestreams.Publisher<? extends T>... sources)
static <T> Observable<T>	mergeDelayError(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2)
static <T> Observable<T>	mergeDelayError(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3)
static <T> Observable<T>	mergeDelayError(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, org.reactivestreams.Publisher<? extends T> p3, org.reactivestreams.Publisher<? extends T> p4)
Observable<T>	mergeWith(org.reactivestreams.Publisher<? extends T> other)
Observable<Observable<T>>	nest() Deprecated.
static <T> Observable<T>	never()
Observable<T>	observeOn(Scheduler scheduler)
Observable<T>	observeOn(Scheduler scheduler, boolean delayError)
Observable<T>	observeOn(Scheduler scheduler, boolean delayError, int bufferSize)
<U> Observable<U>	ofType(java.lang.Class<U> clazz)
Observable<T>	onBackpressureBuffer()
Observable<T>	onBackpressureBuffer(boolean delayError)
Observable<T>	onBackpressureBuffer(int bufferSize)
Observable<T>	onBackpressureBuffer(int bufferSize, boolean delayError)
Observable<T>	onBackpressureBuffer(int bufferSize, boolean delayError, boolean unbounded)
Observable<T>	onBackpressureBuffer(int bufferSize, boolean delayError, boolean unbounded, java.lang.Runnable onOverflow)
Observable<T>	onBackpressureBuffer(int bufferSize, java.lang.Runnable onOverflow)
Observable<T>	onBackpressureDrop()
Observable<T>	onBackpressureDrop(Consumer<? super T> onDrop)
Observable<T>	onBackpressureLatest()
Observable<T>	onErrorResumeNext(Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> resumeFunction)
Observable<T>	onErrorResumeNext(org.reactivestreams.Publisher<? extends T> next)
Observable<T>	onErrorReturn(Function<? super java.lang.Throwable,? extends T> valueSupplier)
Observable<T>	onErrorReturnValue(T value)
Observable<T>	onExceptionResumeNext(org.reactivestreams.Publisher<? extends T> next)
ConnectableObservable<T>	publish()
<R> Observable<R>	publish(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector)
<R> Observable<R>	publish(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, int bufferSize)
ConnectableObservable<T>	publish(int bufferSize)
static Observable<java.lang.Integer>	range(int start, int count)
Observable<T>	reduce(BiFunction<T,T,T> reducer)
<R> Observable<R>	reduce(R seed, BiFunction<R,? super T,R> reducer)
<R> Observable<R>	reduceWith(Supplier<R> seedSupplier, BiFunction<R,? super T,R> reducer)
Observable<T>	repeat()
Observable<T>	repeat(long times)
Observable<T>	repeatUntil(BooleanSupplier stop)
Observable<T>	repeatWhen(Function<? super Observable<java.lang.Object>,? extends org.reactivestreams.Publisher<?>> handler)
ConnectableObservable<T>	replay()
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector)
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, int bufferSize)
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, int bufferSize, long time, java.util.concurrent.TimeUnit unit)
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, int bufferSize, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, int bufferSize, Scheduler scheduler)
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, long time, java.util.concurrent.TimeUnit unit)
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<R> Observable<R>	replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector, Scheduler scheduler)
ConnectableObservable<T>	replay(int bufferSize)
ConnectableObservable<T>	replay(int bufferSize, long time, java.util.concurrent.TimeUnit unit)
ConnectableObservable<T>	replay(int bufferSize, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
ConnectableObservable<T>	replay(int bufferSize, Scheduler scheduler)
ConnectableObservable<T>	replay(long time, java.util.concurrent.TimeUnit unit)
ConnectableObservable<T>	replay(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
ConnectableObservable<T>	replay(Scheduler scheduler)
Observable<T>	retry()
Observable<T>	retry(BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)
Observable<T>	retry(long times)
Observable<T>	retry(long times, Predicate<? super java.lang.Throwable> predicate)
Observable<T>	retry(Predicate<? super java.lang.Throwable> predicate)
Observable<T>	retryUntil(BooleanSupplier stop)
Observable<T>	retryWhen(Function<? super Observable<? extends java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
void	safeSubscribe(org.reactivestreams.Subscriber<? super T> s)
Observable<T>	sample(long period, java.util.concurrent.TimeUnit unit)
Observable<T>	sample(long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<U> Observable<T>	sample(org.reactivestreams.Publisher<U> sampler)
Observable<T>	scan(BiFunction<T,T,T> accumulator)
<R> Observable<R>	scan(R seed, BiFunction<R,? super T,R> accumulator)
<R> Observable<R>	scanWith(Supplier<R> seedSupplier, BiFunction<R,? super T,R> accumulator)
static <T> Observable<java.lang.Boolean>	sequenceEqual(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2)
static <T> Observable<java.lang.Boolean>	sequenceEqual(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, BiPredicate<? super T,? super T> isEqual)
static <T> Observable<java.lang.Boolean>	sequenceEqual(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, BiPredicate<? super T,? super T> isEqual, int bufferSize)
static <T> Observable<java.lang.Boolean>	sequenceEqual(org.reactivestreams.Publisher<? extends T> p1, org.reactivestreams.Publisher<? extends T> p2, int bufferSize)
Observable<T>	serialize()
Observable<T>	share()
Observable<T>	single()
Observable<T>	single(T defaultValue)
Observable<T>	skip(long n)
Observable<T>	skip(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	skipLast(int n)
Observable<T>	skipLast(long time, java.util.concurrent.TimeUnit unit)
Observable<T>	skipLast(long time, java.util.concurrent.TimeUnit unit, boolean delayError)
Observable<T>	skipLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	skipLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
Observable<T>	skipLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)
<U> Observable<T>	skipUntil(org.reactivestreams.Publisher<U> other)
Observable<T>	skipWhile(Predicate<? super T> predicate)
Observable<T>	startWith(java.lang.Iterable<? extends T> values)
Observable<T>	startWith(org.reactivestreams.Publisher<? extends T> other)
Observable<T>	startWith(T value)
Observable<T>	startWithArray(T... values)
Disposable	subscribe()
Disposable	subscribe(Consumer<? super T> onNext)
Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError)
Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, java.lang.Runnable onComplete)
Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, java.lang.Runnable onComplete, Consumer<? super org.reactivestreams.Subscription> onSubscribe)
void	subscribe(org.reactivestreams.Subscriber<? super T> s)
Observable<T>	subscribeOn(Scheduler scheduler)
Observable<T>	subscribeOn(Scheduler scheduler, boolean requestOn)
Observable<T>	switchIfEmpty(org.reactivestreams.Publisher<? extends T> other)
<R> Observable<R>	switchMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
<R> Observable<R>	switchMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize)
static <T> Observable<T>	switchOnNext(int bufferSize, org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
static <T> Observable<T>	switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
Observable<T>	take(long n)
Observable<T>	take(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	takeFirst(Predicate<? super T> predicate)
Observable<T>	takeLast(int n)
Observable<T>	takeLast(long count, long time, java.util.concurrent.TimeUnit unit)
Observable<T>	takeLast(long count, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	takeLast(long count, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)
Observable<T>	takeLast(long time, java.util.concurrent.TimeUnit unit)
Observable<T>	takeLast(long time, java.util.concurrent.TimeUnit unit, boolean delayError)
Observable<T>	takeLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	takeLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
Observable<T>	takeLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)
Observable<java.util.List<T>>	takeLastBuffer(int count)
Observable<java.util.List<T>>	takeLastBuffer(int count, long time, java.util.concurrent.TimeUnit unit)
Observable<java.util.List<T>>	takeLastBuffer(int count, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<java.util.List<T>>	takeLastBuffer(long time, java.util.concurrent.TimeUnit unit)
Observable<java.util.List<T>>	takeLastBuffer(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	takeUntil(Predicate<? super T> predicate)
<U> Observable<T>	takeUntil(org.reactivestreams.Publisher<U> other)
Observable<T>	takeWhile(Predicate<? super T> predicate)
Observable<T>	throttleFirst(long windowDuration, java.util.concurrent.TimeUnit unit)
Observable<T>	throttleFirst(long skipDuration, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	throttleLast(long intervalDuration, java.util.concurrent.TimeUnit unit)
Observable<T>	throttleLast(long intervalDuration, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<T>	throttleWithTimeout(long timeout, java.util.concurrent.TimeUnit unit)
Observable<T>	throttleWithTimeout(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<Timed<T>>	timeInterval()
Observable<Timed<T>>	timeInterval(Scheduler scheduler)
Observable<Timed<T>>	timeInterval(java.util.concurrent.TimeUnit unit)
Observable<Timed<T>>	timeInterval(java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<V> Observable<T>	timeout(Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector)
<V> Observable<T>	timeout(Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector, Observable<? extends T> other)
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit)
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, Observable<? extends T> other)
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, Observable<? extends T> other, Scheduler scheduler)
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, Scheduler scheduler)
<U,V> Observable<T>	timeout(Supplier<? extends org.reactivestreams.Publisher<U>> firstTimeoutSelector, Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector)
<U,V> Observable<T>	timeout(Supplier<? extends org.reactivestreams.Publisher<U>> firstTimeoutSelector, Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector, org.reactivestreams.Publisher<? extends T> other)
static Observable<java.lang.Long>	timer(long delay, java.util.concurrent.TimeUnit unit)
static Observable<java.lang.Long>	timer(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<Timed<T>>	timestamp()
Observable<Timed<T>>	timestamp(Scheduler scheduler)
Observable<Timed<T>>	timestamp(java.util.concurrent.TimeUnit unit)
Observable<Timed<T>>	timestamp(java.util.concurrent.TimeUnit unit, Scheduler scheduler)
<R> R	to(Function<? super Observable<T>,R> converter)
BlockingObservable<T>	toBlocking()
Observable<java.util.List<T>>	toList()
Observable<java.util.List<T>>	toList(int capacityHint)
<U extends java.util.Collection<? super T>> Observable<U>	toList(Supplier<U> collectionSupplier)
<K> Observable<java.util.Map<K,T>>	toMap(Function<? super T,? extends K> keySelector)
<K,V> Observable<java.util.Map<K,V>>	toMap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector)
<K,V> Observable<java.util.Map<K,V>>	toMap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, Supplier<? extends java.util.Map<K,V>> mapSupplier)
<K> Observable<java.util.Map<K,java.util.Collection<T>>>	toMultimap(Function<? super T,? extends K> keySelector)
<K,V> Observable<java.util.Map<K,java.util.Collection<V>>>	toMultimap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector)
<K,V> Observable<java.util.Map<K,java.util.Collection<V>>>	toMultimap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, Supplier<? extends java.util.Map<K,java.util.Collection<V>>> mapSupplier, Function<? super K,? extends java.util.Collection<? super V>> collectionFactory)
<K,V> Observable<java.util.Map<K,java.util.Collection<V>>>	toMultimap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, Supplier<java.util.Map<K,java.util.Collection<V>>> mapSupplier)
NbpObservable<T>	toNbpObservable()
Single<T>	toSingle()
Observable<java.util.List<T>>	toSortedList()
Observable<java.util.List<T>>	toSortedList(java.util.Comparator<? super T> comparator)
Observable<java.util.List<T>>	toSortedList(java.util.Comparator<? super T> comparator, int capacityHint)
Observable<java.util.List<T>>	toSortedList(int capacityHint)
void	unsafeSubscribe(org.reactivestreams.Subscriber<? super T> s)
Observable<T>	unsubscribeOn(Scheduler scheduler)
static <T,D> Observable<T>	using(Supplier<? extends D> resourceSupplier, Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier, Consumer<? super D> disposer)
static <T,D> Observable<T>	using(Supplier<? extends D> resourceSupplier, Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)
Observable<Observable<T>>	window(long count)
Observable<Observable<T>>	window(long count, long skip)
Observable<Observable<T>>	window(long count, long skip, int bufferSize)
Observable<Observable<T>>	window(long timespan, long timeskip, java.util.concurrent.TimeUnit unit)
Observable<Observable<T>>	window(long timespan, long timeskip, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<Observable<T>>	window(long timespan, long timeskip, java.util.concurrent.TimeUnit unit, Scheduler scheduler, int bufferSize)
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit)
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, long count)
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, long count, boolean restart)
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, Scheduler scheduler, long count)
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, Scheduler scheduler, long count, boolean restart)
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, Scheduler scheduler, long count, boolean restart, int bufferSize)
<B> Observable<Observable<T>>	window(org.reactivestreams.Publisher<B> boundary)
<B> Observable<Observable<T>>	window(org.reactivestreams.Publisher<B> boundary, int bufferSize)
<U,V> Observable<Observable<T>>	window(org.reactivestreams.Publisher<U> windowOpen, Function<? super U,? extends org.reactivestreams.Publisher<V>> windowClose)
<U,V> Observable<Observable<T>>	window(org.reactivestreams.Publisher<U> windowOpen, Function<? super U,? extends org.reactivestreams.Publisher<V>> windowClose, int bufferSize)
<B> Observable<Observable<T>>	window(Supplier<? extends org.reactivestreams.Publisher<B>> boundary)
<B> Observable<Observable<T>>	window(Supplier<? extends org.reactivestreams.Publisher<B>> boundary, int bufferSize)
<U,R> Observable<R>	withLatestFrom(org.reactivestreams.Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> combiner)
static <T,R> Observable<R>	zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, Function<? super java.lang.Object[],? extends R> zipper)
static <T,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources, Function<? super java.lang.Object[],? extends R> zipper)
static <T1,T2,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, BiFunction<? super T1,? super T2,? extends R> zipper)
static <T1,T2,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError)
static <T1,T2,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError, int bufferSize)
static <T1,T2,T3,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, Function3<? super T1,? super T2,? super T3,? extends R> zipper)
static <T1,T2,T3,T4,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
static <T1,T2,T3,T4,T5,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
static <T1,T2,T3,T4,T5,T6,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
static <T1,T2,T3,T4,T5,T6,T7,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, org.reactivestreams.Publisher<? extends T7> p7, Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, org.reactivestreams.Publisher<? extends T7> p7, org.reactivestreams.Publisher<? extends T8> p8, Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Observable<R>	zip(org.reactivestreams.Publisher<? extends T1> p1, org.reactivestreams.Publisher<? extends T2> p2, org.reactivestreams.Publisher<? extends T3> p3, org.reactivestreams.Publisher<? extends T4> p4, org.reactivestreams.Publisher<? extends T5> p5, org.reactivestreams.Publisher<? extends T6> p6, org.reactivestreams.Publisher<? extends T7> p7, org.reactivestreams.Publisher<? extends T8> p8, org.reactivestreams.Publisher<? extends T9> p9, Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
static <T,R> Observable<R>	zipArray(Function<? super java.lang.Object[],? extends R> zipper, boolean delayError, int bufferSize, org.reactivestreams.Publisher<? extends T>... sources)
static <T,R> Observable<R>	zipIterable(Function<? super java.lang.Object[],? extends R> zipper, boolean delayError, int bufferSize, java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
<U,R> Observable<R>	zipWith(java.lang.Iterable<U> other, BiFunction<? super T,? super U,? extends R> zipper)
<U,R> Observable<R>	zipWith(org.reactivestreams.Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> zipper)
<U,R> Observable<R>	zipWith(org.reactivestreams.Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> zipper, boolean delayError)
<U,R> Observable<R>	zipWith(org.reactivestreams.Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> zipper, boolean delayError, int bufferSize)

Methods inherited from class java.lang.Object

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

Constructor Detail

Observable

protected Observable(org.reactivestreams.Publisher<T> onSubscribe)

Method Detail

amb

public static <T> Observable<T> amb(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

amb

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> amb(org.reactivestreams.Publisher<? extends T>... sources)

bufferSize

public static int bufferSize()

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> combineLatest(Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                  boolean delayError,
                                                                                                                  int bufferSize,
                                                                                                                  org.reactivestreams.Publisher<? extends T>... sources)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                                  Function<? super java.lang.Object[],? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                                  Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                  boolean delayError)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                                  Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                  boolean delayError,
                                                                                                                  int bufferSize)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T>[] sources,
                                                                                                                  Function<? super java.lang.Object[],? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T>[] sources,
                                                                                                                  Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                  boolean delayError)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T>[] sources,
                                                                                                                  Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                  boolean delayError,
                                                                                                                  int bufferSize)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                      org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                      BiFunction<? super T1,? super T2,? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                         org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                         org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                         Function3<? super T1,? super T2,? super T3,? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                            org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                            org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                            org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                            Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                               org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                               org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                               org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                               org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                               Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                                  org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                                  org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                                  org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                                  org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                                  org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                                  Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,T7,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                                     org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                                     org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                                     org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                                     org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                                     org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                                     org.reactivestreams.Publisher<? extends T7> p7,
                                                                                                                                     Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,T7,T8,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                                        org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                                        org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                                        org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                                        org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                                        org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                                        org.reactivestreams.Publisher<? extends T7> p7,
                                                                                                                                        org.reactivestreams.Publisher<? extends T8> p8,
                                                                                                                                        Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner)

combineLatest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Observable<R> combineLatest(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                                           org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                                           org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                                           org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                                           org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                                           org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                                           org.reactivestreams.Publisher<? extends T7> p7,
                                                                                                                                           org.reactivestreams.Publisher<? extends T8> p8,
                                                                                                                                           org.reactivestreams.Publisher<? extends T9> p9,
                                                                                                                                           Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(int prefetch,
                                                                                                         java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                               int bufferSize)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2,
                                                                                                         org.reactivestreams.Publisher<? extends T> p3)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2,
                                                                                                         org.reactivestreams.Publisher<? extends T> p3,
                                                                                                         org.reactivestreams.Publisher<? extends T> p4)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2,
                                                                                                         org.reactivestreams.Publisher<? extends T> p3,
                                                                                                         org.reactivestreams.Publisher<? extends T> p4,
                                                                                                         org.reactivestreams.Publisher<? extends T> p5)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2,
                                                                                                         org.reactivestreams.Publisher<? extends T> p3,
                                                                                                         org.reactivestreams.Publisher<? extends T> p4,
                                                                                                         org.reactivestreams.Publisher<? extends T> p5,
                                                                                                         org.reactivestreams.Publisher<? extends T> p6)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2,
                                                                                                         org.reactivestreams.Publisher<? extends T> p3,
                                                                                                         org.reactivestreams.Publisher<? extends T> p4,
                                                                                                         org.reactivestreams.Publisher<? extends T> p5,
                                                                                                         org.reactivestreams.Publisher<? extends T> p6,
                                                                                                         org.reactivestreams.Publisher<? extends T> p7)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2,
                                                                                                         org.reactivestreams.Publisher<? extends T> p3,
                                                                                                         org.reactivestreams.Publisher<? extends T> p4,
                                                                                                         org.reactivestreams.Publisher<? extends T> p5,
                                                                                                         org.reactivestreams.Publisher<? extends T> p6,
                                                                                                         org.reactivestreams.Publisher<? extends T> p7,
                                                                                                         org.reactivestreams.Publisher<? extends T> p8)

concat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concat(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                         org.reactivestreams.Publisher<? extends T> p2,
                                                                                                         org.reactivestreams.Publisher<? extends T> p3,
                                                                                                         org.reactivestreams.Publisher<? extends T> p4,
                                                                                                         org.reactivestreams.Publisher<? extends T> p5,
                                                                                                         org.reactivestreams.Publisher<? extends T> p6,
                                                                                                         org.reactivestreams.Publisher<? extends T> p7,
                                                                                                         org.reactivestreams.Publisher<? extends T> p8,
                                                                                                         org.reactivestreams.Publisher<? extends T> p9)

concatArray

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concatArray(int prefetch,
                                                                                                              org.reactivestreams.Publisher<? extends T>... sources)

concatArray

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> concatArray(org.reactivestreams.Publisher<? extends T>... sources)

Concatenates a variable number of Observable sources.

Note: named this way because of overload conflict with concat(NbpObservable<NbpObservable>)

Type Parameters:

T - the common base value type

Parameters:

sources - the array of sources

Returns:

the new NbpObservable instance

Throws:

java.lang.NullPointerException - if sources is null

create

@BackpressureSupport(value=NONE)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> create(org.reactivestreams.Publisher<T> onSubscribe)

defer

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> defer(Supplier<? extends org.reactivestreams.Publisher<? extends T>> supplier)

empty

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> empty()

error

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> error(Supplier<? extends java.lang.Throwable> errorSupplier)

error

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> error(java.lang.Throwable e)

fromArray

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> fromArray(T... values)

fromCallable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> fromCallable(java.util.concurrent.Callable<? extends T> supplier)

fromFuture

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> fromFuture(java.util.concurrent.Future<? extends T> future)

fromFuture

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> fromFuture(java.util.concurrent.Future<? extends T> future,
                                                                                                             long timeout,
                                                                                                             java.util.concurrent.TimeUnit unit)

fromFuture

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public static <T> Observable<T> fromFuture(java.util.concurrent.Future<? extends T> future,
                                                                                                               long timeout,
                                                                                                               java.util.concurrent.TimeUnit unit,
                                                                                                               Scheduler scheduler)

fromFuture

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=IO)
public static <T> Observable<T> fromFuture(java.util.concurrent.Future<? extends T> future,
                                                                                                           Scheduler scheduler)

fromIterable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> fromIterable(java.lang.Iterable<? extends T> source)

fromPublisher

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)

generate

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> generate(Consumer<org.reactivestreams.Subscriber<T>> generator)

generate

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,S> Observable<T> generate(Supplier<S> initialState,
                                                                                                             BiConsumer<S,org.reactivestreams.Subscriber<T>> generator)

generate

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,S> Observable<T> generate(Supplier<S> initialState,
                                                                                                             BiConsumer<S,org.reactivestreams.Subscriber<T>> generator,
                                                                                                             Consumer<? super S> disposeState)

generate

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,S> Observable<T> generate(Supplier<S> initialState,
                                                                                                             BiFunction<S,org.reactivestreams.Subscriber<T>,S> generator)

generate

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,S> Observable<T> generate(Supplier<S> initialState,
                                                                                                             BiFunction<S,org.reactivestreams.Subscriber<T>,S> generator,
                                                                                                             Consumer<? super S> disposeState)

interval

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public static Observable<java.lang.Long> interval(long initialDelay,
                                                                                                                            long period,
                                                                                                                            java.util.concurrent.TimeUnit unit)

interval

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public static Observable<java.lang.Long> interval(long initialDelay,
                                                                                                                       long period,
                                                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                                                       Scheduler scheduler)

interval

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public static Observable<java.lang.Long> interval(long period,
                                                                                                                            java.util.concurrent.TimeUnit unit)

interval

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public static Observable<java.lang.Long> interval(long period,
                                                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                                                       Scheduler scheduler)

intervalRange

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public static Observable<java.lang.Long> intervalRange(long start,
                                                                                                                                 long count,
                                                                                                                                 long initialDelay,
                                                                                                                                 long period,
                                                                                                                                 java.util.concurrent.TimeUnit unit)

intervalRange

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public static Observable<java.lang.Long> intervalRange(long start,
                                                                                                                            long count,
                                                                                                                            long initialDelay,
                                                                                                                            long period,
                                                                                                                            java.util.concurrent.TimeUnit unit,
                                                                                                                            Scheduler scheduler)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> just(T value)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2,
                                                                                                             T v3)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2,
                                                                                                             T v3,
                                                                                                             T v4)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2,
                                                                                                             T v3,
                                                                                                             T v4,
                                                                                                             T v5)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2,
                                                                                                             T v3,
                                                                                                             T v4,
                                                                                                             T v5,
                                                                                                             T v6)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2,
                                                                                                             T v3,
                                                                                                             T v4,
                                                                                                             T v5,
                                                                                                             T v6,
                                                                                                             T v7)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2,
                                                                                                             T v3,
                                                                                                             T v4,
                                                                                                             T v5,
                                                                                                             T v6,
                                                                                                             T v7,
                                                                                                             T v8)

just

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static final <T> Observable<T> just(T v1,
                                                                                                             T v2,
                                                                                                             T v3,
                                                                                                             T v4,
                                                                                                             T v5,
                                                                                                             T v6,
                                                                                                             T v7,
                                                                                                             T v8,
                                                                                                             T v9)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(int maxConcurrency,
                                                                                                        int bufferSize,
                                                                                                        java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(int maxConcurrency,
                                                                                                        int bufferSize,
                                                                                                        org.reactivestreams.Publisher<? extends T>... sources)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(int maxConcurrency,
                                                                                                        org.reactivestreams.Publisher<? extends T>... sources)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                        int maxConcurrency)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                        int maxConcurrency)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(org.reactivestreams.Publisher<? extends T>... sources)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                        org.reactivestreams.Publisher<? extends T> p2)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                        org.reactivestreams.Publisher<? extends T> p2,
                                                                                                        org.reactivestreams.Publisher<? extends T> p3)

merge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> merge(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                        org.reactivestreams.Publisher<? extends T> p2,
                                                                                                        org.reactivestreams.Publisher<? extends T> p3,
                                                                                                        org.reactivestreams.Publisher<? extends T> p4)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(boolean delayErrors,
                                                                                                                  java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(int maxConcurrency,
                                                                                                                  int bufferSize,
                                                                                                                  java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(int maxConcurrency,
                                                                                                                  int bufferSize,
                                                                                                                  org.reactivestreams.Publisher<? extends T>... sources)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(int maxConcurrency,
                                                                                                                  java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(int maxConcurrency,
                                                                                                                  org.reactivestreams.Publisher<? extends T>... sources)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                                  int maxConcurrency)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(org.reactivestreams.Publisher<? extends T>... sources)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                                  org.reactivestreams.Publisher<? extends T> p2)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                                  org.reactivestreams.Publisher<? extends T> p2,
                                                                                                                  org.reactivestreams.Publisher<? extends T> p3)

mergeDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> mergeDelayError(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                                  org.reactivestreams.Publisher<? extends T> p2,
                                                                                                                  org.reactivestreams.Publisher<? extends T> p3,
                                                                                                                  org.reactivestreams.Publisher<? extends T> p4)

never

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> never()

range

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static Observable<java.lang.Integer> range(int start,
                                                                                                                    int count)

sequenceEqual

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<java.lang.Boolean> sequenceEqual(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                                                org.reactivestreams.Publisher<? extends T> p2)

sequenceEqual

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<java.lang.Boolean> sequenceEqual(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                                                org.reactivestreams.Publisher<? extends T> p2,
                                                                                                                                BiPredicate<? super T,? super T> isEqual)

sequenceEqual

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<java.lang.Boolean> sequenceEqual(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                                                org.reactivestreams.Publisher<? extends T> p2,
                                                                                                                                BiPredicate<? super T,? super T> isEqual,
                                                                                                                                int bufferSize)

sequenceEqual

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<java.lang.Boolean> sequenceEqual(org.reactivestreams.Publisher<? extends T> p1,
                                                                                                                                org.reactivestreams.Publisher<? extends T> p2,
                                                                                                                                int bufferSize)

switchOnNext

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> switchOnNext(int bufferSize,
                                                                                                               org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)

switchOnNext

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T> Observable<T> switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)

timer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public static Observable<java.lang.Long> timer(long delay,
                                                                                                                         java.util.concurrent.TimeUnit unit)

timer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public static Observable<java.lang.Long> timer(long delay,
                                                                                                                    java.util.concurrent.TimeUnit unit,
                                                                                                                    Scheduler scheduler)

using

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T,D> Observable<T> using(Supplier<? extends D> resourceSupplier,
                                                                                                                  Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier,
                                                                                                                  Consumer<? super D> disposer)

using

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public static <T,D> Observable<T> using(Supplier<? extends D> resourceSupplier,
                                                                                                                  Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier,
                                                                                                                  Consumer<? super D> disposer,
                                                                                                                  boolean eager)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                        Function<? super java.lang.Object[],? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> zip(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                        Function<? super java.lang.Object[],? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                            org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                            BiFunction<? super T1,? super T2,? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                            org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                            BiFunction<? super T1,? super T2,? extends R> zipper,
                                                                                                            boolean delayError)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                            org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                            BiFunction<? super T1,? super T2,? extends R> zipper,
                                                                                                            boolean delayError,
                                                                                                            int bufferSize)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                               org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                               org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                               Function3<? super T1,? super T2,? super T3,? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                  org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                  org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                  org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                  Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                     org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                     org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                     org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                     org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                     Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                        org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                        org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                        org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                        org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                        org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                        Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,T7,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                           org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                           org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                           org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                           org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                           org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                           org.reactivestreams.Publisher<? extends T7> p7,
                                                                                                                           Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,T7,T8,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                              org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                              org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                              org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                              org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                              org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                              org.reactivestreams.Publisher<? extends T7> p7,
                                                                                                                              org.reactivestreams.Publisher<? extends T8> p8,
                                                                                                                              Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)

zip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Observable<R> zip(org.reactivestreams.Publisher<? extends T1> p1,
                                                                                                                                 org.reactivestreams.Publisher<? extends T2> p2,
                                                                                                                                 org.reactivestreams.Publisher<? extends T3> p3,
                                                                                                                                 org.reactivestreams.Publisher<? extends T4> p4,
                                                                                                                                 org.reactivestreams.Publisher<? extends T5> p5,
                                                                                                                                 org.reactivestreams.Publisher<? extends T6> p6,
                                                                                                                                 org.reactivestreams.Publisher<? extends T7> p7,
                                                                                                                                 org.reactivestreams.Publisher<? extends T8> p8,
                                                                                                                                 org.reactivestreams.Publisher<? extends T9> p9,
                                                                                                                                 Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)

zipArray

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> zipArray(Function<? super java.lang.Object[],? extends R> zipper,
                                                                                                             boolean delayError,
                                                                                                             int bufferSize,
                                                                                                             org.reactivestreams.Publisher<? extends T>... sources)

zipIterable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public static <T,R> Observable<R> zipIterable(Function<? super java.lang.Object[],? extends R> zipper,
                                                                                                                boolean delayError,
                                                                                                                int bufferSize,
                                                                                                                java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

all

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.lang.Boolean> all(Predicate<? super T> predicate)

ambWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> ambWith(org.reactivestreams.Publisher<? extends T> other)

any

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.lang.Boolean> any(Predicate<? super T> predicate)

asObservable

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> asObservable()

buffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> buffer(int count)

buffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> buffer(int count,
                                                                                                                    int skip)

buffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U extends java.util.Collection<? super T>> Observable<U> buffer(int count,
                                                                                                                                                int skip,
                                                                                                                                                Supplier<U> bufferSupplier)

buffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U extends java.util.Collection<? super T>> Observable<U> buffer(int count,
                                                                                                                                                Supplier<U> bufferSupplier)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<java.util.List<T>> buffer(long timespan,
                                                                                                                            long timeskip,
                                                                                                                            java.util.concurrent.TimeUnit unit)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<java.util.List<T>> buffer(long timespan,
                                                                                                                       long timeskip,
                                                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                                                       Scheduler scheduler)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final <U extends java.util.Collection<? super T>> Observable<U> buffer(long timespan,
                                                                                                                                                   long timeskip,
                                                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                                                   Scheduler scheduler,
                                                                                                                                                   Supplier<U> bufferSupplier)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<java.util.List<T>> buffer(long timespan,
                                                                                                                            java.util.concurrent.TimeUnit unit)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<java.util.List<T>> buffer(long timespan,
                                                                                                                            java.util.concurrent.TimeUnit unit,
                                                                                                                            int count)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<java.util.List<T>> buffer(long timespan,
                                                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                                                       int count,
                                                                                                                       Scheduler scheduler)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final <U extends java.util.Collection<? super T>> Observable<U> buffer(long timespan,
                                                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                                                   int count,
                                                                                                                                                   Scheduler scheduler,
                                                                                                                                                   Supplier<U> bufferSupplier,
                                                                                                                                                   boolean restartTimerOnMaxSize)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<java.util.List<T>> buffer(long timespan,
                                                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                                                       Scheduler scheduler)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <TOpening,TClosing> Observable<java.util.List<T>> buffer(Observable<? extends TOpening> bufferOpenings,
                                                                                                                                         Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> bufferClosingSelector)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <TOpening,TClosing,U extends java.util.Collection<? super T>> Observable<U> buffer(Observable<? extends TOpening> bufferOpenings,
                                                                                                                                                                   Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> bufferClosingSelector,
                                                                                                                                                                   Supplier<U> bufferSupplier)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B> Observable<java.util.List<T>> buffer(org.reactivestreams.Publisher<B> boundary)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B> Observable<java.util.List<T>> buffer(org.reactivestreams.Publisher<B> boundary,
                                                                                                                         int initialCapacity)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B,U extends java.util.Collection<? super T>> Observable<U> buffer(org.reactivestreams.Publisher<B> boundary,
                                                                                                                                                   Supplier<U> bufferSupplier)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B> Observable<java.util.List<T>> buffer(Supplier<? extends org.reactivestreams.Publisher<B>> boundarySupplier)

buffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B,U extends java.util.Collection<? super T>> Observable<U> buffer(Supplier<? extends org.reactivestreams.Publisher<B>> boundarySupplier,
                                                                                                                                                   Supplier<U> bufferSupplier)

cache

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> cache()

cache

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> cache(int capacityHint)

cast

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> cast(java.lang.Class<U> clazz)

collect

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> collect(Supplier<? extends U> initialValueSupplier,
                                                                                                                 BiConsumer<? super U,? super T> collector)

collectInto

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> collectInto(U initialValue,
                                                                                                                     BiConsumer<? super U,? super T> collector)

compose

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> compose(Observable.Transformer<T,R> composer)

concatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

concatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                           int prefetch)

concatMapIterable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> concatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)

concatMapIterable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> concatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper,
                                                                                                                   int prefetch)

concatWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> concatWith(org.reactivestreams.Publisher<? extends T> other)

contains

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.lang.Boolean> contains(java.lang.Object o)

count

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.lang.Long> count()

debounce

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <U> Observable<T> debounce(Function<? super T,? extends org.reactivestreams.Publisher<U>> debounceSelector)

debounce

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> debounce(long timeout,
                                                                                                              java.util.concurrent.TimeUnit unit)

debounce

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> debounce(long timeout,
                                                                                                         java.util.concurrent.TimeUnit unit,
                                                                                                         Scheduler scheduler)

defaultIfEmpty

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> defaultIfEmpty(T value)

delay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U> Observable<T> delay(Function<? super T,? extends org.reactivestreams.Publisher<U>> itemDelay)

delay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> delay(long delay,
                                                                                                          java.util.concurrent.TimeUnit unit)

delay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> delay(long delay,
                                                                                                          java.util.concurrent.TimeUnit unit,
                                                                                                          boolean delayError)

delay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> delay(long delay,
                                                                                                     java.util.concurrent.TimeUnit unit,
                                                                                                     Scheduler scheduler)

delay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> delay(long delay,
                                                                                                     java.util.concurrent.TimeUnit unit,
                                                                                                     Scheduler scheduler,
                                                                                                     boolean delayError)

delay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,V> Observable<T> delay(Supplier<? extends org.reactivestreams.Publisher<U>> delaySupplier,
                                                                                                         Function<? super T,? extends org.reactivestreams.Publisher<V>> itemDelay)

delaySubscription

public final <U> Observable<T> delaySubscription(org.reactivestreams.Publisher<U> other)

Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.

Backpressure:

The operator forwards the backpressure requests to this Observable once the subscription happens and requests Long.MAX_VALUE from the other Observable

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

U - the value type of the other Observable, irrelevant

Parameters:

other - the other Observable that should trigger the subscription to this Observable.

Returns:

an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.

delaySubscription

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> delaySubscription(long delay,
                                                                                                                      java.util.concurrent.TimeUnit unit)

delaySubscription

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> delaySubscription(long delay,
                                                                                                                 java.util.concurrent.TimeUnit unit,
                                                                                                                 Scheduler scheduler)

delaySubscription

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U> Observable<T> delaySubscription(Supplier<? extends org.reactivestreams.Publisher<U>> delaySupplier)

dematerialize

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <T2> Observable<T2> dematerialize()

distinct

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> distinct()

distinct

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K> Observable<T> distinct(Function<? super T,K> keySelector)

distinct

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K> Observable<T> distinct(Function<? super T,K> keySelector,
                                                                                                          Supplier<? extends java.util.Collection<? super K>> collectionSupplier)

distinctUntilChanged

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> distinctUntilChanged()

distinctUntilChanged

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K> Observable<T> distinctUntilChanged(Function<? super T,K> keySelector)

doOnCancel

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnCancel(java.lang.Runnable onCancel)

doOnComplete

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnComplete(java.lang.Runnable onComplete)

doOnEach

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnEach(Consumer<? super Try<Optional<T>>> consumer)

doOnEach

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnEach(org.reactivestreams.Subscriber<? super T> observer)

doOnError

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnError(Consumer<? super java.lang.Throwable> onError)

doOnLifecycle

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnLifecycle(Consumer<? super org.reactivestreams.Subscription> onSubscribe,
                                                                                                                   LongConsumer onRequest,
                                                                                                                   java.lang.Runnable onCancel)

doOnNext

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnNext(Consumer<? super T> onNext)

doOnRequest

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnRequest(LongConsumer onRequest)

doOnSubscribe

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnSubscribe(Consumer<? super org.reactivestreams.Subscription> onSubscribe)

doOnTerminate

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> doOnTerminate(java.lang.Runnable onTerminate)

elementAt

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> elementAt(long index)

elementAt

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> elementAt(long index,
                                                                                                               T defaultValue)

endWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> endWith(java.lang.Iterable<? extends T> values)

endWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> endWith(org.reactivestreams.Publisher<? extends T> other)

endWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> endWith(T value)

endWithArray

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> endWithArray(T... values)

filter

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> filter(Predicate<? super T> predicate)

finallyDo

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> finallyDo(java.lang.Runnable onFinally)

first

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final Observable<T> first()

first

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final Observable<T> first(T defaultValue)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                         boolean delayErrors)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                         boolean delayErrors,
                                                                                                         int maxConcurrency)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                         boolean delayErrors,
                                                                                                         int maxConcurrency,
                                                                                                         int bufferSize)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> onNextMapper,
                                                                                                         Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> onErrorMapper,
                                                                                                         Supplier<? extends org.reactivestreams.Publisher<? extends R>> onCompleteSupplier)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> onNextMapper,
                                                                                                         Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> onErrorMapper,
                                                                                                         Supplier<? extends org.reactivestreams.Publisher<? extends R>> onCompleteSupplier,
                                                                                                         int maxConcurrency)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                         int maxConcurrency)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
                                                                                                           BiFunction<? super T,? super U,? extends R> resultSelector)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
                                                                                                           BiFunction<? super T,? super U,? extends R> combiner,
                                                                                                           boolean delayError)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
                                                                                                           BiFunction<? super T,? super U,? extends R> combiner,
                                                                                                           boolean delayError,
                                                                                                           int maxConcurrency)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
                                                                                                           BiFunction<? super T,? super U,? extends R> combiner,
                                                                                                           boolean delayError,
                                                                                                           int maxConcurrency,
                                                                                                           int bufferSize)

flatMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
                                                                                                           BiFunction<? super T,? super U,? extends R> combiner,
                                                                                                           int maxConcurrency)

flatMapIterable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> flatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)

flatMapIterable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,V> Observable<V> flatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper,
                                                                                                                   BiFunction<? super T,? super U,? extends V> resultSelector)

flatMapIterable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> flatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper,
                                                                                                                 int bufferSize)

forEach

@BackpressureSupport(value=NONE)
 @SchedulerSupport(value=NONE)
public final Disposable forEach(Consumer<? super T> onNext)

forEachWhile

@BackpressureSupport(value=NONE)
 @SchedulerSupport(value=NONE)
public final Disposable forEachWhile(Predicate<? super T> onNext)

forEachWhile

@BackpressureSupport(value=NONE)
 @SchedulerSupport(value=NONE)
public final Disposable forEachWhile(Predicate<? super T> onNext,
                                                                                                       Consumer<? super java.lang.Throwable> onError)

forEachWhile

@BackpressureSupport(value=NONE)
 @SchedulerSupport(value=NONE)
public final Disposable forEachWhile(Predicate<? super T> onNext,
                                                                                                       Consumer<? super java.lang.Throwable> onError,
                                                                                                       java.lang.Runnable onComplete)

groupBy

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K> Observable<GroupedObservable<K,T>> groupBy(Function<? super T,? extends K> keySelector)

groupBy

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K> Observable<GroupedObservable<K,T>> groupBy(Function<? super T,? extends K> keySelector,
                                                                                                                              boolean delayError)

groupBy

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<GroupedObservable<K,V>> groupBy(Function<? super T,? extends K> keySelector,
                                                                                                                                Function<? super T,? extends V> valueSelector)

groupBy

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<GroupedObservable<K,V>> groupBy(Function<? super T,? extends K> keySelector,
                                                                                                                                Function<? super T,? extends V> valueSelector,
                                                                                                                                boolean delayError)

groupBy

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<GroupedObservable<K,V>> groupBy(Function<? super T,? extends K> keySelector,
                                                                                                                                Function<? super T,? extends V> valueSelector,
                                                                                                                                boolean delayError,
                                                                                                                                int bufferSize)

ignoreElements

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> ignoreElements()

isEmpty

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.lang.Boolean> isEmpty()

last

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> last()

last

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> last(T defaultValue)

lift

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> lift(Observable.Operator<? extends R,? super T> lifter)

map

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> map(Function<? super T,? extends R> mapper)

materialize

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<Try<Optional<T>>> materialize()

mergeWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> mergeWith(org.reactivestreams.Publisher<? extends T> other)

nest

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
 @Deprecated
public final Observable<Observable<T>> nest()

Deprecated.

observeOn

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> observeOn(Scheduler scheduler)

observeOn

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> observeOn(Scheduler scheduler,
                                                                                                         boolean delayError)

observeOn

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> observeOn(Scheduler scheduler,
                                                                                                         boolean delayError,
                                                                                                         int bufferSize)

ofType

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final <U> Observable<U> ofType(java.lang.Class<U> clazz)

onBackpressureBuffer

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureBuffer()

onBackpressureBuffer

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureBuffer(boolean delayError)

onBackpressureBuffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureBuffer(int bufferSize)

onBackpressureBuffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureBuffer(int bufferSize,
                                                                                                                   boolean delayError)

onBackpressureBuffer

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureBuffer(int bufferSize,
                                                                                                                     boolean delayError,
                                                                                                                     boolean unbounded)

onBackpressureBuffer

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureBuffer(int bufferSize,
                                                                                                                     boolean delayError,
                                                                                                                     boolean unbounded,
                                                                                                                     java.lang.Runnable onOverflow)

onBackpressureBuffer

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureBuffer(int bufferSize,
                                                                                                                   java.lang.Runnable onOverflow)

onBackpressureDrop

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureDrop()

onBackpressureDrop

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureDrop(Consumer<? super T> onDrop)

onBackpressureLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> onBackpressureLatest()

onErrorResumeNext

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> onErrorResumeNext(Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> resumeFunction)

onErrorResumeNext

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> onErrorResumeNext(org.reactivestreams.Publisher<? extends T> next)

onErrorReturn

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> onErrorReturn(Function<? super java.lang.Throwable,? extends T> valueSupplier)

onErrorReturnValue

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> onErrorReturnValue(T value)

onExceptionResumeNext

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> onExceptionResumeNext(org.reactivestreams.Publisher<? extends T> next)

publish

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final ConnectableObservable<T> publish()

publish

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> publish(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector)

publish

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> publish(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                         int bufferSize)

publish

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final ConnectableObservable<T> publish(int bufferSize)

reduce

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> reduce(BiFunction<T,T,T> reducer)

reduce

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> reduce(R seed,
                                                                                                                BiFunction<R,? super T,R> reducer)

reduceWith

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> reduceWith(Supplier<R> seedSupplier,
                                                                                                                    BiFunction<R,? super T,R> reducer)

repeat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> repeat()

repeat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> repeat(long times)

repeatUntil

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> repeatUntil(BooleanSupplier stop)

repeatWhen

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> repeatWhen(Function<? super Observable<java.lang.Object>,? extends org.reactivestreams.Publisher<?>> handler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final ConnectableObservable<T> replay()

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                        int bufferSize)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                               int bufferSize,
                                                                                                               long time,
                                                                                                               java.util.concurrent.TimeUnit unit)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                          int bufferSize,
                                                                                                          long time,
                                                                                                          java.util.concurrent.TimeUnit unit,
                                                                                                          Scheduler scheduler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                          int bufferSize,
                                                                                                          Scheduler scheduler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                               long time,
                                                                                                               java.util.concurrent.TimeUnit unit)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                          long time,
                                                                                                          java.util.concurrent.TimeUnit unit,
                                                                                                          Scheduler scheduler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final <R> Observable<R> replay(Function<? super Observable<T>,? extends org.reactivestreams.Publisher<R>> selector,
                                                                                                          Scheduler scheduler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final ConnectableObservable<T> replay(int bufferSize)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final ConnectableObservable<T> replay(int bufferSize,
                                                                                                                      long time,
                                                                                                                      java.util.concurrent.TimeUnit unit)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final ConnectableObservable<T> replay(int bufferSize,
                                                                                                                 long time,
                                                                                                                 java.util.concurrent.TimeUnit unit,
                                                                                                                 Scheduler scheduler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final ConnectableObservable<T> replay(int bufferSize,
                                                                                                                 Scheduler scheduler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final ConnectableObservable<T> replay(long time,
                                                                                                                      java.util.concurrent.TimeUnit unit)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final ConnectableObservable<T> replay(long time,
                                                                                                                 java.util.concurrent.TimeUnit unit,
                                                                                                                 Scheduler scheduler)

replay

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final ConnectableObservable<T> replay(Scheduler scheduler)

retry

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> retry()

retry

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> retry(BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)

retry

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> retry(long times)

retry

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> retry(long times,
                                                                                                   Predicate<? super java.lang.Throwable> predicate)

retry

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> retry(Predicate<? super java.lang.Throwable> predicate)

retryUntil

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> retryUntil(BooleanSupplier stop)

retryWhen

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> retryWhen(Function<? super Observable<? extends java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler)

safeSubscribe

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final void safeSubscribe(org.reactivestreams.Subscriber<? super T> s)

sample

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> sample(long period,
                                                                                                            java.util.concurrent.TimeUnit unit)

sample

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> sample(long period,
                                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                                       Scheduler scheduler)

sample

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <U> Observable<T> sample(org.reactivestreams.Publisher<U> sampler)

scan

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> scan(BiFunction<T,T,T> accumulator)

scan

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> scan(R seed,
                                                                                                      BiFunction<R,? super T,R> accumulator)

scanWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> scanWith(Supplier<R> seedSupplier,
                                                                                                          BiFunction<R,? super T,R> accumulator)

serialize

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> serialize()

share

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> share()

single

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> single()

single

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<T> single(T defaultValue)

skip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> skip(long n)

skip

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> skip(long time,
                                                                                                    java.util.concurrent.TimeUnit unit,
                                                                                                    Scheduler scheduler)

skipLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> skipLast(int n)

skipLast

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<T> skipLast(long time,
                                                                                                                    java.util.concurrent.TimeUnit unit)

skipLast

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<T> skipLast(long time,
                                                                                                                    java.util.concurrent.TimeUnit unit,
                                                                                                                    boolean delayError)

skipLast

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> skipLast(long time,
                                                                                                                java.util.concurrent.TimeUnit unit,
                                                                                                                Scheduler scheduler)

skipLast

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> skipLast(long time,
                                                                                                                java.util.concurrent.TimeUnit unit,
                                                                                                                Scheduler scheduler,
                                                                                                                boolean delayError)

skipLast

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> skipLast(long time,
                                                                                                                java.util.concurrent.TimeUnit unit,
                                                                                                                Scheduler scheduler,
                                                                                                                boolean delayError,
                                                                                                                int bufferSize)

skipUntil

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U> Observable<T> skipUntil(org.reactivestreams.Publisher<U> other)

skipWhile

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> skipWhile(Predicate<? super T> predicate)

startWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> startWith(java.lang.Iterable<? extends T> values)

startWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> startWith(org.reactivestreams.Publisher<? extends T> other)

startWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> startWith(T value)

startWithArray

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> startWithArray(T... values)

subscribe

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Disposable subscribe()

subscribe

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Disposable subscribe(Consumer<? super T> onNext)

subscribe

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Disposable subscribe(Consumer<? super T> onNext,
                                                                                                            Consumer<? super java.lang.Throwable> onError)

subscribe

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Disposable subscribe(Consumer<? super T> onNext,
                                                                                                            Consumer<? super java.lang.Throwable> onError,
                                                                                                            java.lang.Runnable onComplete)

subscribe

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final Disposable subscribe(Consumer<? super T> onNext,
                                                                                                       Consumer<? super java.lang.Throwable> onError,
                                                                                                       java.lang.Runnable onComplete,
                                                                                                       Consumer<? super org.reactivestreams.Subscription> onSubscribe)

subscribe

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final void subscribe(org.reactivestreams.Subscriber<? super T> s)

Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

subscribeOn

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> subscribeOn(Scheduler scheduler)

subscribeOn

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> subscribeOn(Scheduler scheduler,
                                                                                                                   boolean requestOn)

switchIfEmpty

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> switchIfEmpty(org.reactivestreams.Publisher<? extends T> other)

switchMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> switchMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

switchMap

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <R> Observable<R> switchMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                                                                                           int bufferSize)

take

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final Observable<T> take(long n)

take

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> take(long time,
                                                                                                          java.util.concurrent.TimeUnit unit,
                                                                                                          Scheduler scheduler)

takeFirst

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final Observable<T> takeFirst(Predicate<? super T> predicate)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<T> takeLast(int n)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<T> takeLast(long count,
                                                                                                            long time,
                                                                                                            java.util.concurrent.TimeUnit unit)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> takeLast(long count,
                                                                                                        long time,
                                                                                                        java.util.concurrent.TimeUnit unit,
                                                                                                        Scheduler scheduler)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> takeLast(long count,
                                                                                                        long time,
                                                                                                        java.util.concurrent.TimeUnit unit,
                                                                                                        Scheduler scheduler,
                                                                                                        boolean delayError,
                                                                                                        int bufferSize)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<T> takeLast(long time,
                                                                                                            java.util.concurrent.TimeUnit unit)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<T> takeLast(long time,
                                                                                                            java.util.concurrent.TimeUnit unit,
                                                                                                            boolean delayError)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> takeLast(long time,
                                                                                                        java.util.concurrent.TimeUnit unit,
                                                                                                        Scheduler scheduler)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> takeLast(long time,
                                                                                                        java.util.concurrent.TimeUnit unit,
                                                                                                        Scheduler scheduler,
                                                                                                        boolean delayError)

takeLast

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> takeLast(long time,
                                                                                                        java.util.concurrent.TimeUnit unit,
                                                                                                        Scheduler scheduler,
                                                                                                        boolean delayError,
                                                                                                        int bufferSize)

takeLastBuffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> takeLastBuffer(int count)

takeLastBuffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<java.util.List<T>> takeLastBuffer(int count,
                                                                                                                                  long time,
                                                                                                                                  java.util.concurrent.TimeUnit unit)

takeLastBuffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<java.util.List<T>> takeLastBuffer(int count,
                                                                                                                              long time,
                                                                                                                              java.util.concurrent.TimeUnit unit,
                                                                                                                              Scheduler scheduler)

takeLastBuffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<java.util.List<T>> takeLastBuffer(long time,
                                                                                                                                  java.util.concurrent.TimeUnit unit)

takeLastBuffer

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<java.util.List<T>> takeLastBuffer(long time,
                                                                                                                              java.util.concurrent.TimeUnit unit,
                                                                                                                              Scheduler scheduler)

takeUntil

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> takeUntil(Predicate<? super T> predicate)

takeUntil

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final <U> Observable<T> takeUntil(org.reactivestreams.Publisher<U> other)

takeWhile

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final Observable<T> takeWhile(Predicate<? super T> predicate)

throttleFirst

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> throttleFirst(long windowDuration,
                                                                                                                   java.util.concurrent.TimeUnit unit)

throttleFirst

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> throttleFirst(long skipDuration,
                                                                                                              java.util.concurrent.TimeUnit unit,
                                                                                                              Scheduler scheduler)

throttleLast

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> throttleLast(long intervalDuration,
                                                                                                                  java.util.concurrent.TimeUnit unit)

throttleLast

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> throttleLast(long intervalDuration,
                                                                                                             java.util.concurrent.TimeUnit unit,
                                                                                                             Scheduler scheduler)

throttleWithTimeout

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> throttleWithTimeout(long timeout,
                                                                                                                         java.util.concurrent.TimeUnit unit)

throttleWithTimeout

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> throttleWithTimeout(long timeout,
                                                                                                                    java.util.concurrent.TimeUnit unit,
                                                                                                                    Scheduler scheduler)

timeInterval

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<Timed<T>> timeInterval()

timeInterval

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Timed<T>> timeInterval(Scheduler scheduler)

timeInterval

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<Timed<T>> timeInterval(java.util.concurrent.TimeUnit unit)

timeInterval

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Timed<T>> timeInterval(java.util.concurrent.TimeUnit unit,
                                                                                                                           Scheduler scheduler)

timeout

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final <V> Observable<T> timeout(Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector)

timeout

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <V> Observable<T> timeout(Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector,
                                                                                                         Observable<? extends T> other)

timeout

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> timeout(long timeout,
                                                                                                                    java.util.concurrent.TimeUnit timeUnit)

timeout

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<T> timeout(long timeout,
                                                                                                            java.util.concurrent.TimeUnit timeUnit,
                                                                                                            Observable<? extends T> other)

timeout

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> timeout(long timeout,
                                                                                                       java.util.concurrent.TimeUnit timeUnit,
                                                                                                       Observable<? extends T> other,
                                                                                                       Scheduler scheduler)

timeout

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> timeout(long timeout,
                                                                                                               java.util.concurrent.TimeUnit timeUnit,
                                                                                                               Scheduler scheduler)

timeout

public final <U,V> Observable<T> timeout(Supplier<? extends org.reactivestreams.Publisher<U>> firstTimeoutSelector,
                                         Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector)

timeout

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,V> Observable<T> timeout(Supplier<? extends org.reactivestreams.Publisher<U>> firstTimeoutSelector,
                                                                                                           Function<? super T,? extends org.reactivestreams.Publisher<V>> timeoutSelector,
                                                                                                           org.reactivestreams.Publisher<? extends T> other)

timestamp

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<Timed<T>> timestamp()

timestamp

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Timed<T>> timestamp(Scheduler scheduler)

timestamp

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=TRAMPOLINE)
public final Observable<Timed<T>> timestamp(java.util.concurrent.TimeUnit unit)

timestamp

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Timed<T>> timestamp(java.util.concurrent.TimeUnit unit,
                                                                                                                        Scheduler scheduler)

to

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final <R> R to(Function<? super Observable<T>,R> converter)

toBlocking

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final BlockingObservable<T> toBlocking()

toList

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> toList()

toList

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> toList(int capacityHint)

toList

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <U extends java.util.Collection<? super T>> Observable<U> toList(Supplier<U> collectionSupplier)

toMap

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <K> Observable<java.util.Map<K,T>> toMap(Function<? super T,? extends K> keySelector)

toMap

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<java.util.Map<K,V>> toMap(Function<? super T,? extends K> keySelector,
                                                                                                                                  Function<? super T,? extends V> valueSelector)

toMap

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<java.util.Map<K,V>> toMap(Function<? super T,? extends K> keySelector,
                                                                                                                                  Function<? super T,? extends V> valueSelector,
                                                                                                                                  Supplier<? extends java.util.Map<K,V>> mapSupplier)

toMultimap

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <K> Observable<java.util.Map<K,java.util.Collection<T>>> toMultimap(Function<? super T,? extends K> keySelector)

toMultimap

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<java.util.Map<K,java.util.Collection<V>>> toMultimap(Function<? super T,? extends K> keySelector,
                                                                                                                                                             Function<? super T,? extends V> valueSelector)

toMultimap

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<java.util.Map<K,java.util.Collection<V>>> toMultimap(Function<? super T,? extends K> keySelector,
                                                                                                                                                             Function<? super T,? extends V> valueSelector,
                                                                                                                                                             Supplier<? extends java.util.Map<K,java.util.Collection<V>>> mapSupplier,
                                                                                                                                                             Function<? super K,? extends java.util.Collection<? super V>> collectionFactory)

toMultimap

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final <K,V> Observable<java.util.Map<K,java.util.Collection<V>>> toMultimap(Function<? super T,? extends K> keySelector,
                                                                                                                                                             Function<? super T,? extends V> valueSelector,
                                                                                                                                                             Supplier<java.util.Map<K,java.util.Collection<V>>> mapSupplier)

toNbpObservable

@BackpressureSupport(value=NONE)
 @SchedulerSupport(value=NONE)
public final NbpObservable<T> toNbpObservable()

toSingle

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Single<T> toSingle()

toSortedList

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> toSortedList()

toSortedList

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> toSortedList(java.util.Comparator<? super T> comparator)

toSortedList

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> toSortedList(java.util.Comparator<? super T> comparator,
                                                                                                                                  int capacityHint)

toSortedList

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value=NONE)
public final Observable<java.util.List<T>> toSortedList(int capacityHint)

unsafeSubscribe

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value=NONE)
public final void unsafeSubscribe(org.reactivestreams.Subscriber<? super T> s)

unsubscribeOn

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=CUSTOM)
public final Observable<T> unsubscribeOn(Scheduler scheduler)

window

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<Observable<T>> window(long count)

window

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<Observable<T>> window(long count,
                                                                                                                long skip)

window

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final Observable<Observable<T>> window(long count,
                                                                                                                long skip,
                                                                                                                int bufferSize)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                        long timeskip,
                                                                                                                        java.util.concurrent.TimeUnit unit)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                   long timeskip,
                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                   Scheduler scheduler)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                   long timeskip,
                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                   Scheduler scheduler,
                                                                                                                   int bufferSize)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                        java.util.concurrent.TimeUnit unit)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                        java.util.concurrent.TimeUnit unit,
                                                                                                                        long count)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=COMPUTATION)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                        java.util.concurrent.TimeUnit unit,
                                                                                                                        long count,
                                                                                                                        boolean restart)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                   Scheduler scheduler)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                   Scheduler scheduler,
                                                                                                                   long count)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                   Scheduler scheduler,
                                                                                                                   long count,
                                                                                                                   boolean restart)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=CUSTOM)
public final Observable<Observable<T>> window(long timespan,
                                                                                                                   java.util.concurrent.TimeUnit unit,
                                                                                                                   Scheduler scheduler,
                                                                                                                   long count,
                                                                                                                   boolean restart,
                                                                                                                   int bufferSize)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B> Observable<Observable<T>> window(org.reactivestreams.Publisher<B> boundary)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B> Observable<Observable<T>> window(org.reactivestreams.Publisher<B> boundary,
                                                                                                                     int bufferSize)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <U,V> Observable<Observable<T>> window(org.reactivestreams.Publisher<U> windowOpen,
                                                                                                                       Function<? super U,? extends org.reactivestreams.Publisher<V>> windowClose)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <U,V> Observable<Observable<T>> window(org.reactivestreams.Publisher<U> windowOpen,
                                                                                                                       Function<? super U,? extends org.reactivestreams.Publisher<V>> windowClose,
                                                                                                                       int bufferSize)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B> Observable<Observable<T>> window(Supplier<? extends org.reactivestreams.Publisher<B>> boundary)

window

@BackpressureSupport(value=ERROR)
 @SchedulerSupport(value=NONE)
public final <B> Observable<Observable<T>> window(Supplier<? extends org.reactivestreams.Publisher<B>> boundary,
                                                                                                                     int bufferSize)

withLatestFrom

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> withLatestFrom(org.reactivestreams.Publisher<? extends U> other,
                                                                                                                          BiFunction<? super T,? super U,? extends R> combiner)

zipWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> zipWith(java.lang.Iterable<U> other,
                                                                                                           BiFunction<? super T,? super U,? extends R> zipper)

zipWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> zipWith(org.reactivestreams.Publisher<? extends U> other,
                                                                                                           BiFunction<? super T,? super U,? extends R> zipper)

zipWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> zipWith(org.reactivestreams.Publisher<? extends U> other,
                                                                                                           BiFunction<? super T,? super U,? extends R> zipper,
                                                                                                           boolean delayError)

zipWith

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value=NONE)
public final <U,R> Observable<R> zipWith(org.reactivestreams.Publisher<? extends U> other,
                                                                                                           BiFunction<? super T,? super U,? extends R> zipper,
                                                                                                           boolean delayError,
                                                                                                           int bufferSize)