rx.util.async

Class Async

java.lang.Object

rx.util.async.Async

public final class Async
extends java.lang.Object

Utility methods to convert functions and actions into asynchronous operations through the Observable/Observer pattern.

Method Summary

Methods

Modifier and Type	Method and Description
static rx.functions.FuncN<rx.Observable<java.lang.Void>>	asyncAction(rx.functions.ActionN action) Convert a synchronous action call into an asynchronous function call through an Observable.
static rx.functions.FuncN<rx.Observable<java.lang.Void>>	asyncAction(rx.functions.ActionN action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <R> rx.functions.FuncN<rx.Observable<R>>	asyncFunc(rx.functions.FuncN<? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <R> rx.functions.FuncN<rx.Observable<R>>	asyncFunc(rx.functions.FuncN<? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T> rx.Observable<T>	deferFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends rx.Observable<? extends T>>> observableFactoryAsync) Returns an Observable that starts the specified asynchronous factory function whenever a new observer subscribes.
static <T> rx.Observable<T>	deferFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends rx.Observable<? extends T>>> observableFactoryAsync, rx.Scheduler scheduler) Returns an Observable that starts the specified asynchronous factory function whenever a new observer subscribes.
static <T> java.util.concurrent.FutureTask<java.lang.Void>	forEachFuture(rx.Observable<? extends T> source, rx.functions.Action1<? super T> onNext) Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future.
static <T> java.util.concurrent.FutureTask<java.lang.Void>	forEachFuture(rx.Observable<? extends T> source, rx.functions.Action1<? super T> onNext, rx.functions.Action1<? super java.lang.Throwable> onError) Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future.
static <T> java.util.concurrent.FutureTask<java.lang.Void>	forEachFuture(rx.Observable<? extends T> source, rx.functions.Action1<? super T> onNext, rx.functions.Action1<? super java.lang.Throwable> onError, rx.functions.Action0 onCompleted) Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future.
static <T> java.util.concurrent.FutureTask<java.lang.Void>	forEachFuture(rx.Observable<? extends T> source, rx.functions.Action1<? super T> onNext, rx.functions.Action1<? super java.lang.Throwable> onError, rx.functions.Action0 onCompleted, rx.Scheduler scheduler) Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future, scheduled on the given Scheduler.
static <T> java.util.concurrent.FutureTask<java.lang.Void>	forEachFuture(rx.Observable<? extends T> source, rx.functions.Action1<? super T> onNext, rx.functions.Action1<? super java.lang.Throwable> onError, rx.Scheduler scheduler) Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future, scheduled on the given Scheduler.
static <T> java.util.concurrent.FutureTask<java.lang.Void>	forEachFuture(rx.Observable<? extends T> source, rx.functions.Action1<? super T> onNext, rx.Scheduler scheduler) Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future, scheduled on the given scheduler.
static <R> rx.Observable<R>	fromAction(rx.functions.Action0 action, R result) Return an Observable that calls the given action and emits the given result when an Observer subscribes.
static <R> rx.Observable<R>	fromAction(rx.functions.Action0 action, R result, rx.Scheduler scheduler) Return an Observable that calls the given action and emits the given result when an Observer subscribes.
static <R> rx.Observable<R>	fromCallable(java.util.concurrent.Callable<? extends R> callable) Return an Observable that calls the given Callable and emits its result or Exception when an Observer subscribes.
static <R> rx.Observable<R>	fromCallable(java.util.concurrent.Callable<? extends R> callable, rx.Scheduler scheduler) Return an Observable that calls the given Callable and emits its result or Exception when an Observer subscribes.
static <R> rx.Observable<R>	fromRunnable(java.lang.Runnable run, R result) Return an Observable that calls the given Runnable and emits the given result when an Observer subscribes.
static <R> rx.Observable<R>	fromRunnable(java.lang.Runnable run, R result, rx.Scheduler scheduler) Return an Observable that calls the given Runnable and emits the given result when an Observer subscribes.
static <T> StoppableObservable<T>	runAsync(rx.Scheduler scheduler, rx.functions.Action2<? super rx.Observer<? super T>,? super rx.Subscription> action) Runs the provided action on the given scheduler and allows propagation of multiple events to the observers of the returned StoppableObservable.
static <T,U> StoppableObservable<U>	runAsync(rx.Scheduler scheduler, rx.subjects.Subject<T,U> subject, rx.functions.Action2<? super rx.Observer<? super T>,? super rx.Subscription> action) Runs the provided action on the given scheduler and allows propagation of multiple events to the observers of the returned StoppableObservable.
static <T> rx.Observable<T>	start(rx.functions.Func0<T> func) Invokes the specified function asynchronously and returns an Observable that emits the result.
static <T> rx.Observable<T>	start(rx.functions.Func0<T> func, rx.Scheduler scheduler) Invokes the specified function asynchronously on the specified Scheduler and returns an Observable that emits the result.
static <T> rx.Observable<T>	startFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends T>> functionAsync) Invokes the asynchronous function immediately, surfacing the result through an Observable.
static <T> rx.Observable<T>	startFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends T>> functionAsync, rx.Scheduler scheduler) Invokes the asynchronous function immediately, surfacing the result through an Observable and waits on the specified Scheduler.
static rx.functions.Func0<rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action0 action) Convert a synchronous action call into an asynchronous function call through an Observable.
static rx.functions.Func0<rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action0 action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1> rx.functions.Func1<T1,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action1<? super T1> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1> rx.functions.Func1<T1,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action1<? super T1> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2> rx.functions.Func2<T1,T2,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action2<? super T1,? super T2> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2> rx.functions.Func2<T1,T2,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action2<? super T1,? super T2> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3> rx.functions.Func3<T1,T2,T3,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action3<? super T1,? super T2,? super T3> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3> rx.functions.Func3<T1,T2,T3,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action3<? super T1,? super T2,? super T3> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action4<? super T1,? super T2,? super T3,? super T4> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action4<? super T1,? super T2,? super T3,? super T4> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action5<? super T1,? super T2,? super T3,? super T4,? super T5> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action5<? super T1,? super T2,? super T3,? super T4,? super T5> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> action) Convert a synchronous action call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<java.lang.Void>>	toAsync(rx.functions.Action9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static rx.functions.FuncN<rx.Observable<java.lang.Void>>	toAsync(rx.functions.ActionN action) Convert a synchronous action call into an asynchronous function call through an Observable.
static rx.functions.FuncN<rx.Observable<java.lang.Void>>	toAsync(rx.functions.ActionN action, rx.Scheduler scheduler) Convert a synchronous action call into an asynchronous function call through an Observable.
static <R> rx.functions.Func0<rx.Observable<R>>	toAsync(rx.functions.Func0<? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <R> rx.functions.Func0<rx.Observable<R>>	toAsync(rx.functions.Func0<? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,R> rx.functions.Func1<T1,rx.Observable<R>>	toAsync(rx.functions.Func1<? super T1,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,R> rx.functions.Func1<T1,rx.Observable<R>>	toAsync(rx.functions.Func1<? super T1,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,R> rx.functions.Func2<T1,T2,rx.Observable<R>>	toAsync(rx.functions.Func2<? super T1,? super T2,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,R> rx.functions.Func2<T1,T2,rx.Observable<R>>	toAsync(rx.functions.Func2<? super T1,? super T2,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,R> rx.functions.Func3<T1,T2,T3,rx.Observable<R>>	toAsync(rx.functions.Func3<? super T1,? super T2,? super T3,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,R> rx.functions.Func3<T1,T2,T3,rx.Observable<R>>	toAsync(rx.functions.Func3<? super T1,? super T2,? super T3,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,R> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<R>>	toAsync(rx.functions.Func4<? super T1,? super T2,? super T3,? super T4,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,R> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<R>>	toAsync(rx.functions.Func4<? super T1,? super T2,? super T3,? super T4,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,R> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<R>>	toAsync(rx.functions.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,R> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<R>>	toAsync(rx.functions.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,R> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<R>>	toAsync(rx.functions.Func6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,R> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<R>>	toAsync(rx.functions.Func6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,R> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<R>>	toAsync(rx.functions.Func7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,R> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<R>>	toAsync(rx.functions.Func7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<R>>	toAsync(rx.functions.Func8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<R>>	toAsync(rx.functions.Func8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<R>>	toAsync(rx.functions.Func9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<R>>	toAsync(rx.functions.Func9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.
static <R> rx.functions.FuncN<rx.Observable<R>>	toAsync(rx.functions.FuncN<? extends R> func) Convert a synchronous function call into an asynchronous function call through an Observable.
static <R> rx.functions.FuncN<rx.Observable<R>>	toAsync(rx.functions.FuncN<? extends R> func, rx.Scheduler scheduler) Convert a synchronous function call into an asynchronous function call through an Observable.

Methods inherited from class java.lang.Object

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

Method Detail

start

public static <T> rx.Observable<T> start(rx.functions.Func0<T> func)

Invokes the specified function asynchronously and returns an Observable that emits the result.

Note: The function is called immediately and once, not whenever an observer subscribes to the resulting Observable. Multiple subscriptions to this Observable observe the same return value.

Type Parameters:

T - the result value type

Parameters:

func - function to run asynchronously

Returns:

an Observable that emits the function's result value, or notifies observers of an exception

See Also:

RxJava Wiki: start(), MSDN: Observable.Start

start

public static <T> rx.Observable<T> start(rx.functions.Func0<T> func,
                         rx.Scheduler scheduler)

Invokes the specified function asynchronously on the specified Scheduler and returns an Observable that emits the result.

Note: The function is called immediately and once, not whenever an observer subscribes to the resulting Observable. Multiple subscriptions to this Observable observe the same return value.

Type Parameters:

T - the result value type

Parameters:

func - function to run asynchronously

scheduler - Scheduler to run the function on

Returns:

an Observable that emits the function's result value, or notifies observers of an exception

See Also:

RxJava Wiki: start(), MSDN: Observable.Start

toAsync

public static rx.functions.Func0<rx.Observable<java.lang.Void>> toAsync(rx.functions.Action0 action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <R> rx.functions.Func0<rx.Observable<R>> toAsync(rx.functions.Func0<? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

R - the result value type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1> rx.functions.Func1<T1,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action1<? super T1> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - first parameter type of the action

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,R> rx.functions.Func1<T1,rx.Observable<R>> toAsync(rx.functions.Func1<? super T1,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - first parameter type of the action

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2> rx.functions.Func2<T1,T2,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action2<? super T1,? super T2> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,R> rx.functions.Func2<T1,T2,rx.Observable<R>> toAsync(rx.functions.Func2<? super T1,? super T2,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3> rx.functions.Func3<T1,T2,T3,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action3<? super T1,? super T2,? super T3> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,R> rx.functions.Func3<T1,T2,T3,rx.Observable<R>> toAsync(rx.functions.Func3<? super T1,? super T2,? super T3,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action4<? super T1,? super T2,? super T3,? super T4> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,R> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<R>> toAsync(rx.functions.Func4<? super T1,? super T2,? super T3,? super T4,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action5<? super T1,? super T2,? super T3,? super T4,? super T5> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,R> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<R>> toAsync(rx.functions.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,R> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<R>> toAsync(rx.functions.Func6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,R> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<R>> toAsync(rx.functions.Func7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8,R> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<R>> toAsync(rx.functions.Func8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

T9 - the ninth parameter type

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<R>> toAsync(rx.functions.Func9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

T9 - the ninth parameter type

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static rx.functions.FuncN<rx.Observable<java.lang.Void>> toAsync(rx.functions.ActionN action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync()

toAsync

public static <R> rx.functions.FuncN<rx.Observable<R>> toAsync(rx.functions.FuncN<? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync()

toAsync

public static rx.functions.Func0<rx.Observable<java.lang.Void>> toAsync(rx.functions.Action0 action,
                                                        rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <R> rx.functions.Func0<rx.Observable<R>> toAsync(rx.functions.Func0<? extends R> func,
                                               rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1> rx.functions.Func1<T1,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action1<? super T1> action,
                                                                rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

Parameters:

action - the Action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,R> rx.functions.Func1<T1,rx.Observable<R>> toAsync(rx.functions.Func1<? super T1,? extends R> func,
                                                     rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2> rx.functions.Func2<T1,T2,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action2<? super T1,? super T2> action,
                                                                      rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,R> rx.functions.Func2<T1,T2,rx.Observable<R>> toAsync(rx.functions.Func2<? super T1,? super T2,? extends R> func,
                                                           rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3> rx.functions.Func3<T1,T2,T3,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action3<? super T1,? super T2,? super T3> action,
                                                                            rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,R> rx.functions.Func3<T1,T2,T3,rx.Observable<R>> toAsync(rx.functions.Func3<? super T1,? super T2,? super T3,? extends R> func,
                                                                 rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action4<? super T1,? super T2,? super T3,? super T4> action,
                                                                                  rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,R> rx.functions.Func4<T1,T2,T3,T4,rx.Observable<R>> toAsync(rx.functions.Func4<? super T1,? super T2,? super T3,? super T4,? extends R> func,
                                                                       rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action5<? super T1,? super T2,? super T3,? super T4,? super T5> action,
                                                                                        rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,R> rx.functions.Func5<T1,T2,T3,T4,T5,rx.Observable<R>> toAsync(rx.functions.Func5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> func,
                                                                             rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> action,
                                                                                              rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,R> rx.functions.Func6<T1,T2,T3,T4,T5,T6,rx.Observable<R>> toAsync(rx.functions.Func6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> func,
                                                                                   rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7> action,
                                                                                                    rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,R> rx.functions.Func7<T1,T2,T3,T4,T5,T6,T7,rx.Observable<R>> toAsync(rx.functions.Func7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> func,
                                                                                         rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8> action,
                                                                                                          rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8,R> rx.functions.Func8<T1,T2,T3,T4,T5,T6,T7,T8,rx.Observable<R>> toAsync(rx.functions.Func8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> func,
                                                                                               rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<java.lang.Void>> toAsync(rx.functions.Action9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> action,
                                                                                                                rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

T9 - the ninth parameter type

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> rx.functions.Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,rx.Observable<R>> toAsync(rx.functions.Func9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> func,
                                                                                                     rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

T1 - the first parameter type

T2 - the second parameter type

T3 - the third parameter type

T4 - the fourth parameter type

T5 - the fifth parameter type

T6 - the sixth parameter type

T7 - the seventh parameter type

T8 - the eighth parameter type

T9 - the ninth parameter type

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync(), MSDN: Observable.ToAsync

toAsync

public static rx.functions.FuncN<rx.Observable<java.lang.Void>> toAsync(rx.functions.ActionN action,
                                                        rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: toAsync()

toAsync

public static <R> rx.functions.FuncN<rx.Observable<R>> toAsync(rx.functions.FuncN<? extends R> func,
                                               rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Type Parameters:

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: toAsync()

asyncAction

public static rx.functions.FuncN<rx.Observable<java.lang.Void>> asyncAction(rx.functions.ActionN action)

Convert a synchronous action call into an asynchronous function call through an Observable.

Alias for toAsync(ActionN) intended for dynamic languages.

Parameters:

action - the action to convert

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: asyncAction()

asyncAction

public static rx.functions.FuncN<rx.Observable<java.lang.Void>> asyncAction(rx.functions.ActionN action,
                                                            rx.Scheduler scheduler)

Convert a synchronous action call into an asynchronous function call through an Observable.

Alias for toAsync(ActionN, Scheduler) intended for dynamic languages.

Parameters:

action - the action to convert

scheduler - the Scheduler used to execute the action

Returns:

a function that returns an Observable that executes the action and emits null

See Also:

RxJava Wiki: asyncAction()

asyncFunc

public static <R> rx.functions.FuncN<rx.Observable<R>> asyncFunc(rx.functions.FuncN<? extends R> func)

Convert a synchronous function call into an asynchronous function call through an Observable.

Alias for toAsync(FuncN) intended for dynamic languages.

Type Parameters:

R - the result type

Parameters:

func - the function to convert

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: asyncFunc()

asyncFunc

public static <R> rx.functions.FuncN<rx.Observable<R>> asyncFunc(rx.functions.FuncN<? extends R> func,
                                                 rx.Scheduler scheduler)

Convert a synchronous function call into an asynchronous function call through an Observable.

Alias for toAsync(FuncN, Scheduler) intended for dynamic languages.

Type Parameters:

R - the result type

Parameters:

func - the function to convert

scheduler - the Scheduler used to call the func

Returns:

a function that returns an Observable that executes the func and emits its returned value

See Also:

RxJava Wiki: asyncFunc()

startFuture

public static <T> rx.Observable<T> startFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends T>> functionAsync)

Invokes the asynchronous function immediately, surfacing the result through an Observable.

Important note subscribing to the resulting Observable blocks until the future completes.

Type Parameters:

T - the result type

Parameters:

functionAsync - the asynchronous function to run

Returns:

an Observable that surfaces the result of the future

See Also:

startFuture(rx.functions.Func0, rx.Scheduler), RxJava Wiki: startFuture()

startFuture

public static <T> rx.Observable<T> startFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends T>> functionAsync,
                               rx.Scheduler scheduler)

Invokes the asynchronous function immediately, surfacing the result through an Observable and waits on the specified Scheduler.

Type Parameters:

T - the result type

Parameters:

functionAsync - the asynchronous function to run

scheduler - the Scheduler where the completion of the Future is awaited

Returns:

an Observable that surfaces the result of the future

See Also:

RxJava Wiki: startFuture()

deferFuture

public static <T> rx.Observable<T> deferFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends rx.Observable<? extends T>>> observableFactoryAsync)

Returns an Observable that starts the specified asynchronous factory function whenever a new observer subscribes.

Important note subscribing to the resulting Observable blocks until the future completes.

Type Parameters:

T - the result type

Parameters:

observableFactoryAsync - the asynchronous function to start for each observer

Returns:

the Observable emitting items produced by the asynchronous observer produced by the factory

See Also:

deferFuture(rx.functions.Func0, rx.Scheduler), RxJava Wiki: deferFuture()

deferFuture

public static <T> rx.Observable<T> deferFuture(rx.functions.Func0<? extends java.util.concurrent.Future<? extends rx.Observable<? extends T>>> observableFactoryAsync,
                               rx.Scheduler scheduler)

Returns an Observable that starts the specified asynchronous factory function whenever a new observer subscribes.

Type Parameters:

T - the result type

Parameters:

observableFactoryAsync - the asynchronous function to start for each observer

scheduler - the Scheduler where the completion of the Future is awaited

Returns:

the Observable emitting items produced by the asynchronous observer produced by the factory

See Also:

RxJava Wiki: deferFuture()

forEachFuture

public static <T> java.util.concurrent.FutureTask<java.lang.Void> forEachFuture(rx.Observable<? extends T> source,
                                                                rx.functions.Action1<? super T> onNext)

Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future.

Important note: The returned task blocks indefinitely unless the run() method is called or the task is scheduled on an Executor.

Type Parameters:

T - the source value type

Parameters:

source - the source Observable

onNext - the action to call with each emitted element

Returns:

the Future representing the entire for-each operation

See Also:

forEachFuture(rx.Observable, rx.functions.Action1, rx.Scheduler), RxJava Wiki: forEachFuture()

forEachFuture

public static <T> java.util.concurrent.FutureTask<java.lang.Void> forEachFuture(rx.Observable<? extends T> source,
                                                                rx.functions.Action1<? super T> onNext,
                                                                rx.functions.Action1<? super java.lang.Throwable> onError)

Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future.

Important note: The returned task blocks indefinitely unless the run() method is called or the task is scheduled on an Executor.

Type Parameters:

T - the source value type

Parameters:

source - the source Observable

onNext - the action to call with each emitted element

onError - the action to call when an exception is emitted

Returns:

the Future representing the entire for-each operation

See Also:

forEachFuture(rx.Observable, rx.functions.Action1, rx.functions.Action1, rx.Scheduler), RxJava Wiki: forEachFuture()

forEachFuture

public static <T> java.util.concurrent.FutureTask<java.lang.Void> forEachFuture(rx.Observable<? extends T> source,
                                                                rx.functions.Action1<? super T> onNext,
                                                                rx.functions.Action1<? super java.lang.Throwable> onError,
                                                                rx.functions.Action0 onCompleted)

Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future.

Important note: The returned task blocks indefinitely unless the run() method is called or the task is scheduled on an Executor.

Type Parameters:

T - the source value type

Parameters:

source - the source Observable

onNext - the action to call with each emitted element

onError - the action to call when an exception is emitted

onCompleted - the action to call when the source completes

Returns:

the Future representing the entire for-each operation

See Also:

forEachFuture(rx.Observable, rx.functions.Action1, rx.functions.Action1, rx.functions.Action0, rx.Scheduler), RxJava Wiki: forEachFuture()

forEachFuture

public static <T> java.util.concurrent.FutureTask<java.lang.Void> forEachFuture(rx.Observable<? extends T> source,
                                                                rx.functions.Action1<? super T> onNext,
                                                                rx.Scheduler scheduler)

Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future, scheduled on the given scheduler.

Type Parameters:

T - the source value type

Parameters:

source - the source Observable

onNext - the action to call with each emitted element

scheduler - the Scheduler where the task will await the termination of the for-each

Returns:

the Future representing the entire for-each operation

See Also:

RxJava Wiki: forEachFuture()

forEachFuture

public static <T> java.util.concurrent.FutureTask<java.lang.Void> forEachFuture(rx.Observable<? extends T> source,
                                                                rx.functions.Action1<? super T> onNext,
                                                                rx.functions.Action1<? super java.lang.Throwable> onError,
                                                                rx.Scheduler scheduler)

Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future, scheduled on the given Scheduler.

Type Parameters:

T - the source value type

Parameters:

source - the source Observable

onNext - the action to call with each emitted element

onError - the action to call when an exception is emitted

scheduler - the Scheduler where the task will await the termination of the for-each

Returns:

the Future representing the entire for-each operation

See Also:

RxJava Wiki: forEachFuture()

forEachFuture

public static <T> java.util.concurrent.FutureTask<java.lang.Void> forEachFuture(rx.Observable<? extends T> source,
                                                                rx.functions.Action1<? super T> onNext,
                                                                rx.functions.Action1<? super java.lang.Throwable> onError,
                                                                rx.functions.Action0 onCompleted,
                                                                rx.Scheduler scheduler)

Subscribes to the given source and calls the callback for each emitted item, and surfaces the completion or error through a Future, scheduled on the given Scheduler.

Type Parameters:

T - the source value type

Parameters:

source - the source Observable

onNext - the action to call with each emitted element

onError - the action to call when an exception is emitted

onCompleted - the action to call when the source completes

scheduler - the Scheduler where the task will await the termination of the for-each

Returns:

the Future representing the entire for-each operation

See Also:

RxJava Wiki: forEachFuture()

fromAction

public static <R> rx.Observable<R> fromAction(rx.functions.Action0 action,
                              R result)

Return an Observable that calls the given action and emits the given result when an Observer subscribes.

The action is run on the default thread pool for computation.

Type Parameters:

R - the return type

Parameters:

action - the action to invoke on each subscription

result - the result to emit to observers

Returns:

an Observable that calls the given action and emits the given result when an Observer subscribes

See Also:

RxJava Wiki: fromAction()

fromCallable

public static <R> rx.Observable<R> fromCallable(java.util.concurrent.Callable<? extends R> callable)

Return an Observable that calls the given Callable and emits its result or Exception when an Observer subscribes.

The Callable is called on the default thread pool for computation.

Type Parameters:

R - the return type

Parameters:

callable - the callable to call on each subscription

Returns:

an Observable that calls the given Callable and emits its result or Exception when an Observer subscribes

See Also:

start(rx.functions.Func0), RxJava Wiki: fromCallable()

fromRunnable

public static <R> rx.Observable<R> fromRunnable(java.lang.Runnable run,
                                R result)

Return an Observable that calls the given Runnable and emits the given result when an Observer subscribes.

The Runnable is called on the default thread pool for computation.

Type Parameters:

R - the return type

Parameters:

run - the runnable to invoke on each subscription

result - the result to emit to observers

Returns:

an Observable that calls the given Runnable and emits the given result when an Observer subscribes

See Also:

RxJava Wiki: fromRunnable()

fromAction

public static <R> rx.Observable<R> fromAction(rx.functions.Action0 action,
                              R result,
                              rx.Scheduler scheduler)

Return an Observable that calls the given action and emits the given result when an Observer subscribes.

Type Parameters:

R - the return type

Parameters:

action - the action to invoke on each subscription

scheduler - the Scheduler where the function is called and the result is emitted

result - the result to emit to observers

Returns:

an Observable that calls the given action and emits the given result when an Observer subscribes

See Also:

RxJava Wiki: fromAction()

fromCallable

public static <R> rx.Observable<R> fromCallable(java.util.concurrent.Callable<? extends R> callable,
                                rx.Scheduler scheduler)

Return an Observable that calls the given Callable and emits its result or Exception when an Observer subscribes.

Type Parameters:

R - the return type

Parameters:

callable - the callable to call on each subscription

scheduler - the Scheduler where the function is called and the result is emitted

Returns:

an Observable that calls the given Callable and emits its result or Exception when an Observer subscribes

See Also:

start(rx.functions.Func0), RxJava Wiki: fromCallable()

fromRunnable

public static <R> rx.Observable<R> fromRunnable(java.lang.Runnable run,
                                R result,
                                rx.Scheduler scheduler)

Return an Observable that calls the given Runnable and emits the given result when an Observer subscribes.

Type Parameters:

R - the return type

Parameters:

run - the runnable to invoke on each subscription

scheduler - the Scheduler where the function is called and the result is emitted

result - the result to emit to observers

Returns:

an Observable that calls the given Runnable and emits the given result when an Observer subscribes

See Also:

RxJava Wiki: fromRunnable()

runAsync

public static <T> StoppableObservable<T> runAsync(rx.Scheduler scheduler,
                                  rx.functions.Action2<? super rx.Observer<? super T>,? super rx.Subscription> action)

Runs the provided action on the given scheduler and allows propagation of multiple events to the observers of the returned StoppableObservable. The action is immediately executed and unobserved values will be lost.

Type Parameters:

T - the output value type

Parameters:

scheduler - the Scheduler where the action is executed

action - the action to execute, receives an Observer where the events can be pumped and a Subscription which lets it check for cancellation condition

Returns:

an Observable that provides a Subscription interface to cancel the action

See Also:

RxJava Wiki: runAsync()

runAsync

public static <T,U> StoppableObservable<U> runAsync(rx.Scheduler scheduler,
                                    rx.subjects.Subject<T,U> subject,
                                    rx.functions.Action2<? super rx.Observer<? super T>,? super rx.Subscription> action)

Runs the provided action on the given scheduler and allows propagation of multiple events to the observers of the returned StoppableObservable. The action is immediately executed and unobserved values might be lost, depending on the Subject type used.

Type Parameters:

T - the output value of the action

U - the output type of the observable sequence

Parameters:

scheduler - the Scheduler where the action is executed

subject - the subject to use to distribute values emitted by the action

action - the action to execute, receives an Observer where the events can be pumped and a Subscription which lets it check for cancellation condition

Returns:

an Observable that provides a Subscription interface to cancel the action

See Also:

RxJava Wiki: runAsync()