final OnSubscribe<T> onSubscribe;

/**

* Creates an Observable with a Function to execute when it is subscribed to.

* <p>

* <em>Note:</em> 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<T> f) {

this.onSubscribe = f;

}

/**

* <strong>This method requires advanced knowledge about building operators and data sources; please consider

* other standard methods first;</strong>

* Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to

* it.

* <p>

* <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create.png" alt="">

* <p>

* 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.

* <p>

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

* its {@code onError} method exactly once.

* <p>

* See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed

* information.

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The {@code OnSubscribe} instance provided is responsible to be backpressure-aware or

* document the fact that the consumer of the returned {@code Observable} has to apply one of

* the {@code onBackpressureXXX} operators.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T>

* the type of the items that this Observable emits

* @param f

* a function that accepts an {@code Subscriber<T>}, 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 <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>

*/

public static <T> Observable<T> create(OnSubscribe<T> f) {

return new Observable<T>(RxJavaHooks.onCreate(f));

}

/**

* Returns an Observable that respects the back-pressure semantics. When the returned Observable is

* subscribed to it will initiate the given {@link SyncOnSubscribe}'s life cycle for

* generating events.

*

* <p><b>Note:</b> the {@code SyncOnSubscribe} provides a generic way to fulfill data by iterating

* over a (potentially stateful) function (e.g. reading data off of a channel, a parser, ). If your

* data comes directly from an asynchronous/potentially concurrent source then consider using the

* {@link Observable#create(AsyncOnSubscribe) asynchronous overload}.

*

* <p>

* <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-sync.png" alt="">

* <p>

* See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed

* information.

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator honors backpressure and generates values on-demand (when requested).</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T>

* the type of the items that this Observable emits

* @param <S> the state type

* @param syncOnSubscribe

* an implementation of {@link SyncOnSubscribe}. There are many static creation methods

* on the class for convenience.

* @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified

* function

* @see SyncOnSubscribe#createSingleState(Func0, Action2)

* @see SyncOnSubscribe#createSingleState(Func0, Action2, Action1)

* @see SyncOnSubscribe#createStateful(Func0, Func2)

* @see SyncOnSubscribe#createStateful(Func0, Func2, Action1)

* @see SyncOnSubscribe#createStateless(Action1)

* @see SyncOnSubscribe#createStateless(Action1, Action0)

* @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>

* @since 1.2

*/

public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe) {

return create((OnSubscribe<T>)syncOnSubscribe);

}

/**

* Returns an Observable that respects the back-pressure semantics. When the returned Observable is

* subscribed to it will initiate the given {@link AsyncOnSubscribe}'s life cycle for

* generating events.

*

* <p><b>Note:</b> the {@code AsyncOnSubscribe} is useful for observable sources of data that are

* necessarily asynchronous (RPC, external services, etc). Typically most use cases can be solved

* with the {@link Observable#create(SyncOnSubscribe) synchronous overload}.

*

* <p>

* <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-async.png" alt="">

* <p>

* See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed

* information.

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator honors backpressure and generates values on-demand (when requested).</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T>

* the type of the items that this Observable emits

* @param <S> the state type

* @param asyncOnSubscribe

* an implementation of {@link AsyncOnSubscribe}. There are many static creation methods

* on the class for convenience.

* @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified

* function

* @see AsyncOnSubscribe#createSingleState(Func0, Action3)

* @see AsyncOnSubscribe#createSingleState(Func0, Action3, Action1)

* @see AsyncOnSubscribe#createStateful(Func0, Func3)

* @see AsyncOnSubscribe#createStateful(Func0, Func3, Action1)

* @see AsyncOnSubscribe#createStateless(Action2)

* @see AsyncOnSubscribe#createStateless(Action2, Action0)

* @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>

* @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)

*/

@Experimental

public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe) {

return create((OnSubscribe<T>)asyncOnSubscribe);

}

/**

* Invoked when Observable.subscribe is called.

* @param <T> the output value type

*/

public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {

// cover for generics insanity

}

/**

* Operator function for lifting into an Observable.

* @param <T> the upstream's value type (input)

* @param <R> the downstream's value type (output)

*/

public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> {

// cover for generics insanity

}

/**

* <strong>This method requires advanced knowledge about building operators; please consider

* other standard composition methods first;</strong>

* 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.

* <p>

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

* the Observable.

* <p> {@code

* observable.map(...).filter(...).take(5).lift(new OperatorA()).lift(new OperatorB(...)).subscribe()

* }

* <p>

* 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}.

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The {@code Operator} instance provided is responsible to be backpressure-aware or

* document the fact that the consumer of the returned {@code Observable} has to apply one of

* the {@code onBackpressureXXX} operators.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code lift} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <R> the output value type

* @param operator 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 <a href="https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators">RxJava wiki: Implementing Your Own Operators</a>

*/

public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {

return create(new OnSubscribeLift<T, R>(onSubscribe, operator));

}

/**

* Transform an Observable by applying a particular Transformer function to it.

* <p>

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

* Subscribers or Observers.

* <p>

* 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}.

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with the backpressure behavior which only depends

* on what kind of {@code Observable} the transformer returns.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code compose} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <R> the value type of the output Observable

* @param transformer implements the function that transforms the source Observable

* @return the source Observable, transformed by the transformer function

* @see <a href="https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators">RxJava wiki: Implementing Your Own Operators</a>

*/

@SuppressWarnings("unchecked")

public <R> Observable<R> compose(Transformer<? super T, ? extends R> transformer) {

return ((Transformer<T, R>) transformer).call(this);

}

