/** * Copyright 2014 Netflix, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See * the License for the specific language governing permissions and limitations under the License. */ package rx; import static rx.functions.Functions.alwaysFalse; import java.util.*; import java.util.concurrent.*; import rx.exceptions.*; import rx.functions.*; import rx.internal.operators.*; import rx.internal.util.ScalarSynchronousObservable; import rx.observables.*; import rx.observers.SafeSubscriber; import rx.plugins.*; import rx.schedulers.*; import rx.subjects.*; import rx.subscriptions.Subscriptions; /** * The Observable class that implements the Reactive Pattern. *

* This class provides methods for subscribing to the Observable as well as delegate methods to the various * Observers. *

* The documentation for this class makes use of marble diagrams. The following legend explains these diagrams: *

* *

* For more information see the RxJava wiki * * @param * the type of the items emitted by the Observable */ public class Observable { final OnSubscribe onSubscribe; /** * Creates an Observable with a Function to execute when it is subscribed to. *

* Note: Use {@link #create(OnSubscribe)} to create an Observable, instead of this constructor, * unless you specifically have a need for inheritance. * * @param f * {@link OnSubscribe} to be executed when {@link #subscribe(Subscriber)} is called */ protected Observable(OnSubscribe f) { this.onSubscribe = f; } private static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook(); /** * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to * it. *

* *

* Write the function you pass to {@code create} so that it behaves as an Observable: It should invoke the * Subscriber's {@link Subscriber#onNext onNext}, {@link Subscriber#onError onError}, and * {@link Subscriber#onCompleted onCompleted} methods appropriately. *

* A well-formed Observable must invoke either the Subscriber's {@code onCompleted} method exactly once or * its {@code onError} method exactly once. *

* See Rx Design Guidelines (PDF) for detailed * information. *

*
Scheduler:
*
{@code create} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of the items that this Observable emits * @param f * a function that accepts an {@code Subscriber}, and invokes its {@code onNext}, * {@code onError}, and {@code onCompleted} methods as appropriate * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified * function * @see RxJava wiki: create * @see MSDN: Observable.Create */ public final static Observable create(OnSubscribe f) { return new Observable(hook.onCreate(f)); } /** * Invoked when Obserable.subscribe is called. */ public static interface OnSubscribe extends Action1> { // cover for generics insanity } /** * Operator function for lifting into an Observable. */ public interface Operator extends Func1, Subscriber> { // cover for generics insanity } /** * Lifts a function to the current Observable and returns a new Observable that when subscribed to will pass * the values of the current Observable through the Operator function. *

* In other words, this allows chaining Observers together on an Observable for acting on the values within * the Observable. *

{@code * observable.map(...).filter(...).take(5).lift(new OperatorA()).lift(new OperatorB(...)).subscribe() * } *

* If the operator you are creating is designed to act on the individual items emitted by a source * Observable, use {@code lift}. If your operator is designed to transform the source Observable as a whole * (for instance, by applying a particular set of existing RxJava operators to it) use {@link #compose}. *

*
Scheduler:
*
{@code lift} does not operate by default on a particular {@link Scheduler}.
*
* * @param lift the Operator that implements the Observable-operating function to be applied to the source * Observable * @return an Observable that is the result of applying the lifted Operator to the source Observable * @see RxJava wiki: Implementing Your Own Operators */ public final Observable lift(final Operator lift) { return new Observable(new OnSubscribe() { @Override public void call(Subscriber o) { try { Subscriber st = hook.onLift(lift).call(o); // new Subscriber created and being subscribed with so 'onStart' it st.onStart(); onSubscribe.call(st); } catch (Throwable e) { // localized capture of errors rather than it skipping all operators // and ending up in the try/catch of the subscribe method which then // prevents onErrorResumeNext and other similar approaches to error handling if (e instanceof OnErrorNotImplementedException) { throw (OnErrorNotImplementedException) e; } o.onError(e); } } }); } /** * Transform an Observable by applying a particular Transformer function to it. *

* This method operates on the Observable itself whereas {@link #lift} operates on the Observable's * Subscribers or Observers. *

* If the operator you are creating is designed to act on the individual items emitted by a source * Observable, use {@link #lift}. If your operator is designed to transform the source Observable as a whole * (for instance, by applying a particular set of existing RxJava operators to it) use {@code compose}. *

*
Scheduler:
*
{@code compose} does not operate by default on a particular {@link Scheduler}.
*
* * @param transformer implements the function that transforms the source Observable * @return the source Observable, transformed by the transformer function * @see RxJava wiki: Implementing Your Own Operators */ @SuppressWarnings("unchecked") public Observable compose(Transformer transformer) { // Casting to Observable is type-safe because we know Observable is covariant. return (Observable) transformer.call(this); } /** * Transformer function used by {@link #compose}. * @warn more complete description needed */ public static interface Transformer extends Func1, Observable> { // cover for generics insanity } /* ********************************************************************************************************* * Operators Below Here * ********************************************************************************************************* */ /** * Mirrors the one Observable in an Iterable of several Observables that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param sources * an Iterable of Observable sources competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Iterable> sources) { return create(OnSubscribeAmb.amb(sources)); } /** * Given two Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2) { return create(OnSubscribeAmb.amb(o1, o2)); } /** * Given three Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @param o3 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2, Observable o3) { return create(OnSubscribeAmb.amb(o1, o2, o3)); } /** * Given four Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @param o3 * an Observable competing to react first * @param o4 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4) { return create(OnSubscribeAmb.amb(o1, o2, o3, o4)); } /** * Given five Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @param o3 * an Observable competing to react first * @param o4 * an Observable competing to react first * @param o5 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) { return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5)); } /** * Given six Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @param o3 * an Observable competing to react first * @param o4 * an Observable competing to react first * @param o5 * an Observable competing to react first * @param o6 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) { return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6)); } /** * Given seven Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @param o3 * an Observable competing to react first * @param o4 * an Observable competing to react first * @param o5 * an Observable competing to react first * @param o6 * an Observable competing to react first * @param o7 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) { return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7)); } /** * Given eight Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @param o3 * an Observable competing to react first * @param o4 * an Observable competing to react first * @param o5 * an Observable competing to react first * @param o6 * an Observable competing to react first * @param o7 * an Observable competing to react first * @param o8 * an observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) { return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8)); } /** * Given nine Observables, mirrors the one that first emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * an Observable competing to react first * @param o2 * an Observable competing to react first * @param o3 * an Observable competing to react first * @param o4 * an Observable competing to react first * @param o5 * an Observable competing to react first * @param o6 * an Observable competing to react first * @param o7 * an Observable competing to react first * @param o8 * an Observable competing to react first * @param o9 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) { return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9)); } /** * Combines two source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from either of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) { return combineLatest(Arrays.asList(o1, o2), Functions.fromFunc(combineFunction)); } /** * Combines three source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param o3 * the third source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) { return combineLatest(Arrays.asList(o1, o2, o3), Functions.fromFunc(combineFunction)); } /** * Combines four source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param o3 * the third source Observable * @param o4 * the fourth source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Func4 combineFunction) { return combineLatest(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(combineFunction)); } /** * Combines five source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param o3 * the third source Observable * @param o4 * the fourth source Observable * @param o5 * the fifth source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Func5 combineFunction) { return combineLatest(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(combineFunction)); } /** * Combines six source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param o3 * the third source Observable * @param o4 * the fourth source Observable * @param o5 * the fifth source Observable * @param o6 * the sixth source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Func6 combineFunction) { return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(combineFunction)); } /** * Combines seven source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param o3 * the third source Observable * @param o4 * the fourth source Observable * @param o5 * the fifth source Observable * @param o6 * the sixth source Observable * @param o7 * the seventh source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Func7 combineFunction) { return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(combineFunction)); } /** * Combines eight source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param o3 * the third source Observable * @param o4 * the fourth source Observable * @param o5 * the fifth source Observable * @param o6 * the sixth source Observable * @param o7 * the seventh source Observable * @param o8 * the eighth source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Func8 combineFunction) { return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(combineFunction)); } /** * Combines nine source Observables by emitting an item that aggregates the latest values of each of the * source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *

* *

*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * the second source Observable * @param o3 * the third source Observable * @param o4 * the fourth source Observable * @param o5 * the fifth source Observable * @param o6 * the sixth source Observable * @param o7 * the seventh source Observable * @param o8 * the eighth source Observable * @param o9 * the ninth source Observable * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ @SuppressWarnings("unchecked") public static final Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9, Func9 combineFunction) { return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8, o9), Functions.fromFunc(combineFunction)); } /** * Combines a list of source Observables by emitting an item that aggregates the latest values of each of * the source Observables each time an item is received from any of the source Observables, where this * aggregation is defined by a specified function. *
*
Scheduler:
*
{@code combineLatest} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the common base type of source values * @param * the result type * @param sources * the list of source Observables * @param combineFunction * the aggregation function used to combine the items emitted by the source Observables * @return an Observable that emits items that are the result of combining the items emitted by the source * Observables by means of the given aggregation function * @see RxJava wiki: combineLatest * @see MSDN: Observable.CombineLatest */ public static final Observable combineLatest(List> sources, FuncN combineFunction) { return create(new OnSubscribeCombineLatest(sources, combineFunction)); } /** * Returns an Observable that emits the items emitted by each of the Observables emitted by the source * Observable, one after the other, without interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param observables * an Observable that emits Observables * @return an Observable that emits items all of the items emitted by the Observables emitted by * {@code observables}, one after the other, without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable> observables) { return observables.lift(new OperatorConcat()); } /** * Returns an Observable that emits the items emitted by two Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @return an Observable that emits items emitted by the two source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2) { return concat(just(t1, t2)); } /** * Returns an Observable that emits the items emitted by three Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @param t3 * an Observable to be concatenated * @return an Observable that emits items emitted by the three source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2, Observable t3) { return concat(just(t1, t2, t3)); } /** * Returns an Observable that emits the items emitted by four Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @param t3 * an Observable to be concatenated * @param t4 * an Observable to be concatenated * @return an Observable that emits items emitted by the four source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4) { return concat(just(t1, t2, t3, t4)); } /** * Returns an Observable that emits the items emitted by five Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @param t3 * an Observable to be concatenated * @param t4 * an Observable to be concatenated * @param t5 * an Observable to be concatenated * @return an Observable that emits items emitted by the five source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { return concat(just(t1, t2, t3, t4, t5)); } /** * Returns an Observable that emits the items emitted by six Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @param t3 * an Observable to be concatenated * @param t4 * an Observable to be concatenated * @param t5 * an Observable to be concatenated * @param t6 * an Observable to be concatenated * @return an Observable that emits items emitted by the six source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { return concat(just(t1, t2, t3, t4, t5, t6)); } /** * Returns an Observable that emits the items emitted by seven Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @param t3 * an Observable to be concatenated * @param t4 * an Observable to be concatenated * @param t5 * an Observable to be concatenated * @param t6 * an Observable to be concatenated * @param t7 * an Observable to be concatenated * @return an Observable that emits items emitted by the seven source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { return concat(just(t1, t2, t3, t4, t5, t6, t7)); } /** * Returns an Observable that emits the items emitted by eight Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @param t3 * an Observable to be concatenated * @param t4 * an Observable to be concatenated * @param t5 * an Observable to be concatenated * @param t6 * an Observable to be concatenated * @param t7 * an Observable to be concatenated * @param t8 * an Observable to be concatenated * @return an Observable that emits items emitted by the eight source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { return concat(just(t1, t2, t3, t4, t5, t6, t7, t8)); } /** * Returns an Observable that emits the items emitted by nine Observables, one after the other, without * interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated * @param t2 * an Observable to be concatenated * @param t3 * an Observable to be concatenated * @param t4 * an Observable to be concatenated * @param t5 * an Observable to be concatenated * @param t6 * an Observable to be concatenated * @param t7 * an Observable to be concatenated * @param t8 * an Observable to be concatenated * @param t9 * an Observable to be concatenated * @return an Observable that emits items emitted by the nine source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final static Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) { return concat(just(t1, t2, t3, t4, t5, t6, t7, t8, t9)); } /** * Returns an Observable that calls an Observable factory to create an Observable for each new Observer * that subscribes. That is, for each subscriber, the actual Observable that subscriber observes is * determined by the factory function. *

* *

* The defer Observer allows you to defer or delay emitting items from an Observable until such time as an * Observer subscribes to the Observable. This allows an {@link Observer} to easily obtain updates or a * refreshed version of the sequence. *

*
Scheduler:
*
{@code defer} does not operate by default on a particular {@link Scheduler}.
*
* * @param observableFactory * the Observable factory function to invoke for each {@link Observer} that subscribes to the * resulting Observable * @param * the type of the items emitted by the Observable * @return an Observable whose {@link Observer}s' subscriptions trigger an invocation of the given * Observable factory function * @see RxJava wiki: defer * @see MSDN: Observable.Defer */ public final static Observable defer(Func0> observableFactory) { return create(new OnSubscribeDefer(observableFactory)); } /** * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its * {@link Observer#onCompleted onCompleted} method. *

* *

*
Scheduler:
*
{@code empty} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of the items (ostensibly) emitted by the Observable * @return an Observable that emits no items to the {@link Observer} but immediately invokes the * {@link Observer}'s {@link Observer#onCompleted() onCompleted} method * @see RxJava wiki: empty * @see MSDN: Observable.Empty */ public final static Observable empty() { return from(Collections.emptyList()); } /** * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the * Observer subscribes to it. *

* *

*
Scheduler:
*
{@code error} does not operate by default on a particular {@link Scheduler}.
*
* * @param exception * the particular Throwable to pass to {@link Observer#onError onError} * @param * the type of the items (ostensibly) emitted by the Observable * @return an Observable that invokes the {@link Observer}'s {@link Observer#onError onError} method when * the Observer subscribes to it * @see RxJava wiki: error * @see MSDN: Observable.Throw */ public final static Observable error(Throwable exception) { return new ThrowObservable(exception); } /** * Converts a {@link Future} into an Observable. *

* *

* You can convert any object that supports the {@link Future} interface into an Observable that emits the * return value of the {@link Future#get} method of that object, by passing the object into the {@code from} * method. *

* Important note: This Observable is blocking; you cannot unsubscribe from it. *

*
Scheduler:
*
{@code from} does not operate by default on a particular {@link Scheduler}.
*
* * @param future * the source {@link Future} * @param * the type of object that the {@link Future} returns, and also the type of item to be emitted by * the resulting Observable * @return an Observable that emits the item from the source {@link Future} * @see RxJava wiki: from */ public final static Observable from(Future future) { return create(OnSubscribeToObservableFuture.toObservableFuture(future)); } /** * Converts a {@link Future} into an Observable, with a timeout on the Future. *

* *

* You can convert any object that supports the {@link Future} interface into an Observable that emits the * return value of the {@link Future#get} method of that object, by passing the object into the {@code from} * method. *

* Important note: This Observable is blocking; you cannot unsubscribe from it. *

*
Scheduler:
*
{@code from} does not operate by default on a particular {@link Scheduler}.
*
* * @param future * the source {@link Future} * @param timeout * the maximum time to wait before calling {@code get} * @param unit * the {@link TimeUnit} of the {@code timeout} argument * @param * the type of object that the {@link Future} returns, and also the type of item to be emitted by * the resulting Observable * @return an Observable that emits the item from the source {@link Future} * @see RxJava wiki: from */ public final static Observable from(Future future, long timeout, TimeUnit unit) { return create(OnSubscribeToObservableFuture.toObservableFuture(future, timeout, unit)); } /** * Converts a {@link Future}, operating on a specified {@link Scheduler}, into an Observable. *

* *

* You can convert any object that supports the {@link Future} interface into an Observable that emits the * return value of the {@link Future#get} method of that object, by passing the object into the {@code from} * method. *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param future * the source {@link Future} * @param scheduler * the {@link Scheduler} to wait for the Future on. Use a Scheduler such as * {@link Schedulers#io()} that can block and wait on the Future * @param * the type of object that the {@link Future} returns, and also the type of item to be emitted by * the resulting Observable * @return an Observable that emits the item from the source {@link Future} * @see RxJava wiki: from */ public final static Observable from(Future future, Scheduler scheduler) { // TODO in a future revision the Scheduler will become important because we'll start polling instead of blocking on the Future return create(OnSubscribeToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler); } /** * Converts an {@link Iterable} sequence into an Observable that emits the items in the sequence. *

* *

*
Scheduler:
*
{@code from} does not operate by default on a particular {@link Scheduler}.
*
* * @param iterable * the source {@link Iterable} sequence * @param * the type of items in the {@link Iterable} sequence and the type of items to be emitted by the * resulting Observable * @return an Observable that emits each item in the source {@link Iterable} sequence * @see RxJava wiki: from * @see MSDN: Observable.ToObservable */ public final static Observable from(Iterable iterable) { return create(new OnSubscribeFromIterable(iterable)); } /** * Converts an Array into an Observable that emits the items in the Array. *

* *

*
Scheduler:
*
{@code from} does not operate by default on a particular {@link Scheduler}.
*
* * @param array * the source Array * @param * the type of items in the Array and the type of items to be emitted by the resulting Observable * @return an Observable that emits each item in the source Array * @see RxJava wiki: from * @see MSDN: Observable.ToObservable */ public final static Observable from(T[] array) { return from(Arrays.asList(array)); } /** * Returns an Observable that emits a sequential number every specified interval of time. *

* *

*
Scheduler:
*
{@code interval} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param interval * interval size in time units (see below) * @param unit * time units to use for the interval size * @return an Observable that emits a sequential number each time interval * @see RxJava wiki: interval * @see MSDN: Observable.Interval */ public final static Observable interval(long interval, TimeUnit unit) { return interval(interval, unit, Schedulers.computation()); } /** * Returns an Observable that emits a sequential number every specified interval of time, on a * specified Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param interval * interval size in time units (see below) * @param unit * time units to use for the interval size * @param scheduler * the Scheduler to use for scheduling the items * @return an Observable that emits a sequential number each time interval * @see RxJava wiki: interval * @see MSDN: Observable.Interval */ public final static Observable interval(long interval, TimeUnit unit, Scheduler scheduler) { return create(new OnSubscribeTimerPeriodically(interval, interval, unit, scheduler)); } /** * Returns an Observable that emits a single item and then completes. *

* *

* To convert any object into an Observable that emits that object, pass that object into the {@code just} * method. *

* This is similar to the {@link #from(java.lang.Object[])} method, except that {@code from} will convert * an {@link Iterable} object into an Observable that emits each of the items in the Iterable, one at a * time, while the {@code just} method converts an Iterable into an Observable that emits the entire * Iterable as a single item. *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param value * the item to emit * @param * the type of that item * @return an Observable that emits {@code value} as a single item and then completes * @see RxJava wiki: just */ public final static Observable just(final T value) { return ScalarSynchronousObservable.create(value); } /** * Converts two items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2) { return from(Arrays.asList(t1, t2)); } /** * Converts three items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3) { return from(Arrays.asList(t1, t2, t3)); } /** * Converts four items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param t4 * fourth item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3, T t4) { return from(Arrays.asList(t1, t2, t3, t4)); } /** * Converts five items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param t4 * fourth item * @param t5 * fifth item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3, T t4, T t5) { return from(Arrays.asList(t1, t2, t3, t4, t5)); } /** * Converts six items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param t4 * fourth item * @param t5 * fifth item * @param t6 * sixth item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3, T t4, T t5, T t6) { return from(Arrays.asList(t1, t2, t3, t4, t5, t6)); } /** * Converts seven items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param t4 * fourth item * @param t5 * fifth item * @param t6 * sixth item * @param t7 * seventh item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3, T t4, T t5, T t6, T t7) { return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7)); } /** * Converts eight items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param t4 * fourth item * @param t5 * fifth item * @param t6 * sixth item * @param t7 * seventh item * @param t8 * eighth item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) { return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8)); } /** * Converts nine items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param t4 * fourth item * @param t5 * fifth item * @param t6 * sixth item * @param t7 * seventh item * @param t8 * eighth item * @param t9 * ninth item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) { return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9)); } /** * Converts ten items into an Observable that emits those items. *

* *

*
Scheduler:
*
{@code just} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * first item * @param t2 * second item * @param t3 * third item * @param t4 * fourth item * @param t5 * fifth item * @param t6 * sixth item * @param t7 * seventh item * @param t8 * eighth item * @param t9 * ninth item * @param t10 * tenth item * @param * the type of these items * @return an Observable that emits each item * @see RxJava wiki: just */ // suppress unchecked because we are using varargs inside the method @SuppressWarnings("unchecked") public final static Observable just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9, T t10) { return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)); } /** * Flattens an Iterable of Observables into one Observable, without any transformation. *

* *

* You can combine the items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param sequences * the Iterable of Observables * @return an Observable that emits items that are the result of flattening the items emitted by the * Observables in the Iterable * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ public final static Observable merge(Iterable> sequences) { return merge(from(sequences)); } /** * Flattens an Iterable of Observables into one Observable, without any transformation, while limiting the * number of concurrent subscriptions to these Observables. *

* *

* You can combine the items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param sequences * the Iterable of Observables * @param maxConcurrent * the maximum number of Observables that may be subscribed to concurrently * @return an Observable that emits items that are the result of flattening the items emitted by the * Observables in the Iterable * @throws IllegalArgumentException * if {@code maxConcurrent} is less than or equal to 0 * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ public final static Observable merge(Iterable> sequences, int maxConcurrent) { return merge(from(sequences), maxConcurrent); } /** * Flattens an Observable that emits Observables into a single Observable that emits the items emitted by * those Observables, without any transformation. *

* *

* You can combine the items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param source * an Observable that emits Observables * @return an Observable that emits items that are the result of flattening the Observables emitted by the * {@code source} Observable * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ public final static Observable merge(Observable> source) { return source.lift(new OperatorMerge()); } /** * Flattens an Observable that emits Observables into a single Observable that emits the items emitted by * those Observables, without any transformation, while limiting the maximum number of concurrent * subscriptions to these Observables. *

* *

* You can combine the items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param source * an Observable that emits Observables * @param maxConcurrent * the maximum number of Observables that may be subscribed to concurrently * @return an Observable that emits items that are the result of flattening the Observables emitted by the * {@code source} Observable * @throws IllegalArgumentException * if {@code maxConcurrent} is less than or equal to 0 * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ public final static Observable merge(Observable> source, int maxConcurrent) { return source.lift(new OperatorMergeMaxConcurrent(maxConcurrent)); } /** * Flattens two Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2) { return merge(from(Arrays.asList(t1, t2))); } /** * Flattens three Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2, Observable t3) { return merge(from(Arrays.asList(t1, t2, t3))); } /** * Flattens four Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4) { return merge(from(Arrays.asList(t1, t2, t3, t4))); } /** * Flattens five Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { return merge(from(Arrays.asList(t1, t2, t3, t4, t5))); } /** * Flattens six Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6))); } /** * Flattens seven Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @param t7 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7))); } /** * Flattens eight Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @param t7 * an Observable to be merged * @param t8 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8))); } /** * Flattens nine Observables into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @param t7 * an Observable to be merged * @param t8 * an Observable to be merged * @param t9 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ @SuppressWarnings("unchecked") public final static Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) { return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9))); } /** * Flattens an Array of Observables into one Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
* * @param sequences * the Array of Observables * @return an Observable that emits all of the items emitted by the Observables in the Array * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ public final static Observable merge(Observable[] sequences) { return merge(from(sequences)); } /** * Flattens an Observable that emits Observables into one Observable, in a way that allows an Observer to * receive all successfully emitted items from all of the source Observables without being interrupted by * an error notification from one of them. *

* This behaves like {@link #merge(Observable)} except that if any of the merged Observables notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that * error notification until all of the merged Observables have finished emitting items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param source * an Observable that emits Observables * @return an Observable that emits all of the items emitted by the Observables emitted by the * {@code source} Observable * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable> source) { return source.lift(new OperatorMergeDelayError()); } /** * Flattens two Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from each of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(Observable, Observable)} except that if any of the merged Observables * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from * propagating that error notification until all of the merged Observables have finished emitting items. *

* *

* Even if both merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the two source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable t1, Observable t2) { return mergeDelayError(just(t1, t2)); } /** * Flattens three Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from all of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(Observable, Observable, Observable)} except that if any of the merged * Observables notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain * from propagating that error notification until all of the merged Observables have finished emitting * items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable t1, Observable t2, Observable t3) { return mergeDelayError(just(t1, t2, t3)); } /** * Flattens four Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from all of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(Observable, Observable, Observable, Observable)} except that if any of * the merged Observables notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} * will refrain from propagating that error notification until all of the merged Observables have finished * emitting items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4) { return mergeDelayError(just(t1, t2, t3, t4)); } /** * Flattens five Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from all of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable)} except that * if any of the merged Observables notify of an error via {@link Observer#onError onError}, * {@code mergeDelayError} will refrain from propagating that error notification until all of the merged * Observables have finished emitting items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { return mergeDelayError(just(t1, t2, t3, t4, t5)); } /** * Flattens six Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from all of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable)} * except that if any of the merged Observables notify of an error via {@link Observer#onError onError}, * {@code mergeDelayError} will refrain from propagating that error notification until all of the merged * Observables have finished emitting items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { return mergeDelayError(just(t1, t2, t3, t4, t5, t6)); } /** * Flattens seven Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from all of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like * {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable)} * except that if any of the merged Observables notify of an error via {@link Observer#onError onError}, * {@code mergeDelayError} will refrain from propagating that error notification until all of the merged * Observables have finished emitting items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @param t7 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { return mergeDelayError(just(t1, t2, t3, t4, t5, t6, t7)); } /** * Flattens eight Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from all of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable)} * except that if any of the merged Observables notify of an error via {@link Observer#onError onError}, * {@code mergeDelayError} will refrain from propagating that error notification until all of the merged * Observables have finished emitting items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @param t7 * an Observable to be merged * @param t8 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ // suppress because the types are checked by the method signature before using a vararg public final static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { return mergeDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8)); } /** * Flattens nine Observables into one Observable, in a way that allows an Observer to receive all * successfully emitted items from all of the source Observables without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable)} * except that if any of the merged Observables notify of an error via {@link Observer#onError onError}, * {@code mergeDelayError} will refrain from propagating that error notification until all of the merged * Observables have finished emitting items. *

* *

* Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only * invoke the {@code onError} method of its Observers once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @param t2 * an Observable to be merged * @param t3 * an Observable to be merged * @param t4 * an Observable to be merged * @param t5 * an Observable to be merged * @param t6 * an Observable to be merged * @param t7 * an Observable to be merged * @param t8 * an Observable to be merged * @param t9 * an Observable to be merged * @return an Observable that emits all of the items that are emitted by the source Observables * @see RxJava wiki: mergeDelayError * @see MSDN: Observable.Merge */ public final static Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) { return mergeDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8, t9)); } /** * Converts the source {@code Observable} into an {@code Observable>} that emits the * source Observable as its single emission. *

* *

*
Scheduler:
*
{@code nest} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits a single item: the source Observable */ public final Observable> nest() { return just(this); } /** * Returns an Observable that never sends any items or notifications to an {@link Observer}. *

* *

* This Observable is useful primarily for testing purposes. *

*
Scheduler:
*
{@code never} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items (not) emitted by the Observable * @return an Observable that never emits any items or sends any notifications to an {@link Observer} * @see RxJava wiki: never */ public final static Observable never() { return new NeverObservable(); } /** * Returns an Observable that emits a sequence of Integers within a specified range. *

* *

*
Scheduler:
*
{@code range} does not operate by default on a particular {@link Scheduler}.
*
* * @param start * the value of the first Integer in the sequence * @param count * the number of sequential Integers to generate * @return an Observable that emits a range of sequential Integers * @throws IllegalArgumentException * if {@code count} is less than zero, or if {@code start} + {@code count} − 1 exceeds * {@code Integer.MAX_VALUE} * @see RxJava wiki: range * @see MSDN: Observable.Range */ public final static Observable range(int start, int count) { if (count < 0) { throw new IllegalArgumentException("Count can not be negative"); } if (count == 0) { return Observable.empty(); } if (start > Integer.MAX_VALUE - count + 1) { throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE"); } if(count == 1) { return Observable.just(start); } return Observable.create(new OnSubscribeRange(start, start + (count - 1))); } /** * Returns an Observable that emits a sequence of Integers within a specified range, on a specified * Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param start * the value of the first Integer in the sequence * @param count * the number of sequential Integers to generate * @param scheduler * the Scheduler to run the generator loop on * @return an Observable that emits a range of sequential Integers * @see RxJava wiki: range * @see MSDN: Observable.Range */ public final static Observable range(int start, int count, Scheduler scheduler) { return range(start, count).subscribeOn(scheduler); } /** * Returns an Observable that emits a Boolean value that indicates whether two Observable sequences are the * same by comparing the items emitted by each Observable pairwise. *

* *

*
Scheduler:
*
{@code sequenceEqual} does not operate by default on a particular {@link Scheduler}.
*
* * @param first * the first Observable to compare * @param second * the second Observable to compare * @param * the type of items emitted by each Observable * @return an Observable that emits a Boolean value that indicates whether the two sequences are the same * @see RxJava wiki: sequenceEqual * @see MSDN: Observable.SequenceEqual */ public final static Observable sequenceEqual(Observable first, Observable second) { return sequenceEqual(first, second, new Func2() { @Override public final Boolean call(T first, T second) { if (first == null) { return second == null; } return first.equals(second); } }); } /** * Returns an Observable that emits a Boolean value that indicates whether two Observable sequences are the * same by comparing the items emitted by each Observable pairwise based on the results of a specified * equality function. *

* *

*
Scheduler:
*
{@code sequenceEqual} does not operate by default on a particular {@link Scheduler}.
*
* * @param first * the first Observable to compare * @param second * the second Observable to compare * @param equality * a function used to compare items emitted by each Observable * @param * the type of items emitted by each Observable * @return an Observable that emits a Boolean value that indicates whether the two Observable two sequences * are the same according to the specified function * @see RxJava wiki: sequenceEqual * @see MSDN: Observable.SequenceEqual */ public final static Observable sequenceEqual(Observable first, Observable second, Func2 equality) { return OperatorSequenceEqual.sequenceEqual(first, second, equality); } /** * Converts an Observable that emits Observables into an Observable that emits the items emitted by the * most recently emitted of those Observables. *

* *

* {@code switchOnNext} subscribes to an Observable that emits Observables. Each time it observes one of * these emitted Observables, the Observable returned by {@code switchOnNext} begins emitting the items * emitted by that Observable. When a new Observable is emitted, {@code switchOnNext} stops emitting items * from the earlier-emitted Observable and begins emitting items from the new one. *

*
Scheduler:
*
{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.
*
* * @param the item type * @param sequenceOfSequences * the source Observable that emits Observables * @return an Observable that emits the items emitted by the Observable most recently emitted by the source * Observable * @see RxJava wiki: switchOnNext * @see MSDN: Observable.Switch */ public final static Observable switchOnNext(Observable> sequenceOfSequences) { return sequenceOfSequences.lift(new OperatorSwitch()); } /** * Returns an Observable that emits a {@code 0L} after the {@code initialDelay} and ever increasing numbers * after each {@code period} of time thereafter. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. If the downstream needs a slower rate * it should slow the timer or use something like {@link #onBackpressureDrop}.
*
Scheduler:
*
{@code timer} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param initialDelay * the initial delay time to wait before emitting the first value of 0L * @param period * the period of time between emissions of the subsequent numbers * @param unit * the time unit for both {@code initialDelay} and {@code period} * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after * each {@code period} of time thereafter * @see RxJava wiki: timer * @see MSDN: Observable.Timer */ public final static Observable timer(long initialDelay, long period, TimeUnit unit) { return timer(initialDelay, period, unit, Schedulers.computation()); } /** * Returns an Observable that emits a {@code 0L} after the {@code initialDelay} and ever increasing numbers * after each {@code period} of time thereafter, on a specified {@link Scheduler}. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. If the downstream needs a slower rate * it should slow the timer or use something like {@link #onBackpressureDrop}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param initialDelay * the initial delay time to wait before emitting the first value of 0L * @param period * the period of time between emissions of the subsequent numbers * @param unit * the time unit for both {@code initialDelay} and {@code period} * @param scheduler * the Scheduler on which the waiting happens and items are emitted * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after * each {@code period} of time thereafter, while running on the given Scheduler * @see RxJava wiki: timer * @see MSDN: Observable.Timer */ public final static Observable timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { return create(new OnSubscribeTimerPeriodically(initialDelay, period, unit, scheduler)); } /** * Returns an Observable that emits one item after a specified delay, and then completes. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. If the downstream needs a slower rate * it should slow the timer or use something like {@link #onBackpressureDrop}.
*
Scheduler:
*
{@code timer} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param delay * the initial delay before emitting a single {@code 0L} * @param unit * time units to use for {@code delay} * @return an Observable that emits one item after a specified delay, and then completes * @see RxJava wiki: timer * @see MSDN: Observable.Timer */ public final static Observable timer(long delay, TimeUnit unit) { return timer(delay, unit, Schedulers.computation()); } /** * Returns an Observable that emits one item after a specified delay, on a specified Scheduler, and then * completes. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. If the downstream needs a slower rate * it should slow the timer or use something like {@link #onBackpressureDrop}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param delay * the initial delay before emitting a single 0L * @param unit * time units to use for {@code delay} * @param scheduler * the {@link Scheduler} to use for scheduling the item * @return an Observable that emits one item after a specified delay, on a specified Scheduler, and then * completes * @see RxJava wiki: timer * @see MSDN: Observable.Timer */ public final static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) { return create(new OnSubscribeTimerOnce(delay, unit, scheduler)); } /** * Constructs an Observable that creates a dependent resource object. *

* *

*
Scheduler:
*
{@code using} does not operate by default on a particular {@link Scheduler}.
*
* * @param resourceFactory * the factory function to create a resource object that depends on the Observable * @param observableFactory * the factory function to create an Observable * @param disposeAction * the function that will dispose of the resource * @return the Observable whose lifetime controls the lifetime of the dependent resource object * @see RxJava wiki: using * @see MSDN: Observable.Using */ public final static Observable using( final Func0 resourceFactory, final Func1> observableFactory, final Action1 disposeAction) { return create(new OnSubscribeUsing(resourceFactory, observableFactory, disposeAction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * items emitted, in sequence, by an Iterable of other Observables. *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by each of the source Observables; * the second item emitted by the new Observable will be the result of the function applied to the second * item emitted by each of those Observables; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as * the number of {@code onNext} invokations of the source Observable that emits the fewest items. *

* *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param ws * an Iterable of source Observables * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Iterable> ws, FuncN zipFunction) { List> os = new ArrayList>(); for (Observable o : ws) { os.add(o); } return Observable.just(os.toArray(new Observable[os.size()])).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * n items emitted, in sequence, by the n Observables emitted by a specified Observable. *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by each of the Observables emitted * by the source Observable; the second item emitted by the new Observable will be the result of the * function applied to the second item emitted by each of those Observables; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as * the number of {@code onNext} invokations of the source Observable that emits the fewest items. *

* *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param ws * an Observable of source Observables * @param zipFunction * a function that, when applied to an item emitted by each of the Observables emitted by * {@code ws}, results in an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable> ws, final FuncN zipFunction) { return ws.toList().map(new Func1>, Observable[]>() { @Override public Observable[] call(List> o) { return o.toArray(new Observable[o.size()]); } }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * two items emitted, in sequence, by two other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by {@code o1} and the first item * emitted by {@code o2}; the second item emitted by the new Observable will be the result of the function * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results * in an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, final Func2 zipFunction) { return just(new Observable[] { o1, o2 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * three items emitted, in sequence, by three other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, and the first item emitted by {@code o3}; the second item emitted by the new * Observable will be the result of the function applied to the second item emitted by {@code o1}, the * second item emitted by {@code o2}, and the second item emitted by {@code o3}; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param o3 * a third source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, Observable o3, Func3 zipFunction) { return just(new Observable[] { o1, o2, o3 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * four items emitted, in sequence, by four other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, the first item emitted by {@code o3}, and the first item emitted by {@code 04}; * the second item emitted by the new Observable will be the result of the function applied to the second * item emitted by each of those Observables; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param o3 * a third source Observable * @param o4 * a fourth source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Func4 zipFunction) { return just(new Observable[] { o1, o2, o3, o4 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * five items emitted, in sequence, by five other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, the first item emitted by {@code o3}, the first item emitted by {@code o4}, and * the first item emitted by {@code o5}; the second item emitted by the new Observable will be the result of * the function applied to the second item emitted by each of those Observables; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param o3 * a third source Observable * @param o4 * a fourth source Observable * @param o5 * a fifth source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Func5 zipFunction) { return just(new Observable[] { o1, o2, o3, o4, o5 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * six items emitted, in sequence, by six other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by each source Observable, the * second item emitted by the new Observable will be the result of the function applied to the second item * emitted by each of those Observables, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param o3 * a third source Observable * @param o4 * a fourth source Observable * @param o5 * a fifth source Observable * @param o6 * a sixth source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Func6 zipFunction) { return just(new Observable[] { o1, o2, o3, o4, o5, o6 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * seven items emitted, in sequence, by seven other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by each source Observable, the * second item emitted by the new Observable will be the result of the function applied to the second item * emitted by each of those Observables, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param o3 * a third source Observable * @param o4 * a fourth source Observable * @param o5 * a fifth source Observable * @param o6 * a sixth source Observable * @param o7 * a seventh source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Func7 zipFunction) { return just(new Observable[] { o1, o2, o3, o4, o5, o6, o7 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * eight items emitted, in sequence, by eight other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by each source Observable, the * second item emitted by the new Observable will be the result of the function applied to the second item * emitted by each of those Observables, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param o3 * a third source Observable * @param o4 * a fourth source Observable * @param o5 * a fifth source Observable * @param o6 * a sixth source Observable * @param o7 * a seventh source Observable * @param o8 * an eighth source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Func8 zipFunction) { return just(new Observable[] { o1, o2, o3, o4, o5, o6, o7, o8 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits the results of a function of your choosing applied to combinations of * nine items emitted, in sequence, by nine other Observables. *

* *

* {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable * will be the result of the function applied to the first item emitted by each source Observable, the * second item emitted by the new Observable will be the result of the function applied to the second item * emitted by each of those Observables, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest * items. *

*
Scheduler:
*
{@code zip} does not operate by default on a particular {@link Scheduler}.
*
* * @param o1 * the first source Observable * @param o2 * a second source Observable * @param o3 * a third source Observable * @param o4 * a fourth source Observable * @param o5 * a fifth source Observable * @param o6 * a sixth source Observable * @param o7 * a seventh source Observable * @param o8 * an eighth source Observable * @param o9 * a ninth source Observable * @param zipFunction * a function that, when applied to an item emitted by each of the source Observables, results in * an item that will be emitted by the resulting Observable * @return an Observable that emits the zipped results * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final static Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9, Func9 zipFunction) { return just(new Observable[] { o1, o2, o3, o4, o5, o6, o7, o8, o9 }).lift(new OperatorZip(zipFunction)); } /** * Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source * Observable satisfy a condition. *

* *

*
Scheduler:
*
{@code all} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * a function that evaluates an item and returns a Boolean * @return an Observable that emits {@code true} if all items emitted by the source Observable satisfy the * predicate; otherwise, {@code false} * @see RxJava wiki: all * @see MSDN: Observable.All */ public final Observable all(Func1 predicate) { return lift(new OperatorAll(predicate)); } /** * Mirrors the first Observable (current or provided) that emits an item. *

* *

*
Scheduler:
*
{@code amb} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable competing to react first * @return an Observable that emits the same sequence of items as whichever of the source Observables first * emitted an item * @see RxJava wiki: amb * @see MSDN: Observable.Amb */ public final Observable ambWith(Observable t1) { return amb(this, t1); } /** * Disguises a object of an Observable subclass as a simple Observable object. Useful for instance when you * have an implementation of a subclass of Observable but you want to hide the properties and methods of * this subclass from whomever you are passing the Observable to. *
*
Scheduler:
*
{@code asObservable} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that hides the identity of this Observable */ public final Observable asObservable() { return lift(new OperatorAsObservable()); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a * new buffer whenever the Observable produced by the specified {@code bufferClosingSelector} emits an item. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it is instead controlled by the given Observables and * buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey downstream requests.
*
Scheduler:
*
This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.
*
* * @param bufferClosingSelector * a {@link Func0} that produces an Observable that governs the boundary between buffers. * Whenever this {@code Observable} emits an item, {@code buffer} emits the current buffer and * begins to fill a new one * @return an Observable that emits a connected, non-overlapping buffer of items from the source Observable * each time the Observable created with the {@code bufferClosingSelector} argument emits an item * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(Func0> bufferClosingSelector) { return lift(new OperatorBufferWithSingleObservable(bufferClosingSelector, 16)); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping buffers, each containing {@code count} items. When the source * Observable completes or encounters an error, the resulting Observable emits the current buffer and * propagates the notification from the source Observable. *

* *

*
Scheduler:
*
This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.
*
* * @param count * the maximum number of items in each buffer before it should be emitted * @return an Observable that emits connected, non-overlapping buffers, each containing at most * {@code count} items from the source Observable * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(int count) { return buffer(count, count); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits buffers every {@code skip} items, each containing {@code count} items. When the source * Observable completes or encounters an error, the resulting Observable emits the current buffer and * propagates the notification from the source Observable. *

* *

*
Scheduler:
*
This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.
*
* * @param count * the maximum size of each buffer before it should be emitted * @param skip * how many items emitted by the source Observable should be skipped before starting a new * buffer. Note that when {@code skip} and {@code count} are equal, this is the same operation as * {@link #buffer(int)}. * @return an Observable that emits buffers for every {@code skip} item from the source Observable and * containing at most {@code count} items * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(int count, int skip) { return lift(new OperatorBufferWithSize(count, skip)); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable starts a new buffer periodically, as determined by the {@code timeshift} argument. It emits * each buffer after a fixed timespan, specified by the {@code timespan} argument. When the source * Observable completes or encounters an error, the resulting Observable emits the current buffer and * propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE} * upstream and does not obey downstream requests.
*
Scheduler:
*
This version of {@code buffer} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timespan * the period of time each buffer collects items before it is emitted * @param timeshift * the period of time after which a new buffer will be created * @param unit * the unit of time that applies to the {@code timespan} and {@code timeshift} arguments * @return an Observable that emits new buffers of items emitted by the source Observable periodically after * a fixed timespan has elapsed * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(long timespan, long timeshift, TimeUnit unit) { return buffer(timespan, timeshift, unit, Schedulers.computation()); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable starts a new buffer periodically, as determined by the {@code timeshift} argument, and on the * specified {@code scheduler}. It emits each buffer after a fixed timespan, specified by the * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting * Observable emits the current buffer and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE} * upstream and does not obey downstream requests.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timespan * the period of time each buffer collects items before it is emitted * @param timeshift * the period of time after which a new buffer will be created * @param unit * the unit of time that applies to the {@code timespan} and {@code timeshift} arguments * @param scheduler * the {@link Scheduler} to use when determining the end and start of a buffer * @return an Observable that emits new buffers of items emitted by the source Observable periodically after * a fixed timespan has elapsed * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorBufferWithTime(timespan, timeshift, unit, Integer.MAX_VALUE, scheduler)); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting * Observable emits the current buffer and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE} * upstream and does not obey downstream requests.
*
Scheduler:
*
This version of {@code buffer} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timespan * the period of time each buffer collects items before it is emitted and replaced with a new * buffer * @param unit * the unit of time that applies to the {@code timespan} argument * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source * Observable within a fixed duration * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(long timespan, TimeUnit unit) { return buffer(timespan, unit, Integer.MAX_VALUE, Schedulers.computation()); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached * first). When the source Observable completes or encounters an error, the resulting Observable emits the * current buffer and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE} * upstream and does not obey downstream requests.
*
Scheduler:
*
This version of {@code buffer} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timespan * the period of time each buffer collects items before it is emitted and replaced with a new * buffer * @param unit * the unit of time which applies to the {@code timespan} argument * @param count * the maximum size of each buffer before it is emitted * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source * Observable, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs * first) * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(long timespan, TimeUnit unit, int count) { return lift(new OperatorBufferWithTime(timespan, timespan, unit, count, Schedulers.computation())); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the * {@code timespan} argument as measured on the specified {@code scheduler}, or a maximum size specified by * the {@code count} argument (whichever is reached first). When the source Observable completes or * encounters an error, the resulting Observable emits the current buffer and propagates the notification * from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE} * upstream and does not obey downstream requests.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timespan * the period of time each buffer collects items before it is emitted and replaced with a new * buffer * @param unit * the unit of time which applies to the {@code timespan} argument * @param count * the maximum size of each buffer before it is emitted * @param scheduler * the {@link Scheduler} to use when determining the end and start of a buffer * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source * Observable after a fixed duration or when the buffer reaches maximum capacity (whichever occurs * first) * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) { return lift(new OperatorBufferWithTime(timespan, timespan, unit, count, scheduler)); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the * {@code timespan} argument and on the specified {@code scheduler}. When the source Observable completes or * encounters an error, the resulting Observable emits the current buffer and propagates the notification * from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE} * upstream and does not obey downstream requests.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timespan * the period of time each buffer collects items before it is emitted and replaced with a new * buffer * @param unit * the unit of time which applies to the {@code timespan} argument * @param scheduler * the {@link Scheduler} to use when determining the end and start of a buffer * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source * Observable within a fixed duration * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) { return buffer(timespan, timespan, unit, scheduler); } /** * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting * Observable emits buffers that it creates when the specified {@code bufferOpenings} Observable emits an * item, and closes when the Observable returned from {@code bufferClosingSelector} emits an item. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it is instead controlled by the given Observables and * buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey downstream requests.
*
Scheduler:
*
This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.
*
* * @param bufferOpenings * the Observable that, when it emits an item, causes a new buffer to be created * @param bufferClosingSelector * the {@link Func1} that is used to produce an Observable for every buffer created. When this * Observable emits an item, the associated buffer is emitted. * @return an Observable that emits buffers, containing items from the source Observable, that are created * and closed when the specified Observables emit items * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) { return lift(new OperatorBufferWithStartEndObservable(bufferOpenings, bufferClosingSelector)); } /** * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the * specified boundary Observable emits an item. *

* *

* Completion of either the source or the boundary Observable causes the returned Observable to emit the * latest buffer and complete. *

*
Backpressure Support:
*
This operator does not support backpressure as it is instead controlled by the {@code Observable} * {@code boundary} and buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey * downstream requests.
*
Scheduler:
*
This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the boundary value type (ignored) * @param boundary * the boundary Observable * @return an Observable that emits buffered items from the source Observable when the boundary Observable * emits an item * @see #buffer(rx.Observable, int) * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer */ public final Observable> buffer(Observable boundary) { return buffer(boundary, 16); } /** * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the * specified boundary Observable emits an item. *

* *

* Completion of either the source or the boundary Observable causes the returned Observable to emit the * latest buffer and complete. *

*
Backpressure Support:
*
This operator does not support backpressure as it is instead controlled by the {@code Observable} * {@code boundary} and buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey * downstream requests.
*
Scheduler:
*
This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the boundary value type (ignored) * @param boundary * the boundary Observable * @param initialCapacity * the initial capacity of each buffer chunk * @return an Observable that emits buffered items from the source Observable when the boundary Observable * emits an item * @see RxJava wiki: buffer * @see MSDN: Observable.Buffer * @see #buffer(rx.Observable, int) */ public final Observable> buffer(Observable boundary, int initialCapacity) { return lift(new OperatorBufferWithSingleObservable(boundary, initialCapacity)); } /** * Caches the emissions from the source Observable and replays them in order to any subsequent Subscribers. * This method has similar behavior to {@link #replay} except that this auto-subscribes to the source * Observable rather than returning a {@link ConnectableObservable} for which you must call * {@code connect} to activate the subscription. *

* *

* This is useful when you want an Observable to cache responses and you can't control the * subscribe/unsubscribe behavior of all the {@link Subscriber}s. *

* When you call {@code cache}, it does not yet subscribe to the source Observable and so does not yet * begin cacheing items. This only happens when the first Subscriber calls the resulting Observable's * {@code subscribe} method. *

* Note: You sacrifice the ability to unsubscribe from the origin when you use the {@code cache} * Observer so be careful not to use this Observer on Observables that emit an infinite or very large number * of items that will use up memory. *

*
Backpressure Support:
*
This operator does not support upstream backpressure as it is purposefully requesting and caching * everything emitted.
*
Scheduler:
*
{@code cache} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that, when first subscribed to, caches all of its items and notifications for the * benefit of subsequent subscribers * @see RxJava wiki: cache */ public final Observable cache() { return create(new OnSubscribeCache(this)); } /** * Caches emissions from the source Observable and replays them in order to any subsequent Subscribers. * This method has similar behavior to {@link #replay} except that this auto-subscribes to the source * Observable rather than returning a {@link ConnectableObservable} for which you must call * {@code connect} to activate the subscription. *

* *

* This is useful when you want an Observable to cache responses and you can't control the * subscribe/unsubscribe behavior of all the {@link Subscriber}s. *

* When you call {@code cache}, it does not yet subscribe to the source Observable and so does not yet * begin cacheing items. This only happens when the first Subscriber calls the resulting Observable's * {@code subscribe} method. *

* Note: You sacrifice the ability to unsubscribe from the origin when you use the {@code cache} * Observer so be careful not to use this Observer on Observables that emit an infinite or very large number * of items that will use up memory. *

*
Backpressure Support:
*
This operator does not support upstream backpressure as it is purposefully requesting and caching * everything emitted.
*
Scheduler:
*
{@code cache} does not operate by default on a particular {@link Scheduler}.
*
* * @param capacity hint for number of items to cache (for optimizing underlying data structure) * @return an Observable that, when first subscribed to, caches all of its items and notifications for the * benefit of subsequent subscribers * @see RxJava wiki: cache */ public final Observable cache(int capacity) { return create(new OnSubscribeCache(this, capacity)); } /** * Returns an Observable that emits the items emitted by the source Observable, converted to the specified * type. *

* *

*
Scheduler:
*
{@code cast} does not operate by default on a particular {@link Scheduler}.
*
* * @param klass * the target class type that {@code cast} will cast the items emitted by the source Observable * into before emitting them from the resulting Observable * @return an Observable that emits each item from the source Observable after converting it to the * specified type * @see RxJava wiki: cast * @see MSDN: Observable.Cast */ public final Observable cast(final Class klass) { return lift(new OperatorCast(klass)); } /** * Collects items emitted by the source Observable into a single mutable data structure and returns an * Observable that emits this structure. *

* *

* This is a simplified version of {@code reduce} that does not need to return the state on each pass. *

*
Backpressure Support:
*
This operator does not support backpressure because by intent it will receive all values and reduce * them to a single {@code onNext}.
*
Scheduler:
*
{@code collect} does not operate by default on a particular {@link Scheduler}.
*
* * @param state * the mutable data structure that will collect the items * @param collector * a function that accepts the {@code state} and an emitted item, and modifies {@code state} * accordingly * @return an Observable that emits the result of collecting the values emitted by the source Observable * into a single mutable data structure * @see RxJava wiki: collect */ public final Observable collect(R state, final Action2 collector) { Func2 accumulator = new Func2() { @Override public final R call(R state, T value) { collector.call(state, value); return state; } }; return reduce(state, accumulator); } /** * Returns a new Observable that emits items resulting from applying a function that you supply to each item * emitted by the source Observable, where that function returns an Observable, and then emitting the items * that result from concatinating those resulting Observables. *

* *

*
Scheduler:
*
{@code concatMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param func * a function that, when applied to an item emitted by the source Observable, returns an * Observable * @return an Observable that emits the result of applying the transformation function to each item emitted * by the source Observable and concatinating the Observables obtained from this transformation * @see RxJava wiki: concatMap */ public final Observable concatMap(Func1> func) { return concat(map(func)); } /** * Returns an Observable that emits the items emitted from the current Observable, then the next, one after * the other, without interleaving them. *

* *

*
Scheduler:
*
{@code concat} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be concatenated after the current * @return an Observable that emits items emitted by the two source Observables, one after the other, * without interleaving them * @see RxJava wiki: concat * @see MSDN: Observable.Concat */ public final Observable concatWith(Observable t1) { return concat(this, t1); } /** * Returns an Observable that emits a Boolean that indicates whether the source Observable emitted a * specified item. *

* *

*
Scheduler:
*
{@code contains} does not operate by default on a particular {@link Scheduler}.
*
* * @param element * the item to search for in the emissions from the source Observable * @return an Observable that emits {@code true} if the specified item is emitted by the source Observable, * or {@code false} if the source Observable completes without emitting that item * @see RxJava wiki: contains * @see MSDN: Observable.Contains */ public final Observable contains(final Object element) { return exists(new Func1() { public final Boolean call(T t1) { return element == null ? t1 == null : element.equals(t1); } }); } /** * Returns an Observable that emits the count of the total number of items emitted by the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because by intent it will receive all values and reduce * them to a single {@code onNext}.
*
Scheduler:
*
{@code count} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits a single item: the number of elements emitted by the source Observable * @see RxJava wiki: count * @see MSDN: Observable.Count * @see #countLong() */ public final Observable count() { return reduce(0, new Func2() { @Override public final Integer call(Integer t1, T t2) { return t1 + 1; } }); } /** * Returns an Observable that counts the total number of items emitted by the source Observable and emits * this count as a 64-bit Long. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because by intent it will receive all values and reduce * them to a single {@code onNext}.
*
Scheduler:
*
{@code countLong} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits a single item: the number of items emitted by the source Observable as a * 64-bit Long item * @see RxJava wiki: countLong * @see MSDN: Observable.LongCount * @see #count() */ public final Observable countLong() { return reduce(0L, new Func2() { @Override public final Long call(Long t1, T t2) { return t1 + 1; } }); } /** * Returns an Observable that mirrors the source Observable, except that it drops items emitted by the * source Observable that are followed by another item within a computed debounce duration. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses the {@code debounceSelector} to mark * boundaries.
*
Scheduler:
*
This version of {@code debounce} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the debounce value type (ignored) * @param debounceSelector * function to retrieve a sequence that indicates the throttle duration for each item * @return an Observable that omits items emitted by the source Observable that are followed by another item * within a computed debounce duration * @see RxJava wiki: debounce * @see RxJava wiki: Backpressure * @see MSDN: Observable.Throttle */ public final Observable debounce(Func1> debounceSelector) { return lift(new OperatorDebounceWithSelector(debounceSelector)); } /** * Returns an Observable that mirrors the source Observable, except that it drops items emitted by the * source Observable that are followed by newer items before a timeout value expires. The timer resets on * each emission. *

* Note: If items keep being emitted by the source Observable faster than the timeout then no items * will be emitted by the resulting Observable. *

* *

* Information on debounce vs throttle: *

*

*
*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
This version of {@code debounce} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timeout * the time each item has to be "the most recent" of those emitted by the source Observable to * ensure that it's not dropped * @param unit * the {@link TimeUnit} for the timeout * @return an Observable that filters out items from the source Observable that are too quickly followed by * newer items * @see RxJava wiki: debounce * @see RxJava wiki: Backpressure * @see MSDN: Observable.Throttle * @see #throttleWithTimeout(long, TimeUnit) */ public final Observable debounce(long timeout, TimeUnit unit) { return debounce(timeout, unit, Schedulers.computation()); } /** * Returns an Observable that mirrors the source Observable, except that it drops items emitted by the * source Observable that are followed by newer items before a timeout value expires on a specified * Scheduler. The timer resets on each emission. *

* Note: If items keep being emitted by the source Observable faster than the timeout then no items * will be emitted by the resulting Observable. *

* *

* Information on debounce vs throttle: *

*

*
*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timeout * the time each item has to be "the most recent" of those emitted by the source Observable to * ensure that it's not dropped * @param unit * the unit of time for the specified timeout * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle the timeout for each * item * @return an Observable that filters out items from the source Observable that are too quickly followed by * newer items * @see RxJava wiki: debounce * @see RxJava wiki: Backpressure * @see MSDN: Observable.Throttle * @see #throttleWithTimeout(long, TimeUnit, Scheduler) */ public final Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorDebounceWithTime(timeout, unit, scheduler)); } /** * Returns an Observable that emits the items emitted by the source Observable or a specified default item * if the source Observable is empty. *

* *

*
Scheduler:
*
{@code defaultIfEmpty} does not operate by default on a particular {@link Scheduler}.
*
* * @param defaultValue * the item to emit if the source Observable emits no items * @return an Observable that emits either the specified default item if the source Observable emits no * items, or the items emitted by the source Observable * @see RxJava wiki: defaultIfEmpty * @see MSDN: Observable.DefaultIfEmpty */ public final Observable defaultIfEmpty(T defaultValue) { return lift(new OperatorDefaultIfEmpty(defaultValue)); } /** * Returns an Observable that delays the subscription to and emissions from the souce Observable via another * Observable on a per-item basis. *

* *

* Note: the resulting Observable will immediately propagate any {@code onError} notification * from the source Observable. *

*
Scheduler:
*
This version of {@code delay} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the subscription delay value type (ignored) * @param * the item delay value type (ignored) * @param subscriptionDelay * a function that returns an Observable that triggers the subscription to the source Observable * once it emits any item * @param itemDelay * a function that returns an Observable for each item emitted by the source Observable, which is * then used to delay the emission of that item by the resulting Observable until the Observable * returned from {@code itemDelay} emits an item * @return an Observable that delays the subscription and emissions of the source Observable via another * Observable on a per-item basis * @see RxJava wiki: delay * @see MSDN: Observable.Delay */ public final Observable delay( Func0> subscriptionDelay, Func1> itemDelay) { return delaySubscription(subscriptionDelay).lift(new OperatorDelayWithSelector(this, itemDelay)); } /** * Returns an Observable that delays the emissions of the source Observable via another Observable on a * per-item basis. *

* *

* Note: the resulting Observable will immediately propagate any {@code onError} notification * from the source Observable. *

*
Scheduler:
*
This version of {@code delay} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the item delay value type (ignored) * @param itemDelay * a function that returns an Observable for each item emitted by the source Observable, which is * then used to delay the emission of that item by the resulting Observable until the Observable * returned from {@code itemDelay} emits an item * @return an Observable that delays the emissions of the source Observable via another Observable on a * per-item basis * @see RxJava wiki: delay * @see MSDN: Observable.Delay */ public final Observable delay(Func1> itemDelay) { return lift(new OperatorDelayWithSelector(this, itemDelay)); } /** * Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a * specified delay. Error notifications from the source Observable are not delayed. *

* *

*
Scheduler:
*
This version of {@code delay} operates by default on the {@code compuation} {@link Scheduler}.
*
* * @param delay * the delay to shift the source by * @param unit * the {@link TimeUnit} in which {@code period} is defined * @return the source Observable shifted in time by the specified delay * @see RxJava wiki: delay * @see MSDN: Observable.Delay */ public final Observable delay(long delay, TimeUnit unit) { return delay(delay, unit, Schedulers.computation()); } /** * Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a * specified delay. Error notifications from the source Observable are not delayed. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param delay * the delay to shift the source by * @param unit * the time unit of {@code delay} * @param scheduler * the {@link Scheduler} to use for delaying * @return the source Observable shifted in time by the specified delay * @see RxJava wiki: delay * @see MSDN: Observable.Delay */ public final Observable delay(long delay, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorDelay(this, delay, unit, scheduler)); } /** * Returns an Observable that delays the subscription to the source Observable by a given amount of time. *

* *

*
Scheduler:
*
This version of {@code delay} operates by default on the {@code compuation} {@link Scheduler}.
*
* * @param delay * the time to delay the subscription * @param unit * the time unit of {@code delay} * @return an Observable that delays the subscription to the source Observable by the given amount * @see RxJava wiki: delaySubscription */ public final Observable delaySubscription(long delay, TimeUnit unit) { return delaySubscription(delay, unit, Schedulers.computation()); } /** * Returns an Observable that delays the subscription to the source Observable by a given amount of time, * both waiting and subscribing on a given Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param delay * the time to delay the subscription * @param unit * the time unit of {@code delay} * @param scheduler * the Scheduler on which the waiting and subscription will happen * @return an Observable that delays the subscription to the source Observable by a given * amount, waiting and subscribing on the given Scheduler * @see RxJava wiki: delaySubscription */ public final Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) { return create(new OnSubscribeDelaySubscription(this, delay, unit, scheduler)); } /** * Returns an Observable that delays the subscription to the source Observable until a second Observable * emits an item. *

* *

*
Scheduler:
*
This version of {@code delay} operates by default on the {@code compuation} {@link Scheduler}.
*
* * @param subscriptionDelay * a function that returns an Observable that triggers the subscription to the source Observable * once it emits any item * @return an Observable that delays the subscription to the source Observable until the Observable returned * by {@code subscriptionDelay} emits an item * @see RxJava wiki: delaySubscription */ public final Observable delaySubscription(Func0> subscriptionDelay) { return create(new OnSubscribeDelaySubscriptionWithSelector(this, subscriptionDelay)); } /** * Returns an Observable that reverses the effect of {@link #materialize materialize} by transforming the * {@link Notification} objects emitted by the source Observable into the items or notifications they * represent. *

* *

*
Scheduler:
*
{@code dematerialize} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits the items and notifications embedded in the {@link Notification} objects * emitted by the source Observable * @throws OnErrorNotImplementedException * if the source Observable is not of type {@code Observable>} * @see RxJava wiki: dematerialize * @see MSDN: Observable.dematerialize */ @SuppressWarnings({"unchecked", "rawtypes"}) public final Observable dematerialize() { return lift(new OperatorDematerialize()); } /** * Returns an Observable that emits all items emitted by the source Observable that are distinct. *

* *

*
Scheduler:
*
{@code distinct} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits only those items emitted by the source Observable that are distinct from * each other * @see RxJava wiki: distinct * @see MSDN: Observable.distinct */ public final Observable distinct() { return lift(new OperatorDistinct(Functions.identity())); } /** * Returns an Observable that emits all items emitted by the source Observable that are distinct according * to a key selector function. *

* *

*
Scheduler:
*
{@code distinct} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * a function that projects an emitted item to a key value that is used to decide whether an item * is distinct from another one or not * @return an Observable that emits those items emitted by the source Observable that have distinct keys * @see RxJava wiki: distinct * @see MSDN: Observable.distinct */ public final Observable distinct(Func1 keySelector) { return lift(new OperatorDistinct(keySelector)); } /** * Returns an Observable that emits all items emitted by the source Observable that are distinct from their * immediate predecessors. *

* *

*
Scheduler:
*
{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits those items from the source Observable that are distinct from their * immediate predecessors * @see RxJava wiki: distinctUntilChanged * @see MSDN: Observable.distinctUntilChanged */ public final Observable distinctUntilChanged() { return lift(new OperatorDistinctUntilChanged(Functions.identity())); } /** * Returns an Observable that emits all items emitted by the source Observable that are distinct from their * immediate predecessors, according to a key selector function. *

* *

*
Scheduler:
*
{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * a function that projects an emitted item to a key value that is used to decide whether an item * is distinct from another one or not * @return an Observable that emits those items from the source Observable whose keys are distinct from * those of their immediate predecessors * @see RxJava wiki: distinctUntilChanged * @see MSDN: Observable.distinctUntilChanged */ public final Observable distinctUntilChanged(Func1 keySelector) { return lift(new OperatorDistinctUntilChanged(keySelector)); } /** * Modifies the source Observable so that it invokes an action when it calls {@code onCompleted}. *

* *

*
Scheduler:
*
{@code doOnCompleted} does not operate by default on a particular {@link Scheduler}.
*
* * @param onCompleted * the action to invoke when the source Observable calls {@code onCompleted} * @return the source Observable with the side-effecting behavior applied * @see RxJava wiki: doOnCompleted * @see MSDN: Observable.Do */ public final Observable doOnCompleted(final Action0 onCompleted) { Observer observer = new Observer() { @Override public final void onCompleted() { onCompleted.call(); } @Override public final void onError(Throwable e) { } @Override public final void onNext(T args) { } }; return lift(new OperatorDoOnEach(observer)); } /** * Modifies the source Observable so that it invokes an action for each item it emits. *

* *

*
Scheduler:
*
{@code doOnEach} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNotification * the action to invoke for each item emitted by the source Observable * @return the source Observable with the side-effecting behavior applied * @see RxJava wiki: doOnEach * @see MSDN: Observable.Do */ public final Observable doOnEach(final Action1> onNotification) { Observer observer = new Observer() { @Override public final void onCompleted() { onNotification.call(Notification.createOnCompleted()); } @Override public final void onError(Throwable e) { onNotification.call(Notification.createOnError(e)); } @Override public final void onNext(T v) { onNotification.call(Notification.createOnNext(v)); } }; return lift(new OperatorDoOnEach(observer)); } /** * Modifies the source Observable so that it notifies an Observer for each item it emits. *

* *

*
Scheduler:
*
{@code doOnEach} does not operate by default on a particular {@link Scheduler}.
*
* * @param observer * the action to invoke for each item emitted by the source Observable * @return the source Observable with the side-effecting behavior applied * @see RxJava wiki: doOnEach * @see MSDN: Observable.Do */ public final Observable doOnEach(Observer observer) { return lift(new OperatorDoOnEach(observer)); } /** * Modifies the source Observable so that it invokes an action if it calls {@code onError}. *

* *

*
Scheduler:
*
{@code doOnError} does not operate by default on a particular {@link Scheduler}.
*
* * @param onError * the action to invoke if the source Observable calls {@code onError} * @return the source Observable with the side-effecting behavior applied * @see RxJava wiki: doOnError * @see MSDN: Observable.Do */ public final Observable doOnError(final Action1 onError) { Observer observer = new Observer() { @Override public final void onCompleted() { } @Override public final void onError(Throwable e) { onError.call(e); } @Override public final void onNext(T args) { } }; return lift(new OperatorDoOnEach(observer)); } /** * Modifies the source Observable so that it invokes an action when it calls {@code onNext}. *

* *

*
Scheduler:
*
{@code doOnNext} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext * the action to invoke when the source Observable calls {@code onNext} * @return the source Observable with the side-effecting behavior applied * @see RxJava wiki: doOnEach * @see MSDN: Observable.Do */ public final Observable doOnNext(final Action1 onNext) { Observer observer = new Observer() { @Override public final void onCompleted() { } @Override public final void onError(Throwable e) { } @Override public final void onNext(T args) { onNext.call(args); } }; return lift(new OperatorDoOnEach(observer)); } /** * Modifies the source {@code Observable} so that it invokes the given action when it is subscribed from * its subscribers. Each subscription will result in an invocation of the given action except when the * source {@code Observable} is reference counted, in which case the source {@code Observable} will invoke * the given action for the first subscription. *

* *

*
Scheduler:
*
{@code doOnSubscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param subscribe * the action that gets called when an observer subscribes to this {@code Observable} * @return the source {@code Observable} modified so as to call this Action when appropriate * @see RxJava wiki: doOnSubscribe */ public final Observable doOnSubscribe(final Action0 subscribe) { return lift(new OperatorDoOnSubscribe(subscribe)); } /** * Modifies the source Observable so that it invokes an action when it calls {@code onCompleted} or * {@code onError}. *

* *

* This differs from {@code finallyDo} in that this happens before the {@code onCompleted} or * {@code onError} notification. *

*
Scheduler:
*
{@code doOnTerminate} does not operate by default on a particular {@link Scheduler}.
*
* * @param onTerminate * the action to invoke when the source Observable calls {@code onCompleted} or {@code onError} * @return the source Observable with the side-effecting behavior applied * @see RxJava wiki: doOnTerminate * @see MSDN: Observable.Do * @see #finallyDo(Action0) */ public final Observable doOnTerminate(final Action0 onTerminate) { Observer observer = new Observer() { @Override public final void onCompleted() { onTerminate.call(); } @Override public final void onError(Throwable e) { onTerminate.call(); } @Override public final void onNext(T args) { } }; return lift(new OperatorDoOnEach(observer)); } /** * Modifies the source {@code Observable} so that it invokes the given action when it is unsubscribed from * its subscribers. Each un-subscription will result in an invocation of the given action except when the * source {@code Observable} is reference counted, in which case the source {@code Observable} will invoke * the given action for the very last un-subscription. *

* *

*
Scheduler:
*
{@code doOnUnsubscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param unsubscribe * the action that gets called when this {@code Observable} is unsubscribed * @return the source {@code Observable} modified so as to call this Action when appropriate * @see RxJava wiki: doOnUnsubscribe */ public final Observable doOnUnsubscribe(final Action0 unsubscribe) { return lift(new OperatorDoOnUnsubscribe(unsubscribe)); } /** * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a * source Observbable. *

* *

*
Scheduler:
*
{@code elementAt} does not operate by default on a particular {@link Scheduler}.
*
* * @param index * the zero-based index of the item to retrieve * @return an Observable that emits a single item: the item at the specified position in the sequence of * those emitted by the source Observable * @throws IndexOutOfBoundsException * if {@code index} is greater than or equal to the number of items emitted by the source * Observable, or * if {@code index} is less than 0 * @see RxJava wiki: elementAt */ public final Observable elementAt(int index) { return lift(new OperatorElementAt(index)); } /** * Returns an Observable that emits the item found at a specified index in a sequence of emissions from a * source Observable, or a default item if that index is out of range. *

* *

*
Scheduler:
*
{@code elementAtOrDefault} does not operate by default on a particular {@link Scheduler}.
*
* * @param index * the zero-based index of the item to retrieve * @param defaultValue * the default item * @return an Observable that emits the item at the specified position in the sequence emitted by the source * Observable, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException * if {@code index} is less than 0 * @see RxJava wiki: elementAtOrDefault */ public final Observable elementAtOrDefault(int index, T defaultValue) { return lift(new OperatorElementAt(index, defaultValue)); } /** * Returns an Observable that emits {@code true} if any item emitted by the source Observable satisfies a * specified condition, otherwise {@code false}. Note: this always emits {@code false} if the * source Observable is empty. *

* *

* In Rx.Net this is the {@code any} Observer but we renamed it in RxJava to better match Java naming * idioms. *

*
Scheduler:
*
{@code exists} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * the condition to test items emitted by the source Observable * @return an Observable that emits a Boolean that indicates whether any item emitted by the source * Observable satisfies the {@code predicate} * @see RxJava wiki: exists * @see MSDN: Observable.Any (Note: the description in this page was wrong at the time of this writing) */ public final Observable exists(Func1 predicate) { return lift(new OperatorAny(predicate, false)); } /** * Filters items emitted by an Observable by only emitting those that satisfy a specified predicate. *

* *

*
Scheduler:
*
{@code filter} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * a function that evaluates each item emitted by the source Observable, returning {@code true} * if it passes the filter * @return an Observable that emits only those items emitted by the source Observable that the filter * evaluates as {@code true} * @see RxJava wiki: filter */ public final Observable filter(Func1 predicate) { return lift(new OperatorFilter(predicate)); } /** * Registers an {@link Action0} to be called when this Observable invokes either * {@link Observer#onCompleted onCompleted} or {@link Observer#onError onError}. *

* *

*
Scheduler:
*
{@code finallyDo} does not operate by default on a particular {@link Scheduler}.
*
* * @param action * an {@link Action0} to be invoked when the source Observable finishes * @return an Observable that emits the same items as the source Observable, then invokes the * {@link Action0} * @see RxJava wiki: finallyDo * @see MSDN: Observable.Finally * @see #doOnTerminate(Action0) */ public final Observable finallyDo(Action0 action) { return lift(new OperatorFinally(action)); } /** * Returns an Observable that emits only the very first item emitted by the source Observable, or notifies * of an {@code NoSuchElementException} if the source Observable is empty. *

* *

*
Scheduler:
*
{@code first} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits only the very first item emitted by the source Observable, or raises an * {@code NoSuchElementException} if the source Observable is empty * @see RxJava wiki: first * @see "MSDN: Observable.firstAsync" */ public final Observable first() { return take(1).single(); } /** * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies * a specified condition, or notifies of an {@code NoSuchElementException} if no such items are emitted. *

* *

*
Scheduler:
*
{@code first} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * the condition that an item emitted by the source Observable has to satisfy * @return an Observable that emits only the very first item emitted by the source Observable that satisfies * the {@code predicate}, or raises an {@code NoSuchElementException} if no such items are emitted * @see RxJava wiki: takeFirst * @see "MSDN: Observable.firstAsync" */ public final Observable first(Func1 predicate) { return takeFirst(predicate).single(); } /** * Returns an Observable that emits only the very first item emitted by the source Observable, or a default * item if the source Observable completes without emitting anything. *

* *

*
Scheduler:
*
{@code firstOrDefault} does not operate by default on a particular {@link Scheduler}.
*
* * @param defaultValue * the default item to emit if the source Observable doesn't emit anything * @return an Observable that emits only the very first item from the source, or a default item if the * source Observable completes without emitting any items * @see RxJava wiki: firstOrDefault * @see "MSDN: Observable.firstOrDefaultAsync" */ public final Observable firstOrDefault(T defaultValue) { return take(1).singleOrDefault(defaultValue); } /** * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies * a specified condition, or a default item if the source Observable emits no such items. *

* *

*
Scheduler:
*
{@code firstOrDefault} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * the condition any item emitted by the source Observable has to satisfy * @param defaultValue * the default item to emit if the source Observable doesn't emit anything that satisfies the * {@code predicate} * @return an Observable that emits only the very first item emitted by the source Observable that satisfies * the {@code predicate}, or a default item if the source Observable emits no such items * @see RxJava wiki: firstOrDefault * @see "MSDN: Observable.firstOrDefaultAsync" */ public final Observable firstOrDefault(T defaultValue, Func1 predicate) { return takeFirst(predicate).singleOrDefault(defaultValue); } /** * Returns an Observable that emits items based on applying a function that you supply to each item emitted * by the source Observable, where that function returns an Observable, and then merging those resulting * Observables and emitting the results of this merger. *

* *

*
Scheduler:
*
{@code flatMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param func * a function that, when applied to an item emitted by the source Observable, returns an * Observable * @return an Observable that emits the result of applying the transformation function to each item emitted * by the source Observable and merging the results of the Observables obtained from this * transformation * @see RxJava wiki: flatMap * @see MSDN: Observable.SelectMany */ public final Observable flatMap(Func1> func) { return merge(map(func)); } /** * Returns an Observable that applies a function to each item emitted or notification raised by the source * Observable and then flattens the Observables returned from these functions and emits the resulting items. *

* *

*
Scheduler:
*
{@code flatMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the result type * @param onNext * a function that returns an Observable to merge for each item emitted by the source Observable * @param onError * a function that returns an Observable to merge for an onError notification from the source * Observable * @param onCompleted * a function that returns an Observable to merge for an onCompleted notification from the source * Observable * @return an Observable that emits the results of merging the Observables returned from applying the * specified functions to the emissions and notifications of the source Observable * @see RxJava wiki: flatMap */ public final Observable flatMap( Func1> onNext, Func1> onError, Func0> onCompleted) { return merge(mapNotification(onNext, onError, onCompleted)); } /** * Returns an Observable that emits the results of a specified function to the pair of values emitted by the * source Observable and a specified collection Observable. *

* *

*
Scheduler:
*
{@code flatMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items emitted by the collection Observable * @param * the type of items emitted by the resulting Observable * @param collectionSelector * a function that returns an Observable for each item emitted by the source Observable * @param resultSelector * a function that combines one item emitted by each of the source and collection Observables and * returns an item to be emitted by the resulting Observable * @return an Observable that emits the results of applying a function to a pair of values emitted by the * source Observable and the collection Observable * @see RxJava wiki: flatMap */ public final Observable flatMap(final Func1> collectionSelector, final Func2 resultSelector) { return merge(lift(new OperatorMapPair(collectionSelector, resultSelector))); } /** * Returns an Observable that merges each item emitted by the source Observable with the values in an * Iterable corresponding to that item that is generated by a selector. *

* *

*
Scheduler:
*
{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of item emitted by the resulting Observable * @param collectionSelector * a function that returns an Iterable sequence of values for when given an item emitted by the * source Observable * @return an Observable that emits the results of merging the items emitted by the source Observable with * the values in the Iterables corresponding to those items, as generated by {@code collectionSelector} * @see RxJava wiki: flatMapIterable */ public final Observable flatMapIterable(Func1> collectionSelector) { return merge(map(OperatorMapPair.convertSelector(collectionSelector))); } /** * Returns an Observable that emits the results of applying a function to the pair of values from the source * Observable and an Iterable corresponding to that item that is generated by a selector. *

* *

*
Scheduler:
*
{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the collection element type * @param * the type of item emited by the resulting Observable * @param collectionSelector * a function that returns an Iterable sequence of values for each item emitted by the source * Observable * @param resultSelector * a function that returns an item based on the item emitted by the source Observable and the * Iterable returned for that item by the {@code collectionSelector} * @return an Observable that emits the items returned by {@code resultSelector} for each item in the source * Observable * @see RxJava wiki: flatMapIterable */ public final Observable flatMapIterable(Func1> collectionSelector, Func2 resultSelector) { return flatMap(OperatorMapPair.convertSelector(collectionSelector), resultSelector); } /** * Subscribes to the {@link Observable} and receives notifications for each element. *

* Alias to {@link #subscribe(Action1)} *

*
Scheduler:
*
{@code forEach} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext * {@link Action1} to execute for each item. * @throws IllegalArgumentException * if {@code onNext} is null, or * if {@code onError} is null, or * if {@code onComplete} is null * @see RxJava wiki: onNext, onCompleted, and onError * @see MSDN: Observable.ForEach */ public final void forEach(final Action1 onNext) { subscribe(onNext); } /** * Subscribes to the {@link Observable} and receives notifications for each element and error events. *

* Alias to {@link #subscribe(Action1, Action1)} *

*
Scheduler:
*
{@code forEach} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext * {@link Action1} to execute for each item. * @param onError * {@link Action1} to execute when an error is emitted. * @throws IllegalArgumentException * if {@code onNext} is null, or * if {@code onError} is null, or * if {@code onComplete} is null * @see RxJava wiki: onNext, onCompleted, and onError * @see MSDN: Observable.ForEach */ public final void forEach(final Action1 onNext, final Action1 onError) { subscribe(onNext, onError); } /** * Subscribes to the {@link Observable} and receives notifications for each element and the terminal events. *

* Alias to {@link #subscribe(Action1, Action1, Action0)} *

*
Scheduler:
*
{@code forEach} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext * {@link Action1} to execute for each item. * @param onError * {@link Action1} to execute when an error is emitted. * @param onComplete * {@link Action0} to execute when completion is signalled. * @throws IllegalArgumentException * if {@code onNext} is null, or * if {@code onError} is null, or * if {@code onComplete} is null * @see RxJava wiki: onNext, onCompleted, and onError * @see MSDN: Observable.ForEach */ public final void forEach(final Action1 onNext, final Action1 onError, final Action0 onComplete) { subscribe(onNext, onError, onComplete); } /** * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these * grouped items as {@link GroupedObservable}s, one {@code GroupedObservable} per group. *

* *

* Note: A {@link GroupedObservable} will cache the items it is to emit until such time as it * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may * discard their buffers by applying an operator like {@link #take}{@code (0)} to them. *

*
Scheduler:
*
{@code groupBy} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * a function that extracts the key for each item * @param elementSelector * a function that extracts the return element for each item * @param * the key type * @param * the element type * @return an {@code Observable} that emits {@link GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the source Observable that share that * key value * @see RxJava wiki: groupBy * @see MSDN: Observable.GroupBy */ public final Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) { return lift(new OperatorGroupBy(keySelector, elementSelector)); } /** * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these * grouped items as {@link GroupedObservable}s, one {@code GroupedObservable} per group. *

* *

* Note: A {@link GroupedObservable} will cache the items it is to emit until such time as it * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may * discard their buffers by applying an operator like {@link #take}{@code (0)} to them. *

*
Scheduler:
*
{@code groupBy} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * a function that extracts the key for each item * @param * the key type * @return an {@code Observable} that emits {@link GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the source Observable that share that * key value * @see RxJava wiki: groupBy * @see MSDN: Observable.GroupBy */ public final Observable> groupBy(final Func1 keySelector) { return lift(new OperatorGroupBy(keySelector)); } /** * Returns an Observable that correlates two Observables when they overlap in time and groups the results. *

* *

*
Scheduler:
*
{@code groupJoin} does not operate by default on a particular {@link Scheduler}.
*
* * @param right * the other Observable to correlate items from the source Observable with * @param leftDuration * a function that returns an Observable whose emissions indicate the duration of the values of * the source Observable * @param rightDuration * a function that returns an Observable whose emissions indicate the duration of the values of * the {@code right} Observable * @param resultSelector * a function that takes an item emitted by each Observable and returns the value to be emitted * by the resulting Observable * @return an Observable that emits items based on combining those items emitted by the source Observables * whose durations overlap * @see RxJava Wiiki: groupJoin * @see MSDN: Observable.GroupJoin */ public final Observable groupJoin(Observable right, Func1> leftDuration, Func1> rightDuration, Func2, ? extends R> resultSelector) { return create(new OnSubscribeGroupJoin(this, right, leftDuration, rightDuration, resultSelector)); } /** * Ignores all items emitted by the source Observable and only calls {@code onCompleted} or {@code onError}. *

* *

*
Scheduler:
*
{@code ignoreElements} does not operate by default on a particular {@link Scheduler}.
*
* * @return an empty Observable that only calls {@code onCompleted} or {@code onError}, based on which one is * called by the source Observable * @see RxJava wiki: ignoreElements * @see MSDN: Observable.IgnoreElements */ public final Observable ignoreElements() { return filter(alwaysFalse()); } /** * Returns an Observable that emits {@code true} if the source Observable is empty, otherwise {@code false}. *

* In Rx.Net this is negated as the {@code any} Observer but we renamed this in RxJava to better match Java * naming idioms. *

* *

*
Scheduler:
*
{@code isEmpty} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits a Boolean * @see RxJava wiki: isEmpty * @see MSDN: Observable.Any */ public final Observable isEmpty() { return lift(new OperatorAny(Functions.alwaysTrue(), true)); } /** * Correlates the items emitted by two Observables based on overlapping durations. *

* *

*
Scheduler:
*
{@code join} does not operate by default on a particular {@link Scheduler}.
*
* * @param right * the second Observable to join items from * @param leftDurationSelector * a function to select a duration for each item emitted by the source Observable, used to * determine overlap * @param rightDurationSelector * a function to select a duration for each item emitted by the {@code right} Observable, used to * determine overlap * @param resultSelector * a function that computes an item to be emitted by the resulting Observable for any two * overlapping items emitted by the two Observables * @return an Observable that emits items correlating to items emitted by the source Observables that have * overlapping durations * @see RxJava wiki: join * @see MSDN: Observable.Join */ public final Observable join(Observable right, Func1> leftDurationSelector, Func1> rightDurationSelector, Func2 resultSelector) { return create(new OnSubscribeJoin(this, right, leftDurationSelector, rightDurationSelector, resultSelector)); } /** * Returns an Observable that emits the last item emitted by the source Observable or notifies observers of * a {@code NoSuchElementException} if the source Observable is empty. *

* *

*
Scheduler:
*
{@code last} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits the last item from the source Observable or notifies observers of an * error * @see RxJava wiki: last * @see "MSDN: Observable.lastAsync" */ public final Observable last() { return takeLast(1).single(); } /** * Returns an Observable that emits only the last item emitted by the source Observable that satisfies a * given condition, or notifies of a {@code NoSuchElementException} if no such items are emitted. *

* *

*
Scheduler:
*
{@code last} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * the condition any source emitted item has to satisfy * @return an Observable that emits only the last item satisfying the given condition from the source, or an * {@code NoSuchElementException} if no such items are emitted * @throws IllegalArgumentException * if no items that match the predicate are emitted by the source Observable * @see RxJava wiki: last * @see "MSDN: Observable.lastAsync" */ public final Observable last(Func1 predicate) { return filter(predicate).takeLast(1).single(); } /** * Returns an Observable that emits only the last item emitted by the source Observable, or a default item * if the source Observable completes without emitting any items. *

* *

*
Scheduler:
*
{@code lastOrDefault} does not operate by default on a particular {@link Scheduler}.
*
* * @param defaultValue * the default item to emit if the source Observable is empty * @return an Observable that emits only the last item emitted by the source Observable, or a default item * if the source Observable is empty * @see RxJava wiki: lastOrDefault * @see "MSDN: Observable.lastOrDefaultAsync" */ public final Observable lastOrDefault(T defaultValue) { return takeLast(1).singleOrDefault(defaultValue); } /** * Returns an Observable that emits only the last item emitted by the source Observable that satisfies a * specified condition, or a default item if no such item is emitted by the source Observable. *

* *

*
Scheduler:
*
{@code lastOrDefault} does not operate by default on a particular {@link Scheduler}.
*
* * @param defaultValue * the default item to emit if the source Observable doesn't emit anything that satisfies the * specified {@code predicate} * @param predicate * the condition any item emitted by the source Observable has to satisfy * @return an Observable that emits only the last item emitted by the source Observable that satisfies the * given condition, or a default item if no such item is emitted by the source Observable * @see RxJava wiki: lastOrDefault * @see "MSDN: Observable.lastOrDefaultAsync" */ public final Observable lastOrDefault(T defaultValue, Func1 predicate) { return filter(predicate).takeLast(1).singleOrDefault(defaultValue); } /** * Returns an Observable that emits only the first {@code num} items emitted by the source Observable. *

* Alias of {@link #take(int)} to match Java 8 Stream API naming convention. *

* *

* This method returns an Observable that will invoke a subscribing {@link Observer}'s * {@link Observer#onNext onNext} function a maximum of {@code num} times before invoking * {@link Observer#onCompleted onCompleted}. *

*
Scheduler:
*
{@code limit} does not operate by default on a particular {@link Scheduler}.
*
* * @param num * the maximum number of items to emit * @return an Observable that emits only the first {@code num} items emitted by the source Observable, or * all of the items from the source Observable if that Observable emits fewer than {@code num} items * @see RxJava wiki: take */ public final Observable limit(int num) { return take(num); } /** * Returns an Observable that applies a specified function to each item emitted by the source Observable and * emits the results of these function applications. *

* *

*
Scheduler:
*
{@code map} does not operate by default on a particular {@link Scheduler}.
*
* * @param func * a function to apply to each item emitted by the Observable * @return an Observable that emits the items from the source Observable, transformed by the specified * function * @see RxJava wiki: map * @see MSDN: Observable.Select */ public final Observable map(Func1 func) { return lift(new OperatorMap(func)); } private final Observable mapNotification(Func1 onNext, Func1 onError, Func0 onCompleted) { return lift(new OperatorMapNotification(onNext, onError, onCompleted)); } /** * Returns an Observable that represents all of the emissions and notifications from the source * Observable into emissions marked with their original types within {@link Notification} objects. *

* *

*
Scheduler:
*
{@code materialize} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits items that are the result of materializing the items and notifications * of the source Observable * @see RxJava wiki: materialize * @see MSDN: Observable.Materialize */ public final Observable> materialize() { return lift(new OperatorMaterialize()); } /** * Flattens this and another Observable into a single Observable, without any transformation. *

* *

* You can combine items emitted by multiple Observables so that they appear as a single Observable, by * using the {@code mergeWith} method. *

*
Scheduler:
*
{@code mergeWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * an Observable to be merged * @return an Observable that emits all of the items emitted by the source Observables * @see RxJava wiki: merge * @see MSDN: Observable.Merge */ public final Observable mergeWith(Observable t1) { return merge(this, t1); } /** * Returns an Observable that emits items produced by multicasting the source Observable within a selector * function. *

* This is largely a helper function used by RxJava for other forms of multicasting, such as * {@link #publish} and {@link #publishLast}. *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
{@code multicast} does not operate by default on a particular {@link Scheduler}.
*
* * @warn javadocs incomplete: description needs improvement * @param subjectFactory * the {@link Subject} factory * @warn javadocs incomplete: "subjectFactory" parameter described poorly * @param selector * the selector function, which can use the multicasted source Observable subject to the policies * enforced by the created {@code Subject} * @warn javadocs incomplete: "selector" parameter described poorly * @return an Observable that emits the items produced by multicasting the source Observable within a * selector function * @see RxJava: Observable.publish() and Observable.multicast * @see MSDN: Observable.Multicast */ public final Observable multicast( final Func0> subjectFactory, final Func1, ? extends Observable> selector) { return create(new OnSubscribeMulticastSelector(this, subjectFactory, selector)); } /** * Returns a {@link ConnectableObservable} that upon connection causes the source Observable to push results * into the specified subject. A Connectable Observable resembles an ordinary Observable, except that it * does not begin emitting items when it is subscribed to, but only when its {@code connect} method * is called. *
*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
{@code multicast} does not operate by default on a particular {@link Scheduler}.
*
* * @param subjectFactory * a function that creates a new {@link Subject} for the {@link ConnectableObservable} to push * source items into * @param * the type of items emitted by the resulting {@code ConnectableObservable} * @return a {@link ConnectableObservable} that upon connection causes the source Observable to push results * into the specified {@link Subject} * @see RxJava wiki: Observable.publish and Observable.multicast * @see MSDN: Observable.Multicast */ public final ConnectableObservable multicast(Func0> subjectFactory) { return new OperatorMulticast(this, subjectFactory); } /** * Modifies an Observable to perform its emissions and notifications on a specified {@link Scheduler}, * asynchronously with an unbounded buffer. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param scheduler * the {@link Scheduler} to notify {@link Observer}s on * @return the source Observable modified so that its {@link Observer}s are notified on the specified * {@link Scheduler} * @see RxJava wiki: observeOn * @see RxJava Threading Examples * @see #subscribeOn */ public final Observable observeOn(Scheduler scheduler) { return lift(new OperatorObserveOn(scheduler)); } /** * Filters the items emitted by an Observable, only emitting those of the specified type. *

* *

*
Scheduler:
*
{@code ofType} does not operate by default on a particular {@link Scheduler}.
*
* * @param klass * the class type to filter the items emitted by the source Observable * @return an Observable that emits items from the source Observable of type {@code klass} * @see RxJava wiki: ofType * @see MSDN: Observable.OfType */ public final Observable ofType(final Class klass) { return filter(new Func1() { public final Boolean call(T t) { return klass.isInstance(t); } }).cast(klass); } /** * Instructs an Observable that is emitting items faster than its observer can consume them to buffer these * items indefinitely until they can be emitted. *

* *

*
Scheduler:
*
{@code onBackpressureBuffer} does not operate by default on a particular {@link Scheduler}.
*
* * @return the source Observable modified to buffer items to the extent system resources allow * @see RxJava wiki: Backpressure */ public final Observable onBackpressureBuffer() { return lift(new OperatorOnBackpressureBuffer()); } /** * Use this operator when the upstream does not natively support backpressure and you wish to drop * {@code onNext} when unable to handle further events. *

* *

* If the downstream request count hits 0 then {@code onNext} will be dropped until {@code request(long n)} * is invoked again to increase the request count. *

*
Scheduler:
*
{@code onBackpressureDrop} does not operate by default on a particular {@link Scheduler}.
*
* * @return the source Observable modified to drop {@code onNext} notifications on overflow * @see RxJava wiki: Backpressure */ public final Observable onBackpressureDrop() { return lift(new OperatorOnBackpressureDrop()); } /** * Instructs an Observable to pass control to another Observable rather than invoking * {@link Observer#onError onError} if it encounters an error. *

* *

* By default, when an Observable encounters an error that prevents it from emitting the expected item to * its {@link Observer}, the Observable invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this * behavior. If you pass a function that returns an Observable ({@code resumeFunction}) to * {@code onErrorResumeNext}, if the original Observable encounters an error, instead of invoking its * Observer's {@code onError} method, it will instead relinquish control to the Observable returned from * {@code resumeFunction}, which will invoke the Observer's {@link Observer#onNext onNext} method if it is * able to do so. In such a case, because no Observable necessarily invokes {@code onError}, the Observer * may never know that an error happened. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be * encountered. *

*
Scheduler:
*
{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.
*
* * @param resumeFunction * a function that returns an Observable that will take over if the source Observable encounters * an error * @return the original Observable, with appropriately modified behavior * @see RxJava wiki: onErrorResumeNext * @see MSDN: Observable.OnErrorResumeNext */ public final Observable onErrorResumeNext(final Func1> resumeFunction) { return lift(new OperatorOnErrorResumeNextViaFunction(resumeFunction)); } /** * Instructs an Observable to pass control to another Observable rather than invoking * {@link Observer#onError onError} if it encounters an error. *

* *

* By default, when an Observable encounters an error that prevents it from emitting the expected item to * its {@link Observer}, the Observable invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this * behavior. If you pass another Observable ({@code resumeSequence}) to an Observable's * {@code onErrorResumeNext} method, if the original Observable encounters an error, instead of invoking its * Observer's {@code onError} method, it will instead relinquish control to {@code resumeSequence} which * will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case, * because no Observable necessarily invokes {@code onError}, the Observer may never know that an error * happened. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be * encountered. *

*
Scheduler:
*
{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.
*
* * @param resumeSequence * a function that returns an Observable that will take over if the source Observable encounters * an error * @return the original Observable, with appropriately modified behavior * @see RxJava wiki: onErrorResumeNext * @see MSDN: Observable.OnErrorResumeNext */ public final Observable onErrorResumeNext(final Observable resumeSequence) { return lift(new OperatorOnErrorResumeNextViaObservable(resumeSequence)); } /** * Instructs an Observable to emit an item (returned by a specified function) rather than invoking * {@link Observer#onError onError} if it encounters an error. *

* *

* By default, when an Observable encounters an error that prevents it from emitting the expected item to * its {@link Observer}, the Observable invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onErrorReturn} method changes this * behavior. If you pass a function ({@code resumeFunction}) to an Observable's {@code onErrorReturn} * method, if the original Observable encounters an error, instead of invoking its Observer's * {@code onError} method, it will instead emit the return value of {@code resumeFunction}. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be * encountered. *

*
Scheduler:
*
{@code onErrorReturn} does not operate by default on a particular {@link Scheduler}.
*
* * @param resumeFunction * a function that returns an item that the new Observable will emit if the source Observable * encounters an error * @return the original Observable with appropriately modified behavior * @see RxJava wiki: onErrorReturn */ public final Observable onErrorReturn(Func1 resumeFunction) { return lift(new OperatorOnErrorReturn(resumeFunction)); } /** * Instructs an Observable to pass control to another Observable rather than invoking * {@link Observer#onError onError} if it encounters an {@link java.lang.Exception}. *

* This differs from {@link #onErrorResumeNext} in that this one does not handle {@link java.lang.Throwable} * or {@link java.lang.Error} but lets those continue through. *

* *

* By default, when an Observable encounters an exception that prevents it from emitting the expected item * to its {@link Observer}, the Observable invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onExceptionResumeNext} method changes * this behavior. If you pass another Observable ({@code resumeSequence}) to an Observable's * {@code onExceptionResumeNext} method, if the original Observable encounters an exception, instead of * invoking its Observer's {@code onError} method, it will instead relinquish control to * {@code resumeSequence} which will invoke the Observer's {@link Observer#onNext onNext} method if it is * able to do so. In such a case, because no Observable necessarily invokes {@code onError}, the Observer * may never know that an exception happened. *

* You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be * encountered. *

*
Scheduler:
*
{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.
*
* * @param resumeSequence * a function that returns an Observable that will take over if the source Observable encounters * an exception * @return the original Observable, with appropriately modified behavior * @see RxJava wiki: onExceptionResumeNext */ public final Observable onExceptionResumeNext(final Observable resumeSequence) { return lift(new OperatorOnExceptionResumeNextViaObservable(resumeSequence)); } /** * Returns a {@link ConnectableObservable}, which waits until its * {@link ConnectableObservable#connect connect} method is called before it begins emitting items to those * {@link Observer}s that have subscribed to it. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
{@code publish} does not operate by default on a particular {@link Scheduler}.
*
* * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit items * to its {@link Observer}s * @see RxJava wiki: publish * @see MSDN: Observable.Publish */ public final ConnectableObservable publish() { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return PublishSubject. create(); } }); } /** * Returns an Observable that emits the results of invoking a specified selector on items emitted by a * {@link ConnectableObservable} that shares a single subscription to the underlying sequence. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
{@code publish} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a function that can use the multicasted source sequence as many times as needed, without * causing multiple subscriptions to the source sequence. Subscribers to the given source will * receive all notifications of the source from the time of the subscription forward. * @return an Observable that emits the results of invoking the selector on the items emitted by a {@link ConnectableObservable} that shares a single subscription to the underlying sequence * @see RxJava wiki: publish * @see MSDN: Observable.Publish */ public final Observable publish(Func1, ? extends Observable> selector) { return multicast(new Func0>() { @Override public final Subject call() { return PublishSubject.create(); } }, selector); } /** * Returns an Observable that emits {@code initialValue} followed by the results of invoking a specified * selector on items emitted by a {@link ConnectableObservable} that shares a single subscription to the * source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
{@code publish} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a function that can use the multicasted source sequence as many times as needed, without * causing multiple subscriptions to the source Observable. Subscribers to the source will * receive all notifications of the source from the time of the subscription forward * @param initialValue * the initial value of the underlying {@link BehaviorSubject} * @return an Observable that emits {@code initialValue} followed by the results of invoking the selector * on a {@link ConnectableObservable} that shares a single subscription to the underlying Observable * @see RxJava wiki: publish * @see MSDN: Observable.Publish */ public final Observable publish(Func1, ? extends Observable> selector, final T initialValue) { return multicast(new Func0>() { @Override public final Subject call() { return BehaviorSubject.create(initialValue); } }, selector); } /** * Returns a {@link ConnectableObservable} that emits {@code initialValue} followed by the items emitted by * the source Observable. A Connectable Observable resembles an ordinary Observable, except that it does not * begin emitting items when it is subscribed to, but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
{@code publish} does not operate by default on a particular {@link Scheduler}.
*
* * @param initialValue * the initial value to be emitted by the resulting Observable * @return a {@link ConnectableObservable} that shares a single subscription to the underlying Observable * and starts with {@code initialValue} * @see RxJava wiki: publish * @see MSDN: Observable.Publish */ public final ConnectableObservable publish(final T initialValue) { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return BehaviorSubject. create(initialValue); } }); } /** * Returns a {@link ConnectableObservable} that emits only the last item emitted by the source Observable. * A Connectable Observable resembles an ordinary Observable, except that it does not begin emitting items * when it is subscribed to, but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because by intent it is skipping all values except the * last.
*
Scheduler:
*
{@code publishLast} does not operate by default on a particular {@link Scheduler}.
*
* * @return a {@link ConnectableObservable} that emits only the last item emitted by the source Observable * @see RxJava wiki: publishLast * @see MSDN: Observable.PublishLast */ public final ConnectableObservable publishLast() { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return AsyncSubject. create(); } }); } /** * Returns an Observable that emits an item that results from invoking a specified selector on the last item * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because by intent it is skipping all values except the * last.
*
Scheduler:
*
{@code publishLast} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a function that can use the multicasted source sequence as many times as needed, without * causing multiple subscriptions to the source Observable. Subscribers to the source will only * receive the last item emitted by the source. * @return an Observable that emits an item that is the result of invoking the selector on a {@link ConnectableObservable} that shares a single subscription to the source Observable * @see RxJava wiki: publishLast * @see MSDN: Observable.PublishLast */ public final Observable publishLast(Func1, ? extends Observable> selector) { return multicast(new Func0>() { @Override public final Subject call() { return AsyncSubject.create(); } }, selector); } /** * Returns an Observable that applies a function of your choosing to the first item emitted by a source * Observable, then feeds the result of that function along with the second item emitted by the source * Observable into the same function, and so on until all items have been emitted by the source Observable, * and emits the final result from the final call to your function as its sole item. *

* *

* This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method * that does a similar operation on lists. *

*
Backpressure Support:
*
This operator does not support backpressure because by intent it will receive all values and reduce * them to a single {@code onNext}.
*
Scheduler:
*
{@code reduce} does not operate by default on a particular {@link Scheduler}.
*
* * @param accumulator * an accumulator function to be invoked on each item emitted by the source Observable, whose * result will be used in the next accumulator call * @return an Observable that emits a single item that is the result of accumulating the items emitted by * the source Observable * @throws IllegalArgumentException * if the source Observable emits no items * @see RxJava wiki: reduce * @see MSDN: Observable.Aggregate * @see Wikipedia: Fold (higher-order function) */ public final Observable reduce(Func2 accumulator) { /* * Discussion and confirmation of implementation at * https://github.com/ReactiveX/RxJava/issues/423#issuecomment-27642532 * * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty. */ return scan(accumulator).last(); } /** * Returns an Observable that applies a function of your choosing to the first item emitted by a source * Observable and a specified seed value, then feeds the result of that function along with the second item * emitted by an Observable into the same function, and so on until all items have been emitted by the * source Observable, emitting the final result from the final call to your function as its sole item. *

* *

* This technique, which is called "reduce" here, is sometimec called "aggregate," "fold," "accumulate," * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method * that does a similar operation on lists. *

*
Backpressure Support:
*
This operator does not support backpressure because by intent it will receive all values and reduce * them to a single {@code onNext}.
*
Scheduler:
*
{@code reduce} does not operate by default on a particular {@link Scheduler}.
*
* * @param initialValue * the initial (seed) accumulator value * @param accumulator * an accumulator function to be invoked on each item emitted by the source Observable, the * result of which will be used in the next accumulator call * @return an Observable that emits a single item that is the result of accumulating the output from the * items emitted by the source Observable * @see RxJava wiki: reduce * @see MSDN: Observable.Aggregate * @see Wikipedia: Fold (higher-order function) */ public final Observable reduce(R initialValue, Func2 accumulator) { return scan(initialValue, accumulator).takeLast(1); } /** * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely. *

* *

*
Scheduler:
*
{@code repeat} operates by default on the {@code trampoline} {@link Scheduler}.
*
* * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence * @see RxJava wiki: repeat * @see MSDN: Observable.Repeat */ public final Observable repeat() { return OnSubscribeRedo.repeat(this); } /** * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely, * on a particular Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param scheduler * the Scheduler to emit the items on * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence * @see RxJava wiki: repeat * @see MSDN: Observable.Repeat */ public final Observable repeat(Scheduler scheduler) { return OnSubscribeRedo.repeat(this, scheduler); } /** * Returns an Observable that repeats the sequence of items emitted by the source Observable at most * {@code count} times. *

* *

*
Scheduler:
*
{@code repeat} operates by default on the {@code trampoline} {@link Scheduler}.
*
* * @param count * the number of times the source Observable items are repeated, a count of 0 will yield an empty * sequence * @return an Observable that repeats the sequence of items emitted by the source Observable at most * {@code count} times * @throws IllegalArgumentException * if {@code count} is less than zero * @see RxJava wiki: repeat * @see MSDN: Observable.Repeat */ public final Observable repeat(final long count) { return OnSubscribeRedo.repeat(this, count); } /** * Returns an Observable that repeats the sequence of items emitted by the source Observable at most * {@code count} times, on a particular Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param count * the number of times the source Observable items are repeated, a count of 0 will yield an empty * sequence * @param scheduler * the {@link Scheduler} to emit the items on * @return an Observable that repeats the sequence of items emitted by the source Observable at most * {@code count} times on a particular Scheduler * @see RxJava Wiki: repeat() * @see MSDN: Observable.Repeat */ public final Observable repeat(final long count, Scheduler scheduler) { return OnSubscribeRedo.repeat(this, count, scheduler); } /** * Returns an Observable that emits the same values as the source Observable with the exception of an * {@code onCompleted}. An {@code onCompleted} notification from the source will result in the emission of * a {@code void} item to the Observable provided as an argument to the {@code notificationHandler} * function. If that Observable calls {@code onComplete} or {@code onError} then {@code repeatWhen} will * call {@code onCompleted} or {@code onError} on the child subscription. Otherwise, this Observable will * resubscribe to the source Observable, on a particular Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param notificationHandler * receives an Observable of notifications with which a user can complete or error, aborting the repeat. * @param scheduler * the {@link Scheduler} to emit the items on * @return the source Observable modified with repeat logic * @see RxJava Wiki: repeatWhen() * @see MSDN: Observable.Repeat */ public final Observable repeatWhen(final Func1, ? extends Observable> notificationHandler, Scheduler scheduler) { Func1>, ? extends Observable> dematerializedNotificationHandler = new Func1>, Observable>() { @Override public Observable call(Observable> notifications) { return notificationHandler.call(notifications.map(new Func1, Void>() { @Override public Void call(Notification notification) { return null; } })); } }; return OnSubscribeRedo.repeat(this, dematerializedNotificationHandler, scheduler); } /** * Returns an Observable that emits the same values as the source Observable with the exception of an * {@code onCompleted}. An {@code onCompleted} notification from the source will result in the emission of * a {@code void} item to the Observable provided as an argument to the {@code notificationHandler} * function. If that Observable calls {@code onComplete} or {@code onError} then {@code repeatWhen} will * call {@code onCompleted} or {@code onError} on the child subscription. Otherwise, this Observable will * resubscribe to the source observable. *

* *

*
Scheduler:
*
{@code repeatWhen} operates by default on the {@code trampoline} {@link Scheduler}.
*
* * @param notificationHandler * receives an Observable of notifications with which a user can complete or error, aborting the repeat. * @return the source Observable modified with repeat logic * @see RxJava Wiki: repeatWhen() * @see MSDN: Observable.Repeat */ public final Observable repeatWhen(final Func1, ? extends Observable> notificationHandler) { Func1>, ? extends Observable> dematerializedNotificationHandler = new Func1>, Observable>() { @Override public Observable call(Observable> notifications) { return notificationHandler.call(notifications.map(new Func1, Void>() { @Override public Void call(Notification notification) { return null; } })); } }; return OnSubscribeRedo.repeat(this, dematerializedNotificationHandler); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the underlying Observable * that will replay all of its items and notifications to any future {@link Observer}. A Connectable * Observable resembles an ordinary Observable, except that it does not begin emitting items when it is * subscribed to, but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} does not operate by default on a particular {@link Scheduler}.
*
* * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit its * items to its {@link Observer}s * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay() { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return ReplaySubject. create(); } }); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on the items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items emitted by the resulting Observable * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @return an Observable that emits items that are the results of invoking the selector on a * {@link ConnectableObservable} that shares a single subscription to the source Observable * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector) { return create(new OnSubscribeMulticastSelector(this, new Func0>() { @Override public final Subject call() { return ReplaySubject.create(); } }, selector)); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying {@code bufferSize} notifications. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items emitted by the resulting Observable * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @param bufferSize * the buffer size that limits the number of items the connectable observable can replay * @return an Observable that emits items that are the results of invoking the selector on items emitted by * a {@link ConnectableObservable} that shares a single subscription to the source Observable * replaying no more than {@code bufferSize} items * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector, final int bufferSize) { return create(new OnSubscribeMulticastSelector(this, new Func0>() { @Override public final Subject call() { return ReplaySubject.createWithSize(bufferSize); } }, selector)); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying no more than {@code bufferSize} items that were emitted within a specified time window. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @param bufferSize * the buffer size that limits the number of items the connectable observable can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @return an Observable that emits items that are the results of invoking the selector on items emitted by * a {@link ConnectableObservable} that shares a single subscription to the source Observable, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector, int bufferSize, long time, TimeUnit unit) { return replay(selector, bufferSize, time, unit, Schedulers.computation()); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying no more than {@code bufferSize} items that were emitted within a specified time window. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @param bufferSize * the buffer size that limits the number of items the connectable observable can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler * the Scheduler that is the time source for the window * @return an Observable that emits items that are the results of invoking the selector on items emitted by * a {@link ConnectableObservable} that shares a single subscription to the source Observable, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} * @throws IllegalArgumentException * if {@code bufferSize} is less than zero * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) { if (bufferSize < 0) { throw new IllegalArgumentException("bufferSize < 0"); } return create(new OnSubscribeMulticastSelector(this, new Func0>() { @Override public final Subject call() { return ReplaySubject.createWithTimeAndSize(time, unit, bufferSize, scheduler); } }, selector)); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying a maximum of {@code bufferSize} items. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @param bufferSize * the buffer size that limits the number of items the connectable observable can replay * @param scheduler * the Scheduler on which the replay is observed * @return an Observable that emits items that are the results of invoking the selector on items emitted by * a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying no more than {@code bufferSize} notifications * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final Scheduler scheduler) { return create(new OnSubscribeMulticastSelector(this, new Func0>() { @Override public final Subject call() { return OperatorReplay. createScheduledSubject(ReplaySubject.createWithSize(bufferSize), scheduler); } }, selector)); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying all items that were emitted within a specified time window. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @return an Observable that emits items that are the results of invoking the selector on items emitted by * a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying all items that were emitted within the window defined by {@code time} * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector, long time, TimeUnit unit) { return replay(selector, time, unit, Schedulers.computation()); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying all items that were emitted within a specified time window. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler * the scheduler that is the time source for the window * @return an Observable that emits items that are the results of invoking the selector on items emitted by * a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying all items that were emitted within the window defined by {@code time} * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector, final long time, final TimeUnit unit, final Scheduler scheduler) { return create(new OnSubscribeMulticastSelector(this, new Func0>() { @Override public final Subject call() { return ReplaySubject.createWithTime(time, unit, scheduler); } }, selector)); } /** * Returns an Observable that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param * the type of items emitted by the resulting Observable * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without * causing multiple subscriptions to the Observable * @param scheduler * the Scheduler where the replay is observed * @return an Observable that emits items that are the results of invoking the selector on items emitted by * a {@link ConnectableObservable} that shares a single subscription to the source Observable, * replaying all items * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final Observable replay(Func1, ? extends Observable> selector, final Scheduler scheduler) { return create(new OnSubscribeMulticastSelector(this, new Func0>() { @Override public final Subject call() { return OperatorReplay.createScheduledSubject(ReplaySubject. create(), scheduler); } }, selector)); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable that * replays at most {@code bufferSize} items emitted by that Observable. A Connectable Observable resembles * an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only * when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} does not operate by default on a particular {@link Scheduler}.
*
* * @param bufferSize * the buffer size that limits the number of items that can be replayed * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays at most {@code bufferSize} items emitted by that Observable * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay(final int bufferSize) { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return ReplaySubject.createWithSize(bufferSize); } }); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays at most {@code bufferSize} items that were emitted during a specified time window. A Connectable * Observable resembles an ordinary Observable, except that it does not begin emitting items when it is * subscribed to, but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param bufferSize * the buffer size that limits the number of items that can be replayed * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) { return replay(bufferSize, time, unit, Schedulers.computation()); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and * that replays a maximum of {@code bufferSize} items that are emitted within a specified time window. A * Connectable Observable resembles an ordinary Observable, except that it does not begin emitting items * when it is subscribed to, but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param bufferSize * the buffer size that limits the number of items that can be replayed * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler * the scheduler that is used as a time source for the window * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} * @throws IllegalArgumentException * if {@code bufferSize} is less than zero * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay(final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) { if (bufferSize < 0) { throw new IllegalArgumentException("bufferSize < 0"); } return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return ReplaySubject.createWithTimeAndSize(time, unit, bufferSize, scheduler); } }); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays at most {@code bufferSize} items emitted by that Observable. A Connectable Observable resembles * an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only * when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param bufferSize * the buffer size that limits the number of items that can be replayed * @param scheduler * the scheduler on which the Observers will observe the emitted items * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays at most {@code bufferSize} items that were emitted by the Observable * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay(final int bufferSize, final Scheduler scheduler) { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return OperatorReplay.createScheduledSubject(ReplaySubject.createWithSize(bufferSize), scheduler); } }); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays all items emitted by that Observable within a specified time window. A Connectable Observable * resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays the items that were emitted during the window defined by {@code time} * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay(long time, TimeUnit unit) { return replay(time, unit, Schedulers.computation()); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays all items emitted by that Observable within a specified time window. A Connectable Observable * resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler * the Scheduler that is the time source for the window * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and * replays the items that were emitted during the window defined by {@code time} * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay(final long time, final TimeUnit unit, final Scheduler scheduler) { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return ReplaySubject.createWithTime(time, unit, scheduler); } }); } /** * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable that * will replay all of its items and notifications to any future {@link Observer} on the given * {@link Scheduler}. A Connectable Observable resembles an ordinary Observable, except that it does not * begin emitting items when it is subscribed to, but only when its {@code connect} method is called. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param scheduler * the Scheduler on which the Observers will observe the emitted items * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable that * will replay all of its items and notifications to any future {@link Observer} on the given * {@link Scheduler} * @see RxJava wiki: replay * @see MSDN: Observable.Replay */ public final ConnectableObservable replay(final Scheduler scheduler) { return new OperatorMulticast(this, new Func0>() { @Override public Subject call() { return OperatorReplay.createScheduledSubject(ReplaySubject. create(), scheduler); } }); } /** * Returns an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} * (infinite retry count). *

* *

* If the source Observable calls {@link Observer#onError}, this method will resubscribe to the source * Observable rather than propagating the {@code onError} call. *

* Any and all items emitted by the source Observable will be emitted by the resulting Observable, even * those emitted during failed subscriptions. For example, if an Observable fails at first but emits * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}. *

*
Scheduler:
*
{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.
*
* * @return the source Observable modified with retry logic * @see RxJava wiki: retry * @see MSDN: Observable.Retry */ public final Observable retry() { return OnSubscribeRedo.retry(this); } /** * Returns an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} * up to a specified number of retries. *

* *

* If the source Observable calls {@link Observer#onError}, this method will resubscribe to the source * Observable for a maximum of {@code count} resubscriptions rather than propagating the * {@code onError} call. *

* Any and all items emitted by the source Observable will be emitted by the resulting Observable, even * those emitted during failed subscriptions. For example, if an Observable fails at first but emits * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}. *

*
Scheduler:
*
{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.
*
* * @param count * number of retry attempts before failing * @return the source Observable modified with retry logic * @see RxJava wiki: retry * @see MSDN: Observable.Retry */ public final Observable retry(final long count) { return OnSubscribeRedo.retry(this, count); } /** * Returns an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} * and the predicate returns true for that specific exception and retry count. *

* *

*
Scheduler:
*
{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.
*
* * @param predicate * the predicate that determines if a resubscription may happen in case of a specific exception * and retry count * @return the source Observable modified with retry logic * @see #retry() * @see RxJava Wiki: retry() */ public final Observable retry(Func2 predicate) { return nest().lift(new OperatorRetryWithPredicate(predicate)); } /** * Returns an Observable that emits the same values as the source observable with the exception of an * {@code onError}. An {@code onError} notification from the source will result in the emission of a * {@link Throwable} item to the Observable provided as an argument to the {@code notificationHandler} * function. If that Observable calls {@code onComplete} or {@code onError} then {@code retry} will call * {@code onCompleted} or {@code onError} on the child subscription. Otherwise, this Observable will * resubscribe to the source Observable. *

* * * Example: * * This retries 3 times, each time incrementing the number of seconds it waits. * * 

 {@code
     *  Observable.create((Subscriber s) -> {
     *      System.out.println("subscribing");
     *      s.onError(new RuntimeException("always fails"));
     *  }).retryWhen(attempts -> {
     *      return attempts.zipWith(Observable.range(1, 3), (n, i) -> i).flatMap(i -> {
     *          System.out.println("delay retry by " + i + " second(s)");
     *          return Observable.timer(i, TimeUnit.SECONDS);
     *      });
     *  }).toBlocking().forEach(System.out::println);
     * }
* * Output is: * * 
 {@code
     * subscribing
     * delay retry by 1 second(s)
     * subscribing
     * delay retry by 2 second(s)
     * subscribing
     * delay retry by 3 second(s)
     * subscribing
     * }
*
*
Scheduler:
*
{@code retryWhen} operates by default on the {@code trampoline} {@link Scheduler}.
*
* * @param notificationHandler * receives an Observable of notifications with which a user can complete or error, aborting the * retry * @return the source Observable modified with retry logic * @see RxJava Wiki: retryWhen() */ public final Observable retryWhen(final Func1, ? extends Observable> notificationHandler) { Func1>, ? extends Observable> dematerializedNotificationHandler = new Func1>, Observable>() { @Override public Observable call(Observable> notifications) { return notificationHandler.call(notifications.map(new Func1, Throwable>() { @Override public Throwable call(Notification notification) { return notification.getThrowable(); } })); } }; return OnSubscribeRedo. retry(this, dematerializedNotificationHandler); } /** * Returns an Observable that emits the same values as the source observable with the exception of an * {@code onError}. An {@code onError} will cause the emission of the {@link Throwable} that cause the * error to the Observable returned from {@code notificationHandler}. If that Observable calls * {@code onComplete} or {@code onError} then {@code retry} will call {@code onCompleted} or {@code onError} * on the child subscription. Otherwise, this Observable will resubscribe to the source observable, on a * particular Scheduler. *

* *

*

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param notificationHandler * receives an Observable of notifications with which a user can complete or error, aborting the * retry * @param scheduler * the {@link Scheduler} on which to subscribe to the source Observable * @return the source Observable modified with retry logic * @see RxJava Wiki: retryWhen() */ public final Observable retryWhen(final Func1, ? extends Observable> notificationHandler, Scheduler scheduler) { Func1>, ? extends Observable> dematerializedNotificationHandler = new Func1>, Observable>() { @Override public Observable call(Observable> notifications) { return notificationHandler.call(notifications.map(new Func1, Throwable>() { @Override public Throwable call(Notification notification) { return notification.getThrowable(); } })); } }; return OnSubscribeRedo. retry(this, dematerializedNotificationHandler, scheduler); } /** * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable * within periodic time intervals. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
{@code sample} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param period * the sampling rate * @param unit * the {@link TimeUnit} in which {@code period} is defined * @return an Observable that emits the results of sampling the items emitted by the source Observable at * the specified time interval * @see RxJava wiki: sample * @see RxJava wiki: Backpressure * @see MSDN: Observable.Sample * @see #throttleLast(long, TimeUnit) */ public final Observable sample(long period, TimeUnit unit) { return sample(period, unit, Schedulers.computation()); } /** * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable * within periodic time intervals, where the intervals are defined on a particular Scheduler. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param period * the sampling rate * @param unit * the {@link TimeUnit} in which {@code period} is defined * @param scheduler * the {@link Scheduler} to use when sampling * @return an Observable that emits the results of sampling the items emitted by the source Observable at * the specified time interval * @see RxJava wiki: sample * @see RxJava wiki: Backpressure * @see MSDN: Observable.Sample * @see #throttleLast(long, TimeUnit, Scheduler) */ public final Observable sample(long period, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorSampleWithTime(period, unit, scheduler)); } /** * Returns an Observable that, when the specified {@code sampler} Observable emits an item or completes, * emits the most recently emitted item (if any) emitted by the source Observable since the previous * emission from the {@code sampler} Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses the emissions of the {@code sampler} * Observable to control data flow.
*
Scheduler:
*
This version of {@code sample} does not operate by default on a particular {@link Scheduler}.
*
* * @param sampler * the Observable to use for sampling the source Observable * @return an Observable that emits the results of sampling the items emitted by this Observable whenever * the {@code sampler} Observable emits an item or completes * @see RxJava wiki: sample * @see RxJava wiki: Backpressure * @see MSDN: Observable.Sample */ public final Observable sample(Observable sampler) { return lift(new OperatorSampleWithObservable(sampler)); } /** * Returns an Observable that applies a function of your choosing to the first item emitted by a source * Observable, then feeds the result of that function along with the second item emitted by the source * Observable into the same function, and so on until all items have been emitted by the source Observable, * emitting the result of each of these iterations. *

* *

* This sort of function is sometimes called an accumulator. *

*
Scheduler:
*
{@code scan} does not operate by default on a particular {@link Scheduler}.
*
* * @param accumulator * an accumulator function to be invoked on each item emitted by the source Observable, whose * result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the * next accumulator call * @return an Observable that emits the results of each call to the accumulator function * @see RxJava wiki: scan * @see MSDN: Observable.Scan */ public final Observable scan(Func2 accumulator) { return lift(new OperatorScan(accumulator)); } /** * Returns an Observable that applies a function of your choosing to the first item emitted by a source * Observable and a seed value, then feeds the result of that function along with the second item emitted by * the source Observable into the same function, and so on until all items have been emitted by the source * Observable, emitting the result of each of these iterations. *

* *

* This sort of function is sometimes called an accumulator. *

* Note that the Observable that results from this method will emit {@code initialValue} as its first * emitted item. *

*
Scheduler:
*
{@code scan} does not operate by default on a particular {@link Scheduler}.
*
* * @param initialValue * the initial (seed) accumulator item * @param accumulator * an accumulator function to be invoked on each item emitted by the source Observable, whose * result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the * next accumulator call * @return an Observable that emits {@code initialValue} followed by the results of each call to the * accumulator function * @see RxJava wiki: scan * @see MSDN: Observable.Scan */ public final Observable scan(R initialValue, Func2 accumulator) { return lift(new OperatorScan(initialValue, accumulator)); } /** * Forces an Observable's emissions and notifications to be serialized and for it to obey the Rx contract * in other ways. *

* It is possible for an Observable to invoke its Subscribers' methods asynchronously, perhaps from * different threads. This could make such an Observable poorly-behaved, in that it might try to invoke * {@code onCompleted} or {@code onError} before one of its {@code onNext} invocations, or it might call * {@code onNext} from two different threads concurrently. You can force such an Observable to be * well-behaved and sequential by applying the {@code serialize} method to it. *

* *

*
Scheduler:
*
{@code serialize} does not operate by default on a particular {@link Scheduler}.
*
* * @return an {@link Observable} that is guaranteed to be well-behaved and to make only serialized calls to * its observers * @see RxJava wiki: serialize * @see MSDN: Observable.Synchronize */ public final Observable serialize() { return lift(new OperatorSerialize()); } /** * Returns a new {@link Observable} that multicasts (shares) the original {@link Observable}. As long as * there is more than one {@link Subscriber} this {@link Observable} will be subscribed and emitting data. * When all subscribers have unsubscribed it will unsubscribe from the source {@link Observable}. *

* This is an alias for {@link #publish()}.{@link ConnectableObservable#refCount()}. *

* *

*
Backpressure Support:
*
This operator does not support backpressure because multicasting means the stream is "hot" with * multiple subscribers. Each child will need to manage backpressure independently using operators such * as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.
*
Scheduler:
*
{@code share} does not operate by default on a particular {@link Scheduler}.
*
* * @return an {@code Observable} that upon connection causes the source {@code Observable} to emit items * to its {@link Observer}s * @see RxJava wiki: refCount */ public final Observable share() { return publish().refCount(); } /** * Returns an Observable that emits the single item emitted by the source Observable, if that Observable * emits only a single item. If the source Observable emits more than one item or no items, notify of an * {@code IllegalArgumentException} or {@code NoSuchElementException} respectively. *

* *

*
Scheduler:
*
{@code single} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits the single item emitted by the source Observable * @throws IllegalArgumentException * if the source emits more than one item * @throws NoSuchElementException * if the source emits no items * @see RxJava wiki: single * @see "MSDN: Observable.singleAsync" */ public final Observable single() { return lift(new OperatorSingle()); } /** * Returns an Observable that emits the single item emitted by the source Observable that matches a * specified predicate, if that Observable emits one such item. If the source Observable emits more than one * such item or no such items, notify of an {@code IllegalArgumentException} or * {@code NoSuchElementException} respectively. *

* *

*
Scheduler:
*
{@code single} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * a predicate function to evaluate items emitted by the source Observable * @return an Observable that emits the single item emitted by the source Observable that matches the * predicate * @throws IllegalArgumentException * if the source Observable emits more than one item that matches the predicate * @throws NoSuchElementException * if the source Observable emits no item that matches the predicate * @see RxJava wiki: single * @see "MSDN: Observable.singleAsync" */ public final Observable single(Func1 predicate) { return filter(predicate).single(); } /** * Returns an Observable that emits the single item emitted by the source Observable, if that Observable * emits only a single item, or a default item if the source Observable emits no items. If the source * Observable emits more than one item, throw an {@code IllegalArgumentException}. *

* *

*
Scheduler:
*
{@code singleOrDefault} does not operate by default on a particular {@link Scheduler}.
*
* * @param defaultValue * a default value to emit if the source Observable emits no item * @return an Observable that emits the single item emitted by the source Observable, or a default item if * the source Observable is empty * @throws IllegalArgumentException * if the source Observable emits more than one item * @see RxJava wiki: single * @see "MSDN: Observable.singleOrDefaultAsync" */ public final Observable singleOrDefault(T defaultValue) { return lift(new OperatorSingle(defaultValue)); } /** * Returns an Observable that emits the single item emitted by the source Observable that matches a * predicate, if that Observable emits only one such item, or a default item if the source Observable emits * no such items. If the source Observable emits more than one such item, throw an * {@code IllegalArgumentException}. *

* *

*
Scheduler:
*
{@code singleOrDefault} does not operate by default on a particular {@link Scheduler}.
*
* * @param defaultValue * a default item to emit if the source Observable emits no matching items * @param predicate * a predicate function to evaluate items emitted by the source Observable * @return an Observable that emits the single item emitted by the source Observable that matches the * predicate, or the default item if no emitted item matches the predicate * @throws IllegalArgumentException * if the source Observable emits more than one item that matches the predicate * @see RxJava wiki: single * @see "MSDN: Observable.singleOrDefaultAsync" */ public final Observable singleOrDefault(T defaultValue, Func1 predicate) { return filter(predicate).singleOrDefault(defaultValue); } /** * Returns an Observable that skips the first {@code num} items emitted by the source Observable and emits * the remainder. *

* *

*
Scheduler:
*
This version of {@code skip} does not operate by default on a particular {@link Scheduler}.
*
* * @param num * the number of items to skip * @return an Observable that is identical to the source Observable except that it does not emit the first * {@code num} items that the source Observable emits * @see RxJava wiki: skip * @see MSDN: Observable.skip */ public final Observable skip(int num) { return lift(new OperatorSkip(num)); } /** * Returns an Observable that skips values emitted by the source Observable before a specified time window * elapses. *

* *

*
Scheduler:
*
This version of {@code skip} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param time * the length of the time window to skip * @param unit * the time unit of {@code time} * @return an Observable that skips values emitted by the source Observable before the time window defined * by {@code time} elapses and the emits the remainder * @see RxJava wiki: skip * @see MSDN: Observable.skip */ public final Observable skip(long time, TimeUnit unit) { return skip(time, unit, Schedulers.computation()); } /** * Returns an Observable that skips values emitted by the source Observable before a specified time window * on a specified {@link Scheduler} elapses. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param time * the length of the time window to skip * @param unit * the time unit of {@code time} * @param scheduler * the {@link Scheduler} on which the timed wait happens * @return an Observable that skips values emitted by the source Observable before the time window defined * by {@code time} and {@code scheduler} elapses, and then emits the remainder * @see RxJava wiki: skip * @see MSDN: Observable.skip */ public final Observable skip(long time, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorSkipTimed(time, unit, scheduler)); } /** * Returns an Observable that drops a specified number of items from the end of the sequence emitted by the * source Observable. *

* *

* This Observer accumulates a queue long enough to store the first {@code count} items. As more items are * received, items are taken from the front of the queue and emitted by the returned Observable. This causes * such items to be delayed. *

*
Scheduler:
*
This version of {@code skipLast} does not operate by default on a particular {@link Scheduler}.
*
* * @param count * number of items to drop from the end of the source sequence * @return an Observable that emits the items emitted by the source Observable except for the dropped ones * at the end * @throws IndexOutOfBoundsException * if {@code count} is less than zero * @see RxJava wiki: skipLast * @see MSDN: Observable.SkipLast */ public final Observable skipLast(int count) { return lift(new OperatorSkipLast(count)); } /** * Returns an Observable that drops items emitted by the source Observable during a specified time window * before the source completes. *

* *

* Note: this action will cache the latest items arriving in the specified time window. *

*
Scheduler:
*
This version of {@code skipLast} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @return an Observable that drops those items emitted by the source Observable in a time window before the * source completes defined by {@code time} * @see RxJava wiki: skipLast * @see MSDN: Observable.SkipLast */ public final Observable skipLast(long time, TimeUnit unit) { return skipLast(time, unit, Schedulers.computation()); } /** * Returns an Observable that drops items emitted by the source Observable during a specified time window * (defined on a specified scheduler) before the source completes. *

* *

* Note: this action will cache the latest items arriving in the specified time window. *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @param scheduler * the scheduler used as the time source * @return an Observable that drops those items emitted by the source Observable in a time window before the * source completes defined by {@code time} and {@code scheduler} * @see RxJava wiki: skipLast * @see MSDN: Observable.SkipLast */ public final Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorSkipLastTimed(time, unit, scheduler)); } /** * Returns an Observable that skips items emitted by the source Observable until a second Observable emits * an item. *

* *

*
Scheduler:
*
{@code skipUntil} does not operate by default on a particular {@link Scheduler}.
*
* * @param other * the second Observable that has to emit an item before the source Observable's elements begin * to be mirrored by the resulting Observable * @return an Observable that skips items from the source Observable until the second Observable emits an * item, then emits the remaining items * @see RxJava wiki: skipUntil * @see MSDN: Observable.SkipUntil */ public final Observable skipUntil(Observable other) { return lift(new OperatorSkipUntil(other)); } /** * Returns an Observable that skips all items emitted by the source Observable as long as a specified * condition holds true, but emits all further source items as soon as the condition becomes false. *

* *

*
Scheduler:
*
{@code skipWhile} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * a function to test each item emitted from the source Observable * @return an Observable that begins emitting items emitted by the source Observable when the specified * predicate becomes false * @see RxJava wiki: skipWhile * @see MSDN: Observable.SkipWhile */ public final Observable skipWhile(Func1 predicate) { return lift(new OperatorSkipWhile(OperatorSkipWhile.toPredicate2(predicate))); } /** * Returns an Observable that skips all items emitted by the source Observable as long as a specified * condition holds true, but emits all further source items as soon as the condition becomes false. *

* *

*
Scheduler:
*
{@code skipWhileWithIndex} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * a function to test each item emitted from the source Observable. It takes the emitted item as * the first parameter and the sequential index of the emitted item as a second parameter. * @return an Observable that begins emitting items emitted by the source Observable when the specified * predicate becomes false * @see RxJava wiki: skipWhileWithIndex * @see MSDN: Observable.SkipWhile */ public final Observable skipWhileWithIndex(Func2 predicate) { return lift(new OperatorSkipWhile(predicate)); } /** * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit * items emitted by the source Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param values * an Observable that contains the items you want the modified Observable to emit first * @return an Observable that emits the items in the specified {@link Observable} and then emits the items * emitted by the source Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(Observable values) { return concat(values, this); } /** * Returns an Observable that emits the items in a specified {@link Iterable} before it begins to emit items * emitted by the source Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param values * an Iterable that contains the items you want the modified Observable to emit first * @return an Observable that emits the items in the specified {@link Iterable} and then emits the items * emitted by the source Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(Iterable values) { return concat(Observable. from(values), this); } /** * Returns an Observable that emits a specified item before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the item to emit * @return an Observable that emits the specified item before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1) { return concat(just(t1), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @return an Observable that emits the specified items before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2) { return concat(just(t1, t2), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @param t3 * the third item to emit * @return an Observable that emits the specified items before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2, T t3) { return concat(just(t1, t2, t3), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @param t3 * the third item to emit * @param t4 * the fourth item to emit * @return an Observable that emits the specified items before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2, T t3, T t4) { return concat(just(t1, t2, t3, t4), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @param t3 * the third item to emit * @param t4 * the fourth item to emit * @param t5 * the fifth item to emit * @return an Observable that emits the specified items before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2, T t3, T t4, T t5) { return concat(just(t1, t2, t3, t4, t5), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @param t3 * the third item to emit * @param t4 * the fourth item to emit * @param t5 * the fifth item to emit * @param t6 * the sixth item to emit * @return an Observable that emits the specified items before it begins to emit items emitted * by the source Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6) { return concat(just(t1, t2, t3, t4, t5, t6), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @param t3 * the third item to emit * @param t4 * the fourth item to emit * @param t5 * the fifth item to emit * @param t6 * the sixth item to emit * @param t7 * the seventh item to emit * @return an Observable that emits the specified items before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) { return concat(just(t1, t2, t3, t4, t5, t6, t7), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @param t3 * the third item to emit * @param t4 * the fourth item to emit * @param t5 * the fifth item to emit * @param t6 * the sixth item to emit * @param t7 * the seventh item to emit * @param t8 * the eighth item to emit * @return an Observable that emits the specified items before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) { return concat(just(t1, t2, t3, t4, t5, t6, t7, t8), this); } /** * Returns an Observable that emits the specified items before it begins to emit items emitted by the source * Observable. *

* *

*
Scheduler:
*
{@code startWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param t1 * the first item to emit * @param t2 * the second item to emit * @param t3 * the third item to emit * @param t4 * the fourth item to emit * @param t5 * the fifth item to emit * @param t6 * the sixth item to emit * @param t7 * the seventh item to emit * @param t8 * the eighth item to emit * @param t9 * the ninth item to emit * @return an Observable that emits the specified items before it begins to emit items emitted by the source * Observable * @see RxJava wiki: startWith * @see MSDN: Observable.StartWith */ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) { return concat(just(t1, t2, t3, t4, t5, t6, t7, t8, t9), this); } /** * Subscribes to an Observable but ignore its emissions and notifications. *
*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before * the Observable has finished sending them * @throws OnErrorNotImplementedException * if the Observable tries to call {@code onError} */ public final Subscription subscribe() { return subscribe(new Subscriber() { @Override public final void onCompleted() { // do nothing } @Override public final void onError(Throwable e) { throw new OnErrorNotImplementedException(e); } @Override public final void onNext(T args) { // do nothing } }); } /** * Subscribes to an Observable and provides a callback to handle the items it emits. *
*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext * the {@code Action1} you have designed to accept emissions from the Observable * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before * the Observable has finished sending them * @throws IllegalArgumentException * if {@code onNext} is null * @throws OnErrorNotImplementedException * if the Observable tries to call {@code onError} * @see RxJava wiki: onNext, onCompleted, and onError */ public final Subscription subscribe(final Action1 onNext) { if (onNext == null) { throw new IllegalArgumentException("onNext can not be null"); } return subscribe(new Subscriber() { @Override public final void onCompleted() { // do nothing } @Override public final void onError(Throwable e) { throw new OnErrorNotImplementedException(e); } @Override public final void onNext(T args) { onNext.call(args); } }); } /** * Subscribes to an Observable and provides callbacks to handle the items it emits and any error * notification it issues. *
*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext * the {@code Action1} you have designed to accept emissions from the Observable * @param onError * the {@code Action1} you have designed to accept any error notification from the * Observable * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before * the Observable has finished sending them * @see RxJava wiki: onNext, onCompleted, and onError * @throws IllegalArgumentException * if {@code onNext} is null, or * if {@code onError} is null */ public final Subscription subscribe(final Action1 onNext, final Action1 onError) { if (onNext == null) { throw new IllegalArgumentException("onNext can not be null"); } if (onError == null) { throw new IllegalArgumentException("onError can not be null"); } return subscribe(new Subscriber() { @Override public final void onCompleted() { // do nothing } @Override public final void onError(Throwable e) { onError.call(e); } @Override public final void onNext(T args) { onNext.call(args); } }); } /** * Subscribes to an Observable and provides callbacks to handle the items it emits and any error or * completion notification it issues. *
*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext * the {@code Action1} you have designed to accept emissions from the Observable * @param onError * the {@code Action1} you have designed to accept any error notification from the * Observable * @param onComplete * the {@code Action0} you have designed to accept a completion notification from the * Observable * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before * the Observable has finished sending them * @throws IllegalArgumentException * if {@code onNext} is null, or * if {@code onError} is null, or * if {@code onComplete} is null * @see RxJava wiki: onNext, onCompleted, and onError */ public final Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete) { if (onNext == null) { throw new IllegalArgumentException("onNext can not be null"); } if (onError == null) { throw new IllegalArgumentException("onError can not be null"); } if (onComplete == null) { throw new IllegalArgumentException("onComplete can not be null"); } return subscribe(new Subscriber() { @Override public final void onCompleted() { onComplete.call(); } @Override public final void onError(Throwable e) { onError.call(e); } @Override public final void onNext(T args) { onNext.call(args); } }); } /** * Subscribes to an Observable and provides an Observer that implements functions to handle the items the * Observable emits and any error or completion notification it issues. *
*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param observer * the Observer that will handle emissions and notifications from the Observable * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before * the Observable has completed * @see RxJava wiki: onNext, onCompleted, and onError */ public final Subscription subscribe(final Observer observer) { return subscribe(new Subscriber() { @Override public void onCompleted() { observer.onCompleted(); } @Override public void onError(Throwable e) { observer.onError(e); } @Override public void onNext(T t) { observer.onNext(t); } }); } /** * Subscribes to an Observable and invokes {@link OnSubscribe} function without any contract protection, * error handling, unsubscribe, or execution hooks. *

* Use this only for implementing an {@link Operator} that requires nested subscriptions. For other * purposes, use {@link #subscribe(Subscriber)} which ensures the Rx contract and other functionality. *

*
Scheduler:
*
{@code unsafeSubscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param subscriber * the Subscriber that will handle emissions and notifications from the Observable * @return a {@link Subscription} reference with which the {@link Subscriber} can stop receiving items * before the Observable has completed */ public final Subscription unsafeSubscribe(Subscriber subscriber) { try { // new Subscriber so onStart it subscriber.onStart(); // allow the hook to intercept and/or decorate hook.onSubscribeStart(this, onSubscribe).call(subscriber); return hook.onSubscribeReturn(subscriber); } catch (Throwable e) { // special handling for certain Throwable/Error/Exception types Exceptions.throwIfFatal(e); // if an unhandled error occurs executing the onSubscribe we will propagate it try { subscriber.onError(hook.onSubscribeError(e)); } catch (OnErrorNotImplementedException e2) { // special handling when onError is not implemented ... we just rethrow throw e2; } catch (Throwable e2) { // if this happens it means the onError itself failed (perhaps an invalid function implementation) // so we are unable to propagate the error correctly and will just throw RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2); // TODO could the hook be the cause of the error in the on error handling. hook.onSubscribeError(r); // TODO why aren't we throwing the hook's return value. throw r; } return Subscriptions.empty(); } } /** * Subscribes to an Observable and provides a Subscriber that implements functions to handle the items the * Observable emits and any error or completion notification it issues. *

* A typical implementation of {@code subscribe} does the following: *

    *
  1. It stores a reference to the Subscriber in a collection object, such as a {@code List} object.
    2. *
  2. It returns a reference to the {@link Subscription} interface. This enables Subscribers to * unsubscribe, that is, to stop receiving items and notifications before the Observable completes, which * also invokes the Subscriber's {@link Subscriber#onCompleted onCompleted} method.
    3. *

* An {@code Observable} instance is responsible for accepting all subscriptions and notifying all * Subscribers. Unless the documentation for a particular {@code Observable} implementation indicates * otherwise, Subscriber should make no assumptions about the order in which multiple Subscribers will * receive their notifications. *

* For more information see the * RxJava wiki. *

*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param subscriber * the {@link Subscriber} that will handle emissions and notifications from the Observable * @return a {@link Subscription} reference with which Subscribers that are {@link Observer}s can * unsubscribe from the Observable * @throws IllegalStateException * if {@code subscribe} is unable to obtain an {@code OnSubscribe<>} function * @throws IllegalArgumentException * if the {@link Subscriber} provided as the argument to {@code subscribe} is {@code null} * @throws OnErrorNotImplementedException * if the {@link Subscriber}'s {@code onError} method is null * @throws RuntimeException * if the {@link Subscriber}'s {@code onError} method itself threw a {@code Throwable} */ public final Subscription subscribe(Subscriber subscriber) { // validate and proceed if (subscriber == null) { throw new IllegalArgumentException("observer can not be null"); } if (onSubscribe == null) { throw new IllegalStateException("onSubscribe function can not be null."); /* * the subscribe function can also be overridden but generally that's not the appropriate approach * so I won't mention that in the exception */ } // new Subscriber so onStart it subscriber.onStart(); /* * See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls * to user code from within an Observer" */ // if not already wrapped if (!(subscriber instanceof SafeSubscriber)) { // assign to `observer` so we return the protected version subscriber = new SafeSubscriber(subscriber); } // The code below is exactly the same an unsafeSubscribe but not used because it would add a sigificent depth to alreay huge call stacks. try { // allow the hook to intercept and/or decorate hook.onSubscribeStart(this, onSubscribe).call(subscriber); return hook.onSubscribeReturn(subscriber); } catch (Throwable e) { // special handling for certain Throwable/Error/Exception types Exceptions.throwIfFatal(e); // if an unhandled error occurs executing the onSubscribe we will propagate it try { subscriber.onError(hook.onSubscribeError(e)); } catch (OnErrorNotImplementedException e2) { // special handling when onError is not implemented ... we just rethrow throw e2; } catch (Throwable e2) { // if this happens it means the onError itself failed (perhaps an invalid function implementation) // so we are unable to propagate the error correctly and will just throw RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2); // TODO could the hook be the cause of the error in the on error handling. hook.onSubscribeError(r); // TODO why aren't we throwing the hook's return value. throw r; } return Subscriptions.empty(); } } /** * Asynchronously subscribes Observers to this Observable on the specified {@link Scheduler}. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param scheduler * the {@link Scheduler} to perform subscription actions on * @return the source Observable modified so that its subscriptions happen on the * specified {@link Scheduler} * @see RxJava wiki: subscribeOn * @see RxJava Threading Examples * @see #observeOn */ public final Observable subscribeOn(Scheduler scheduler) { return nest().lift(new OperatorSubscribeOn(scheduler)); } /** * Returns a new Observable by applying a function that you supply to each item emitted by the source * Observable that returns an Observable, and then emitting the items emitted by the most recently emitted * of these Observables. *

* *

*
Scheduler:
*
{@code switchMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param func * a function that, when applied to an item emitted by the source Observable, returns an * Observable * @return an Observable that emits the items emitted by the Observable returned from applying {@code func} to the most recently emitted item emitted by the source Observable * @see RxJava wiki: switchMap */ public final Observable switchMap(Func1> func) { return switchOnNext(map(func)); } /** * Returns an Observable that emits only the first {@code num} items emitted by the source Observable. *

* *

* This method returns an Observable that will invoke a subscribing {@link Observer}'s * {@link Observer#onNext onNext} function a maximum of {@code num} times before invoking * {@link Observer#onCompleted onCompleted}. *

*
Scheduler:
*
This version of {@code take} does not operate by default on a particular {@link Scheduler}.
*
* * @param num * the maximum number of items to emit * @return an Observable that emits only the first {@code num} items emitted by the source Observable, or * all of the items from the source Observable if that Observable emits fewer than {@code num} items * @see RxJava wiki: take * @see MSDN: Observable.Take */ public final Observable take(final int num) { return lift(new OperatorTake(num)); } /** * Returns an Observable that emits those items emitted by source Observable before a specified time runs * out. *

* *

*
Scheduler:
*
This version of {@code take} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @return an Observable that emits those items emitted by the source Observable before the time runs out * @see RxJava wiki: take */ public final Observable take(long time, TimeUnit unit) { return take(time, unit, Schedulers.computation()); } /** * Returns an Observable that emits those items emitted by source Observable before a specified time (on a * specified Scheduler) runs out. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @param scheduler * the Scheduler used for time source * @return an Observable that emits those items emitted by the source Observable before the time runs out, * according to the specified Scheduler * @see RxJava wiki: take */ public final Observable take(long time, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorTakeTimed(time, unit, scheduler)); } /** * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies * a specified condition. *

* *

*
Scheduler:
*
{@code takeFirst} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * the condition any item emitted by the source Observable has to satisfy * @return an Observable that emits only the very first item emitted by the source Observable that satisfies * the given condition, or that completes without emitting anything if the source Observable * completes without emitting a single condition-satisfying item * @see RxJava wiki: takeFirst * @see "MSDN: Observable.firstAsync" */ public final Observable takeFirst(Func1 predicate) { return filter(predicate).take(1); } /** * Returns an Observable that emits only the last {@code count} items emitted by the source Observable. *

* *

*
Scheduler:
*
This version of {@code takeLast} does not operate by default on a particular {@link Scheduler}.
*
* * @param count * the number of items to emit from the end of the sequence of items emitted by the source * Observable * @return an Observable that emits only the last {@code count} items emitted by the source Observable * @throws IndexOutOfBoundsException * if {@code count} is less than zero * @see RxJava wiki: takeLast * @see MSDN: Observable.TakeLast */ public final Observable takeLast(final int count) { return lift(new OperatorTakeLast(count)); } /** * Returns an Observable that emits at most a specified number of items from the source Observable that were * emitted in a specified window of time before the Observable completed. *

* *

*
Scheduler:
*
This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param count * the maximum number of items to emit * @param time * the length of the time window * @param unit * the time unit of {@code time} * @return an Observable that emits at most {@code count} items from the source Observable that were emitted * in a specified window of time before the Observable completed * @see RxJava wiki: takeLast * @see MSDN: Observable.TakeLast */ public final Observable takeLast(int count, long time, TimeUnit unit) { return takeLast(count, time, unit, Schedulers.computation()); } /** * Returns an Observable that emits at most a specified number of items from the source Observable that were * emitted in a specified window of time before the Observable completed, where the timing information is * provided by a given Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param count * the maximum number of items to emit * @param time * the length of the time window * @param unit * the time unit of {@code time} * @param scheduler * the {@link Scheduler} that provides the timestamps for the observed items * @return an Observable that emits at most {@code count} items from the source Observable that were emitted * in a specified window of time before the Observable completed, where the timing information is * provided by the given {@code scheduler} * @throws IndexOutOfBoundsException * if {@code count} is less than zero * @see RxJava wiki: takeLast * @see MSDN: Observable.TakeLast */ public final Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorTakeLastTimed(count, time, unit, scheduler)); } /** * Returns an Observable that emits the items from the source Observable that were emitted in a specified * window of time before the Observable completed. *

* *

*
Scheduler:
*
This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @return an Observable that emits the items from the source Observable that were emitted in the window of * time before the Observable completed specified by {@code time} * @see RxJava wiki: takeLast * @see MSDN: Observable.TakeLast */ public final Observable takeLast(long time, TimeUnit unit) { return takeLast(time, unit, Schedulers.computation()); } /** * Returns an Observable that emits the items from the source Observable that were emitted in a specified * window of time before the Observable completed, where the timing information is provided by a specified * Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @param scheduler * the Scheduler that provides the timestamps for the Observed items * @return an Observable that emits the items from the source Observable that were emitted in the window of * time before the Observable completed specified by {@code time}, where the timing information is * provided by {@code scheduler} * @see RxJava wiki: takeLast * @see MSDN: Observable.TakeLast */ public final Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorTakeLastTimed(time, unit, scheduler)); } /** * Returns an Observable that emits a single List containing the last {@code count} elements emitted by the * source Observable. *

* *

*
Scheduler:
*
This version of {@code takeLastBuffer} does not operate by default on a particular {@link Scheduler}.
*
* * @param count * the number of items to emit in the list * @return an Observable that emits a single list containing the last {@code count} elements emitted by the * source Observable * @see RxJava wiki: takeLastBuffer */ public final Observable> takeLastBuffer(int count) { return takeLast(count).toList(); } /** * Returns an Observable that emits a single List containing at most {@code count} items from the source * Observable that were emitted during a specified window of time before the source Observable completed. *

* *

*
Scheduler:
*
This version of {@code takeLastBuffer} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param count * the maximum number of items to emit * @param time * the length of the time window * @param unit * the time unit of {@code time} * @return an Observable that emits a single List containing at most {@code count} items emitted by the * source Observable during the time window defined by {@code time} before the source Observable * completed * @see RxJava wiki: takeLastBuffer */ public final Observable> takeLastBuffer(int count, long time, TimeUnit unit) { return takeLast(count, time, unit).toList(); } /** * Returns an Observable that emits a single List containing at most {@code count} items from the source * Observable that were emitted during a specified window of time (on a specified Scheduler) before the * source Observable completed. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param count * the maximum number of items to emit * @param time * the length of the time window * @param unit * the time unit of {@code time} * @param scheduler * the Scheduler that provides the timestamps for the observed items * @return an Observable that emits a single List containing at most {@code count} items emitted by the * source Observable during the time window defined by {@code time} before the source Observable * completed * @see RxJava wiki: takeLastBuffer */ public final Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) { return takeLast(count, time, unit, scheduler).toList(); } /** * Returns an Observable that emits a single List containing those items from the source Observable that * were emitted during a specified window of time before the source Observable completed. *

* *

*
Scheduler:
*
This version of {@code takeLastBuffer} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @return an Observable that emits a single List containing the items emitted by the source Observable * during the time window defined by {@code time} before the source Observable completed * @see RxJava wiki: takeLastBuffer */ public final Observable> takeLastBuffer(long time, TimeUnit unit) { return takeLast(time, unit).toList(); } /** * Returns an Observable that emits a single List containing those items from the source Observable that * were emitted during a specified window of time before the source Observable completed, where the timing * information is provided by the given Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param time * the length of the time window * @param unit * the time unit of {@code time} * @param scheduler * the Scheduler that provides the timestamps for the observed items * @return an Observable that emits a single List containing the items emitted by the source Observable * during the time window defined by {@code time} before the source Observable completed, where the * timing information is provided by {@code scheduler} * @see RxJava wiki: takeLastBuffer */ public final Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) { return takeLast(time, unit, scheduler).toList(); } /** * Returns an Observable that emits the items emitted by the source Observable until a second Observable * emits an item. *

* *

*
Scheduler:
*
{@code takeUntil} does not operate by default on a particular {@link Scheduler}.
*
* * @param other * the Observable whose first emitted item will cause {@code takeUntil} to stop emitting items * from the source Observable * @param * the type of items emitted by {@code other} * @return an Observable that emits the items emitted by the source Observable until such time as {@code other} emits its first item * @see RxJava wiki: takeUntil * @see MSDN: Observable.TakeUntil */ public final Observable takeUntil(Observable other) { return lift(new OperatorTakeUntil(other)); } /** * Returns an Observable that emits items emitted by the source Observable so long as each item satisfied a * specified condition, and then completes as soon as this condition is not satisfied. *

* *

*
Scheduler:
*
{@code takeWhile} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * a function that evaluates an item emitted by the source Observable and returns a Boolean * @return an Observable that emits the items from the source Observable so long as each item satisfies the * condition defined by {@code predicate}, then completes * @see RxJava wiki: takeWhile * @see MSDN: Observable.TakeWhile */ public final Observable takeWhile(final Func1 predicate) { return lift(new OperatorTakeWhile(predicate)); } /** * Returns an Observable that emits the items emitted by a source Observable so long as a given predicate * remains true, where the predicate operates on both the item and its index relative to the complete * sequence of emitted items. *

* *

*
Scheduler:
*
{@code takeWhile} does not operate by default on a particular {@link Scheduler}.
*
* * @param predicate * a function to test each item emitted by the source Observable for a condition; the second * parameter of the function represents the sequential index of the source item; it returns a * Boolean * @return an Observable that emits items from the source Observable so long as the predicate continues to * return {@code true} for each item, then completes * @see RxJava wiki: takeWhileWithIndex * @see MSDN: Observable.TakeWhile */ public final Observable takeWhileWithIndex(final Func2 predicate) { return lift(new OperatorTakeWhile(predicate)); } /** * Returns an Observable that emits only the first item emitted by the source Observable during sequential * time windows of a specified duration. *

* This differs from {@link #throttleLast} in that this only tracks passage of time whereas * {@link #throttleLast} ticks at scheduled intervals. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
{@code throttleFirst} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param windowDuration * time to wait before emitting another item after emitting the last item * @param unit * the unit of time of {@code windowDuration} * @return an Observable that performs the throttle operation * @see RxJava wiki: throttleFirst * @see RxJava wiki: Backpressure */ public final Observable throttleFirst(long windowDuration, TimeUnit unit) { return throttleFirst(windowDuration, unit, Schedulers.computation()); } /** * Returns an Observable that emits only the first item emitted by the source Observable during sequential * time windows of a specified duration, where the windows are managed by a specified Scheduler. *

* This differs from {@link #throttleLast} in that this only tracks passage of time whereas * {@link #throttleLast} ticks at scheduled intervals. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param skipDuration * time to wait before emitting another item after emitting the last item * @param unit * the unit of time of {@code skipDuration} * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle timeout for each * event * @return an Observable that performs the throttle operation * @see RxJava wiki: throttleFirst * @see RxJava wiki: Backpressure */ public final Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) { return lift(new OperatorThrottleFirst(skipDuration, unit, scheduler)); } /** * Returns an Observable that emits only the last item emitted by the source Observable during sequential * time windows of a specified duration. *

* This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas * {@link #throttleFirst} does not tick, it just tracks passage of time. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
{@code throttleLast} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param intervalDuration * duration of windows within which the last item emitted by the source Observable will be * emitted * @param unit * the unit of time of {@code intervalDuration} * @return an Observable that performs the throttle operation * @see RxJava wiki: throttleLast * @see RxJava wiki: Backpressure * @see MSDN: Observable.Sample * @see #sample(long, TimeUnit) */ public final Observable throttleLast(long intervalDuration, TimeUnit unit) { return sample(intervalDuration, unit); } /** * Returns an Observable that emits only the last item emitted by the source Observable during sequential * time windows of a specified duration, where the duration is governed by a specified Scheduler. *

* This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas * {@link #throttleFirst} does not tick, it just tracks passage of time. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param intervalDuration * duration of windows within which the last item emitted by the source Observable will be * emitted * @param unit * the unit of time of {@code intervalDuration} * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle timeout for each * event * @return an Observable that performs the throttle operation * @see RxJava wiki: throttleLast * @see RxJava wiki: Backpressure * @see MSDN: Observable.Sample * @see #sample(long, TimeUnit, Scheduler) */ public final Observable throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) { return sample(intervalDuration, unit, scheduler); } /** * Returns an Observable that only emits those items emitted by the source Observable that are not followed * by another emitted item within a specified time window. *

* Note: If the source Observable keeps emitting items more frequently than the length of the time * window then no items will be emitted by the resulting Observable. *

* *

* Information on debounce vs throttle: *

*

*
*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
{@code throttleWithTimeout} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timeout * the length of the window of time that must pass after the emission of an item from the source * Observable in which that Observable emits no items in order for the item to be emitted by the * resulting Observable * @param unit * the {@link TimeUnit} of {@code timeout} * @return an Observable that filters out items that are too quickly followed by newer items * @see RxJava wiki: throttleWithTimeout * @see RxJava wiki: Backpressure * @see MSDN: Observable.Throttle * @see #debounce(long, TimeUnit) */ public final Observable throttleWithTimeout(long timeout, TimeUnit unit) { return debounce(timeout, unit); } /** * Returns an Observable that only emits those items emitted by the source Observable that are not followed * by another emitted item within a specified time window, where the time window is governed by a specified * Scheduler. *

* Note: If the source Observable keeps emitting items more frequently than the length of the time * window then no items will be emitted by the resulting Observable. *

* *

* Information on debounce vs throttle: *

*

*
*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timeout * the length of the window of time that must pass after the emission of an item from the source * Observable in which that Observable emits no items in order for the item to be emitted by the * resulting Observable * @param unit * the {@link TimeUnit} of {@code timeout} * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle the timeout for each * item * @return an Observable that filters out items that are too quickly followed by newer items * @see RxJava wiki: throttleWithTimeout * @see RxJava wiki: Backpressure * @see MSDN: Observable.Throttle * @see #debounce(long, TimeUnit, Scheduler) */ public final Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) { return debounce(timeout, unit, scheduler); } /** * Returns an Observable that emits records of the time interval between consecutive items emitted by the * source Observable. *

* *

*
Scheduler:
*
{@code timeInterval} operates by default on the {@code immediate} {@link Scheduler}.
*
* * @return an Observable that emits time interval information items * @see RxJava wiki: timeInterval * @see MSDN: Observable.TimeInterval */ public final Observable> timeInterval() { return timeInterval(Schedulers.immediate()); } /** * Returns an Observable that emits records of the time interval between consecutive items emitted by the * source Observable, where this interval is computed on a specified Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param scheduler * the {@link Scheduler} used to compute time intervals * @return an Observable that emits time interval information items * @see RxJava wiki: timeInterval * @see MSDN: Observable.TimeInterval */ public final Observable> timeInterval(Scheduler scheduler) { return lift(new OperatorTimeInterval(scheduler)); } /** * Returns an Observable that mirrors the source Observable, but notifies observers of a * {@code TimeoutException} if either the first item emitted by the source Observable or any subsequent item * doesn't arrive within time windows defined by other Observables. *

* *

*
Scheduler:
*
This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.
*
* * @param * the first timeout value type (ignored) * @param * the subsequent timeout value type (ignored) * @param firstTimeoutSelector * a function that returns an Observable that determines the timeout window for the first source * item * @param timeoutSelector * a function that returns an Observable for each item emitted by the source Observable and that * determines the timeout window in which the subsequent source item must arrive in order to * continue the sequence * @return an Observable that mirrors the source Observable, but notifies observers of a * {@code TimeoutException} if either the first item or any subsequent item doesn't arrive within * the time windows specified by the timeout selectors * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) { return timeout(firstTimeoutSelector, timeoutSelector, null); } /** * Returns an Observable that mirrors the source Observable, but switches to a fallback Observable if either * the first item emitted by the source Observable or any subsequent item doesn't arrive within time windows * defined by other Observables. *

* *

*
Scheduler:
*
This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.
*
* * @param * the first timeout value type (ignored) * @param * the subsequent timeout value type (ignored) * @param firstTimeoutSelector * a function that returns an Observable which determines the timeout window for the first source * item * @param timeoutSelector * a function that returns an Observable for each item emitted by the source Observable and that * determines the timeout window in which the subsequent source item must arrive in order to * continue the sequence * @param other * the fallback Observable to switch to if the source Observable times out * @return an Observable that mirrors the source Observable, but switches to the {@code other} Observable if * either the first item emitted by the source Observable or any subsequent item doesn't arrive * within time windows defined by the timeout selectors * @throws NullPointerException * if {@code timeoutSelector} is null * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) { if (timeoutSelector == null) { throw new NullPointerException("timeoutSelector is null"); } return lift(new OperatorTimeoutWithSelector(firstTimeoutSelector, timeoutSelector, other)); } /** * Returns an Observable that mirrors the source Observable, but notifies observers of a * {@code TimeoutException} if an item emitted by the source Observable doesn't arrive within a window of * time after the emission of the previous item, where that period of time is measured by an Observable that * is a function of the previous item. *

* *

* Note: The arrival of the first source item is never timed out. *

*
Scheduler:
*
This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.
*
* * @param * the timeout value type (ignored) * @param timeoutSelector * a function that returns an observable for each item emitted by the source * Observable and that determines the timeout window for the subsequent item * @return an Observable that mirrors the source Observable, but notifies observers of a * {@code TimeoutException} if an item emitted by the source Observable takes longer to arrive than * the time window defined by the selector for the previously emitted item * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(Func1> timeoutSelector) { return timeout(null, timeoutSelector, null); } /** * Returns an Observable that mirrors the source Observable, but that switches to a fallback Observable if * an item emitted by the source Observable doesn't arrive within a window of time after the emission of the * previous item, where that period of time is measured by an Observable that is a function of the previous * item. *

* *

* Note: The arrival of the first source item is never timed out. *

*
Scheduler:
*
This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.
*
* * @param * the timeout value type (ignored) * @param timeoutSelector * a function that returns an Observable, for each item emitted by the source Observable, that * determines the timeout window for the subsequent item * @param other * the fallback Observable to switch to if the source Observable times out * @return an Observable that mirrors the source Observable, but switches to mirroring a fallback Observable * if an item emitted by the source Observable takes longer to arrive than the time window defined * by the selector for the previously emitted item * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(Func1> timeoutSelector, Observable other) { return timeout(null, timeoutSelector, other); } /** * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted * item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, * the resulting Observable terminates and notifies observers of a {@code TimeoutException}. *

* *

*
Scheduler:
*
This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timeout * maximum duration between emitted items before a timeout occurs * @param timeUnit * the unit of time that applies to the {@code timeout} argument. * @return the source Observable modified to notify observers of a {@code TimeoutException} in case of a * timeout * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(long timeout, TimeUnit timeUnit) { return timeout(timeout, timeUnit, null, Schedulers.computation()); } /** * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted * item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, * the resulting Observable begins instead to mirror a fallback Observable. *

* *

*
Scheduler:
*
This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timeout * maximum duration between items before a timeout occurs * @param timeUnit * the unit of time that applies to the {@code timeout} argument * @param other * the fallback Observable to use in case of a timeout * @return the source Observable modified to switch to the fallback Observable in case of a timeout * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(long timeout, TimeUnit timeUnit, Observable other) { return timeout(timeout, timeUnit, other, Schedulers.computation()); } /** * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted * item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration * starting from its predecessor, the resulting Observable begins instead to mirror a fallback Observable. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timeout * maximum duration between items before a timeout occurs * @param timeUnit * the unit of time that applies to the {@code timeout} argument * @param other * the Observable to use as the fallback in case of a timeout * @param scheduler * the {@link Scheduler} to run the timeout timers on * @return the source Observable modified so that it will switch to the fallback Observable in case of a * timeout * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) { return lift(new OperatorTimeout(timeout, timeUnit, other, scheduler)); } /** * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted * item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the * specified timeout duration starting from its predecessor, the resulting Observable terminates and * notifies observers of a {@code TimeoutException}. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timeout * maximum duration between items before a timeout occurs * @param timeUnit * the unit of time that applies to the {@code timeout} argument * @param scheduler * the Scheduler to run the timeout timers on * @return the source Observable modified to notify observers of a {@code TimeoutException} in case of a * timeout * @see RxJava wiki: timeout * @see MSDN: Observable.Timeout */ public final Observable timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) { return timeout(timeout, timeUnit, null, scheduler); } /** * Returns an Observable that emits each item emitted by the source Observable, wrapped in a * {@link Timestamped} object. *

* *

*
Scheduler:
*
{@code timestamp} operates by default on the {@code immediate} {@link Scheduler}.
*
* * @return an Observable that emits timestamped items from the source Observable * @see RxJava wiki: timestamp * @see MSDN: Observable.Timestamp */ public final Observable> timestamp() { return timestamp(Schedulers.immediate()); } /** * Returns an Observable that emits each item emitted by the source Observable, wrapped in a * {@link Timestamped} object whose timestamps are provided by a specified Scheduler. *

* *

*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param scheduler * the {@link Scheduler} to use as a time source * @return an Observable that emits timestamped items from the source Observable with timestamps provided by * the {@code scheduler} * @see RxJava wiki: timestamp * @see MSDN: Observable.Timestamp */ public final Observable> timestamp(Scheduler scheduler) { return lift(new OperatorTimestamp(scheduler)); } /** * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking operators). *
*
Scheduler:
*
{@code toBlocking} does not operate by default on a particular {@link Scheduler}.
*
* * @return a {@code BlockingObservable} version of this Observable * @see RxJava wiki: Blocking Observable Operators */ public final BlockingObservable toBlocking() { return BlockingObservable.from(this); } /** * Returns an Observable that emits a single item, a list composed of all the items emitted by the source * Observable. *

* *

* Normally, an Observable that returns multiple items will do so by invoking its {@link Observer}'s * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the * Observable to compose a list of all of these items and then to invoke the Observer's {@code onNext} * function once, passing it the entire list, by calling the Observable's {@code toList} method prior to * calling its {@link #subscribe} method. *

* Be careful not to use this operator on Observables that emit infinite or very large numbers of items, as * you do not have the option to unsubscribe. *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toList} does not operate by default on a particular {@link Scheduler}.
*
* * @return an Observable that emits a single item: a List containing all of the items emitted by the source * Observable * @see RxJava wiki: toList * @see MSDN: Observable.ToList */ public final Observable> toList() { return lift(new OperatorToObservableList()); } /** * Returns an Observable that emits a single HashMap containing all items emitted by the source Observable, * mapped by the keys returned by a specified {@code keySelector} function. *

* *

* If more than one source item maps to the same key, the HashMap will contain the latest of those items. *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * the function that extracts the key from a source item to be used in the HashMap * @return an Observable that emits a single item: a HashMap containing the mapped items from the source * Observable * @see RxJava wiki: toMap * @see MSDN: Observable.ToDictionary */ public final Observable> toMap(Func1 keySelector) { return lift(new OperatorToMap(keySelector, Functions.identity())); } /** * Returns an Observable that emits a single HashMap containing values corresponding to items emitted by the * source Observable, mapped by the keys returned by a specified {@code keySelector} function. *

* *

* If more than one source item maps to the same key, the HashMap will contain a single entry that * corresponds to the latest of those items. *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * the function that extracts the key from a source item to be used in the HashMap * @param valueSelector * the function that extracts the value from a source item to be used in the HashMap * @return an Observable that emits a single item: a HashMap containing the mapped items from the source * Observable * @see RxJava wiki: toMap * @see MSDN: Observable.ToDictionary */ public final Observable> toMap(Func1 keySelector, Func1 valueSelector) { return lift(new OperatorToMap(keySelector, valueSelector)); } /** * Returns an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that * contains keys and values extracted from the items emitted by the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * the function that extracts the key from a source item to be used in the Map * @param valueSelector * the function that extracts the value from the source items to be used as value in the Map * @param mapFactory * the function that returns a Map instance to be used * @return an Observable that emits a single item: a Map that contains the mapped items emitted by the * source Observable * @see RxJava wiki: toMap */ public final Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) { return lift(new OperatorToMap(keySelector, valueSelector, mapFactory)); } /** * Returns an Observable that emits a single HashMap that contains an ArrayList of items emitted by the * source Observable keyed by a specified {@code keySelector} function. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * the function that extracts the key from the source items to be used as key in the HashMap * @return an Observable that emits a single item: a HashMap that contains an ArrayList of items mapped from * the source Observable * @see RxJava wiki: toMap * @see MSDN: Observable.ToLookup */ public final Observable>> toMultimap(Func1 keySelector) { return lift(new OperatorToMultimap(keySelector, Functions.identity())); } /** * Returns an Observable that emits a single HashMap that contains an ArrayList of values extracted by a * specified {@code valueSelector} function from items emitted by the source Observable, keyed by a * specified {@code keySelector} function. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * the function that extracts a key from the source items to be used as key in the HashMap * @param valueSelector * the function that extracts a value from the source items to be used as value in the HashMap * @return an Observable that emits a single item: a HashMap that contains an ArrayList of items mapped from * the source Observable * @see RxJava wiki: toMap * @see MSDN: Observable.ToLookup */ public final Observable>> toMultimap(Func1 keySelector, Func1 valueSelector) { return lift(new OperatorToMultimap(keySelector, valueSelector)); } /** * Returns an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that * contains an ArrayList of values, extracted by a specified {@code valueSelector} function from items * emitted by the source Observable and keyed by the {@code keySelector} function. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * the function that extracts a key from the source items to be used as the key in the Map * @param valueSelector * the function that extracts a value from the source items to be used as the value in the Map * @param mapFactory * the function that returns a Map instance to be used * @return an Observable that emits a single item: a Map that contains a list items mapped from the source * Observable * @see RxJava wiki: toMap */ public final Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) { return lift(new OperatorToMultimap(keySelector, valueSelector, mapFactory)); } /** * Returns an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that * contains a custom collection of values, extracted by a specified {@code valueSelector} function from * items emitted by the source Observable, and keyed by the {@code keySelector} function. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.
*
* * @param keySelector * the function that extracts a key from the source items to be used as the key in the Map * @param valueSelector * the function that extracts a value from the source items to be used as the value in the Map * @param mapFactory * the function that returns a Map instance to be used * @param collectionFactory * the function that returns a Collection instance for a particular key to be used in the Map * @return an Observable that emits a single item: a Map that contains the collection of mapped items from * the source Observable * @see RxJava wiki: toMap */ public final Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) { return lift(new OperatorToMultimap(keySelector, valueSelector, mapFactory, collectionFactory)); } /** * Returns an Observable that emits a list that contains the items emitted by the source Observable, in a * sorted order. Each item emitted by the Observable must implement {@link Comparable} with respect to all * other items in the sequence. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toSortedList} does not operate by default on a particular {@link Scheduler}.
*
* * @throws ClassCastException * if any item emitted by the Observable does not implement {@link Comparable} with respect to * all other items emitted by the Observable * @return an Observable that emits a list that contains the items emitted by the source Observable in * sorted order * @see RxJava wiki: toSortedList */ public final Observable> toSortedList() { return lift(new OperatorToObservableSortedList()); } /** * Returns an Observable that emits a list that contains the items emitted by the source Observable, in a * sorted order based on a specified comparison function. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as by intent it is requesting and buffering everything.
*
Scheduler:
*
{@code toSortedList} does not operate by default on a particular {@link Scheduler}.
*
* * @param sortFunction * a function that compares two items emitted by the source Observable and returns an Integer * that indicates their sort order * @return an Observable that emits a list that contains the items emitted by the source Observable in * sorted order * @see RxJava wiki: toSortedList */ public final Observable> toSortedList(Func2 sortFunction) { return lift(new OperatorToObservableSortedList(sortFunction)); } /** * Modifies the source Observable so that subscribers will unsubscribe from it on a specified * {@link Scheduler}. *
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param scheduler * the {@link Scheduler} to perform unsubscription actions on * @return the source Observable modified so that its unsubscriptions happen on the specified * {@link Scheduler} */ public final Observable unsubscribeOn(Scheduler scheduler) { return lift(new OperatorUnsubscribeOn(scheduler)); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping windows. It emits the current window and opens a new one * whenever the Observable produced by the specified {@code closingSelector} emits an item. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses the {@code closingSelector} to control data * flow.
*
Scheduler:
*
This version of {@code window} does not operate by default on a particular {@link Scheduler}.
*
* * @param closingSelector * a {@link Func0} that returns an {@code Observable} that governs the boundary between windows. * When this {@code Observable} emits an item, {@code window} emits the current window and begins * a new one. * @return an Observable that emits connected, non-overlapping windows of items from the source Observable * whenever {@code closingSelector} emits an item * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(Func0> closingSelector) { return lift(new OperatorWindowWithObservable(closingSelector)); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping windows, each containing {@code count} items. When the source * Observable completes or encounters an error, the resulting Observable emits the current window and * propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses {@code count} to control data flow.
*
Scheduler:
*
This version of {@code window} does not operate by default on a particular {@link Scheduler}.
*
* * @param count * the maximum size of each window before it should be emitted * @return an Observable that emits connected, non-overlapping windows, each containing at most * {@code count} items from the source Observable * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(int count) { return window(count, count); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits windows every {@code skip} items, each containing no more than {@code count} items. When * the source Observable completes or encounters an error, the resulting Observable emits the current window * and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses {@code count} to control data flow.
*
Scheduler:
*
This version of {@code window} does not operate by default on a particular {@link Scheduler}.
*
* * @param count * the maximum size of each window before it should be emitted * @param skip * how many items need to be skipped before starting a new window. Note that if {@code skip} and * {@code count} are equal this is the same operation as {@link #window(int)}. * @return an Observable that emits windows every {@code skip} items containing at most {@code count} items * from the source Observable * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(int count, int skip) { return lift(new OperatorWindowWithSize(count, skip)); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable starts a new window periodically, as determined by the {@code timeshift} argument. It emits * each window after a fixed timespan, specified by the {@code timespan} argument. When the source * Observable completes or Observable completes or encounters an error, the resulting Observable emits the * current window and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timespan * the period of time each window collects items before it should be emitted * @param timeshift * the period of time after which a new window will be created * @param unit * the unit of time that applies to the {@code timespan} and {@code timeshift} arguments * @return an Observable that emits new windows periodically as a fixed timespan elapses * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(long timespan, long timeshift, TimeUnit unit) { return window(timespan, timeshift, unit, Integer.MAX_VALUE, Schedulers.computation()); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable starts a new window periodically, as determined by the {@code timeshift} argument. It emits * each window after a fixed timespan, specified by the {@code timespan} argument. When the source * Observable completes or Observable completes or encounters an error, the resulting Observable emits the * current window and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timespan * the period of time each window collects items before it should be emitted * @param timeshift * the period of time after which a new window will be created * @param unit * the unit of time that applies to the {@code timespan} and {@code timeshift} arguments * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window * @return an Observable that emits new windows periodically as a fixed timespan elapses * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) { return window(timespan, timeshift, unit, Integer.MAX_VALUE, scheduler); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable starts a new window periodically, as determined by the {@code timeshift} argument or a maximum * size as specified by the {@code count} argument (whichever is reached first). It emits * each window after a fixed timespan, specified by the {@code timespan} argument. When the source * Observable completes or Observable completes or encounters an error, the resulting Observable emits the * current window and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timespan * the period of time each window collects items before it should be emitted * @param timeshift * the period of time after which a new window will be created * @param unit * the unit of time that applies to the {@code timespan} and {@code timeshift} arguments * @param count * the maximum size of each window before it should be emitted * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window * @return an Observable that emits new windows periodically as a fixed timespan elapses * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(long timespan, long timeshift, TimeUnit unit, int count, Scheduler scheduler) { return lift(new OperatorWindowWithTime(timespan, timeshift, unit, count, scheduler)); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping windows, each of a fixed duration specified by the * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting * Observable emits the current window and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timespan * the period of time each window collects items before it should be emitted and replaced with a * new window * @param unit * the unit of time that applies to the {@code timespan} argument * @return an Observable that emits connected, non-overlapping windows represending items emitted by the * source Observable during fixed, consecutive durations * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(long timespan, TimeUnit unit) { return window(timespan, timespan, unit, Schedulers.computation()); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the * {@code timespan} argument or a maximum size as specified by the {@code count} argument (whichever is * reached first). When the source Observable completes or encounters an error, the resulting Observable * emits the current window and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.
*
* * @param timespan * the period of time each window collects items before it should be emitted and replaced with a * new window * @param unit * the unit of time that applies to the {@code timespan} argument * @param count * the maximum size of each window before it should be emitted * @return an Observable that emits connected, non-overlapping windows of items from the source Observable * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(long timespan, TimeUnit unit, int count) { return window(timespan, unit, count, Schedulers.computation()); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping windows, each of a fixed duration specified by the * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached * first). When the source Observable completes or encounters an error, the resulting Observable emits the * current window and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timespan * the period of time each window collects items before it should be emitted and replaced with a * new window * @param unit * the unit of time which applies to the {@code timespan} argument * @param count * the maximum size of each window before it should be emitted * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window * @return an Observable that emits connected, non-overlapping windows of items from the source Observable * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) { return window(timespan, timespan, unit, count, scheduler); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting * Observable emits the current window and propagates the notification from the source Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses time to control data flow.
*
Scheduler:
*
you specify which {@link Scheduler} this operator will use
*
* * @param timespan * the period of time each window collects items before it should be emitted and replaced with a * new window * @param unit * the unit of time which applies to the {@code timespan} argument * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window * @return an Observable that emits connected, non-overlapping windows containing items emitted by the * source Observable within a fixed duration * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(long timespan, TimeUnit unit, Scheduler scheduler) { return window(timespan, unit, Integer.MAX_VALUE, scheduler); } /** * Returns an Observable that emits windows of items it collects from the source Observable. The resulting * Observable emits windows that contain those items emitted by the source Observable between the time when * the {@code windowOpenings} Observable emits an item and when the Observable returned by * {@code closingSelector} emits an item. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses Observables to control data flow.
*
Scheduler:
*
This version of {@code window} does not operate by default on a particular {@link Scheduler}.
*
* * @param windowOpenings * an Observable that, when it emits an item, causes another window to be created * @param closingSelector * a {@link Func1} that produces an Observable for every window created. When this Observable * emits an item, the associated window is closed and emitted * @return an Observable that emits windows of items emitted by the source Observable that are governed by * the specified window-governing Observables * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(Observable windowOpenings, Func1> closingSelector) { return lift(new OperatorWindowWithStartEndObservable(windowOpenings, closingSelector)); } /** * Returns an Observable that emits non-overlapping windows of items it collects from the source Observable * where the boundary of each window is determined by the items emitted from a specified boundary-governing * Observable. *

* *

*
Backpressure Support:
*
This operator does not support backpressure as it uses a {@code boundary} Observable to control data * flow.
*
Scheduler:
*
This version of {@code window} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the window element type (ignored) * @param boundary * an Observable whose emitted items close and open windows * @return an Observable that emits non-overlapping windows of items it collects from the source Observable * where the boundary of each window is determined by the items emitted from the {@code boundary} * Observable * @see RxJava wiki: window * @see MSDN: Observable.Window */ public final Observable> window(Observable boundary) { return lift(new OperatorWindowWithObservable(boundary)); } /** * Returns an Observable that emits items that are the result of applying a specified function to pairs of * values, one each from the source Observable and a specified Iterable sequence. *

* *

* Note that the {@code other} Iterable is evaluated as items are observed from the source Observable; it is * not pre-consumed. This allows you to zip infinite streams on either side. *

*
Scheduler:
*
{@code zipWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items in the {@code other} Iterable * @param * the type of items emitted by the resulting Observable * @param other * the Iterable sequence * @param zipFunction * a function that combines the pairs of items from the Observable and the Iterable to generate * the items to be emitted by the resulting Observable * @return an Observable that pairs up values from the source Observable and the {@code other} Iterable * sequence and emits the results of {@code zipFunction} applied to these pairs * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final Observable zipWith(Iterable other, Func2 zipFunction) { return lift(new OperatorZipIterable(other, zipFunction)); } /** * Returns an Observable that emits items that are the result of applying a specified function to pairs of * values, one each from the source Observable and another specified Observable. *

* *

*
Scheduler:
*
{@code zipWith} does not operate by default on a particular {@link Scheduler}.
*
* * @param * the type of items emitted by the {@code other} Observable * @param * the type of items emitted by the resulting Observable * @param other * the other Observable * @param zipFunction * a function that combines the pairs of items from the two Observables to generate the items to * be emitted by the resulting Observable * @return an Observable that pairs up values from the source Observable and the {@code other} Observable * and emits the results of {@code zipFunction} applied to these pairs * @see RxJava wiki: zip * @see MSDN: Observable.Zip */ public final Observable zipWith(Observable other, Func2 zipFunction) { return zip(this, other, zipFunction); } /** * An Observable that never sends any information to an {@link Observer}. * This Observable is useful primarily for testing purposes. * * @param * the type of item (not) emitted by the Observable */ private static class NeverObservable extends Observable { public NeverObservable() { super(new OnSubscribe() { @Override public void call(Subscriber observer) { // do nothing } }); } } /** * An Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it. * * @param * the type of item (ostensibly) emitted by the Observable */ private static class ThrowObservable extends Observable { public ThrowObservable(final Throwable exception) { super(new OnSubscribe() { /** * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method. * * @param observer * an {@link Observer} of this Observable */ @Override public void call(Subscriber observer) { observer.onError(exception); } }); } } }