/**

* Function that receives the current Observable and should return another

* Observable, possibly with given element type, in exchange that will be

* subscribed to by the downstream operators and subscribers.

* <p>

* This convenience interface has been introduced to work around the variance declaration

* problems of type arguments.

*

* @param <T> the input Observable's value type

* @param <R> the output Observable's value type

*/

public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {

// cover for generics insanity

}

/**

* Calls the specified converter function during assembly time and returns its resulting value.

* <p>

* This allows fluent conversion to any other type.

* @param <R> the resulting object type

* @param converter the function that receives the current Observable instance and returns a value

* @return the value returned by the function

*/

@Experimental

public final <R> R to(Func1<? super Observable<T>, R> converter) {

return converter.call(this);

}

/**

* Returns a Single 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.

* <p>

* <img width="640" height="295" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.toSingle.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Single}

* does not have a notion of backpressure.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code toSingle} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @return a Single that emits the single item emitted by the source Observable

* @throws IllegalArgumentException

* if the source observable emits more than one item

* @throws NoSuchElementException

* if the source observable emits no items

* @see <a href="http://reactivex.io/documentation/single.html">ReactiveX documentation: Single</a>

* @since 1.2

*/

public Single<T> toSingle() {

return new Single<T>(OnSubscribeSingle.create(this));

}

/**

* Returns a Completable that discards all onNext emissions (similar to

* {@code ignoreAllElements()}) and calls onCompleted when this source observable calls

* onCompleted. Error terminal events are propagated.

* <p>

* <img width="640" height="295" src=

* "https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Completable.toCompletable.png"

* alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Completable}

* does not have a notion of backpressure.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code toCompletable} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @return a Completable that calls onCompleted on it's subscriber when the source Observable

* calls onCompleted

* @see <a href="http://reactivex.io/documentation/completable.html">ReactiveX documentation:

* Completable</a>

* @since (if this graduates from Experimental/Beta to supported, replace this parenthetical

* with the release number)

*/

@Beta

public Completable toCompletable() {

return Completable.fromObservable(this);

}

/* *********************************************************************************************************

* Operators Below Here

* *********************************************************************************************************

*/

/**

* Mirrors the one Observable in an Iterable of several Observables that first either emits an item or sends

* a termination notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element type

* @param sources

* an Iterable of Observable sources competing to react first

* @return an Observable that emits the same sequence as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>> sources) {

return create(OnSubscribeAmb.amb(sources));

}

/**

* Given two Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element type

* @param o1

* an Observable competing to react first

* @param o2

* an Observable competing to react first

* @return an Observable that emits the same sequence as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {

return create(OnSubscribeAmb.amb(o1, o2));

}

/**

* Given three Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element base type

* @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 as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) {

return create(OnSubscribeAmb.amb(o1, o2, o3));

}

/**

* Given four Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element base type

* @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 as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) {

return create(OnSubscribeAmb.amb(o1, o2, o3, o4));

}

/**

* Given five Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element base type

* @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 as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) {

return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5));

}

/**

* Given six Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element base type

* @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 as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) {

return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6));

}

/**

* Given seven Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element base type

* @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 as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) {

return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7));

}

/**

* Given eight Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element base type

* @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 as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) {

return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));

}

/**

* Given nine Observables, mirrors the one that first either emits an item or sends a termination

* notification.

* <p>

* <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The operator itself doesn't interfere with backpressure which is determined by the winning

* {@code Observable}'s backpressure behavior.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T> the common element base type

* @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 as whichever of the source Observables first

* emitted an item or sent a termination notification

* @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>

*/

public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> 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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {

return (Observable<R>)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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <T3> the element type of the third source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {

return (Observable<R>)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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <T3> the element type of the third source

* @param <T4> the element type of the fourth source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4,

Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineFunction) {

return (Observable<R>)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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <T3> the element type of the third source

* @param <T4> the element type of the fourth source

* @param <T5> the element type of the fifth source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5,

Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineFunction) {

return (Observable<R>)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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <T3> the element type of the third source

* @param <T4> the element type of the fourth source

* @param <T5> the element type of the fifth source

* @param <T6> the element type of the sixth source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,

Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineFunction) {

return (Observable<R>)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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <T3> the element type of the third source

* @param <T4> the element type of the fourth source

* @param <T5> the element type of the fifth source

* @param <T6> the element type of the sixth source

* @param <T7> the element type of the seventh source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,

Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineFunction) {

return (Observable<R>)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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <T3> the element type of the third source

* @param <T4> the element type of the fourth source

* @param <T5> the element type of the fifth source

* @param <T6> the element type of the sixth source

* @param <T7> the element type of the seventh source

* @param <T8> the element type of the eighth source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,

Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineFunction) {

return (Observable<R>)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.

* <p>

* <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">

* <dl>

* <dt><b>Backpressure:</b></dt>

* <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s

* are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal

* {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>

* <dt><b>Scheduler:</b></dt>

* <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>

* </dl>

*

* @param <T1> the element type of the first source

* @param <T2> the element type of the second source

* @param <T3> the element type of the third source

* @param <T4> the element type of the fourth source

* @param <T5> the element type of the fifth source

* @param <T6> the element type of the sixth source

* @param <T7> the element type of the seventh source

* @param <T8> the element type of the eighth source

* @param <T9> the element type of the ninth source

* @param <R> the combined output type

* @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 <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>

*/

@SuppressWarnings({ "unchecked", "cast" })

public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,

Observable<? extends T9> o9,

Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> combineFunction) {

return (Observable<R>)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.

* <dl>

* <dt><b>Backpressure:</b></dt>