T
- the type of the item emitted by the Single@Experimental public class Single<T> extends java.lang.Object
Observable
for the
implementation of the Reactive Pattern for a stream or vector of values.
Single
behaves the same as Observable
except that it can only emit either a single successful
value, or an error (there is no "onComplete" notification as there is for Observable
)
Like an Observable
, a Single
is lazy, can be either "hot" or "cold", synchronous or
asynchronous.
The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
For more information see the ReactiveX documentation.
Modifier and Type | Class and Description |
---|---|
static interface |
Single.OnSubscribe<T>
Invoked when Single.execute is called.
|
static interface |
Single.Transformer<T,R>
Transformer function used by
compose(rx.Single.Transformer<? super T, ? extends R>) . |
Modifier | Constructor and Description |
---|---|
protected |
Single(Single.OnSubscribe<T> f)
Creates a Single with a Function to execute when it is subscribed to (executed).
|
Modifier and Type | Method and Description |
---|---|
<R> Single<R> |
compose(Single.Transformer<? super T,? extends R> transformer)
Transform a Single by applying a particular Transformer function to it.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2)
Returns an Observable that emits the items emitted by two Singles, one after the other.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3)
Returns an Observable that emits the items emitted by three Singles, one after the other.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4)
Returns an Observable that emits the items emitted by four Singles, one after the other.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5)
Returns an Observable that emits the items emitted by five Singles, one after the other.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6)
Returns an Observable that emits the items emitted by six Singles, one after the other.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6,
Single<? extends T> t7)
Returns an Observable that emits the items emitted by seven Singles, one after the other.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6,
Single<? extends T> t7,
Single<? extends T> t8)
Returns an Observable that emits the items emitted by eight Singles, one after the other.
|
static <T> Observable<T> |
concat(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6,
Single<? extends T> t7,
Single<? extends T> t8,
Single<? extends T> t9)
Returns an Observable that emits the items emitted by nine Singles, one after the other.
|
Observable<T> |
concatWith(Single<? extends T> t1)
Returns an Observable that emits the item emitted by the source Single, then the item emitted by the
specified Single.
|
static <T> Single<T> |
create(Single.OnSubscribe<T> f)
Returns a Single that will execute the specified function when a
SingleSubscriber executes it or
a Subscriber subscribes to it. |
static <T> Single<T> |
error(java.lang.Throwable exception)
Returns a Single that invokes a subscriber's
onError method when the
subscriber subscribes to it. |
<R> Single<R> |
flatMap(Func1<? super T,? extends Single<? extends R>> func)
Returns a Single that is based on applying a specified function to the item emitted by the source Single,
where that function returns a Single.
|
<R> Observable<R> |
flatMapObservable(Func1<? super T,? extends Observable<? extends R>> func)
Returns an Observable that emits items based on applying a specified function to the item emitted by the
source Observable, where that function returns an Observable.
|
static <T> Single<T> |
from(java.util.concurrent.Future<? extends T> future)
Converts a
Future into a Single . |
static <T> Single<T> |
from(java.util.concurrent.Future<? extends T> future,
long timeout,
java.util.concurrent.TimeUnit unit)
Converts a
Future into a Single , with a timeout on the Future. |
static <T> Single<T> |
from(java.util.concurrent.Future<? extends T> future,
Scheduler scheduler)
|
static <T> Single<T> |
just(T value)
Returns a
Single that emits a specified item. |
<R> Single<R> |
map(Func1<? super T,? extends R> func)
Returns a Single that applies a specified function to the item emitted by the source Single and
emits the result of this function application.
|
static <T> Single<T> |
merge(Single<? extends Single<? extends T>> source)
Flattens a
Single that emits a Single into a single Single that emits the item
emitted by the nested Single , without any transformation. |
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2)
Flattens two Singles into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3)
Flattens three Singles into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4)
Flattens four Singles into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5)
Flattens five Singles into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6)
Flattens six Singles into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6,
Single<? extends T> t7)
Flattens seven Singles into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6,
Single<? extends T> t7,
Single<? extends T> t8)
Flattens eight Singles into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(Single<? extends T> t1,
Single<? extends T> t2,
Single<? extends T> t3,
Single<? extends T> t4,
Single<? extends T> t5,
Single<? extends T> t6,
Single<? extends T> t7,
Single<? extends T> t8,
Single<? extends T> t9)
Flattens nine Singles into a single Observable, without any transformation.
|
Observable<T> |
mergeWith(Single<? extends T> t1)
Flattens this and another Single into a single Observable, without any transformation.
|
Single<T> |
observeOn(Scheduler scheduler)
Modifies a Single to emit its item (or notify of its error) on a specified
Scheduler ,
asynchronously. |
Single<T> |
onErrorReturn(Func1<java.lang.Throwable,? extends T> resumeFunction)
Instructs a Single to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Subscription |
subscribe()
Subscribes to a Single but ignore its emission or notification.
|
Subscription |
subscribe(Action1<? super T> onSuccess)
Subscribes to a Single and provides a callback to handle the item it emits.
|
Subscription |
subscribe(Action1<? super T> onSuccess,
Action1<java.lang.Throwable> onError)
Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it
issues.
|
Subscription |
subscribe(SingleSubscriber<? super T> te)
Subscribes to a Single and provides a
SingleSubscriber that implements functions to handle the
item the Single emits or any error notification it issues. |
Subscription |
subscribe(Subscriber<? super T> subscriber)
Subscribes to a Single and provides a Subscriber that implements functions to handle the item the Single
emits or any error notification it issues.
|
Single<T> |
subscribeOn(Scheduler scheduler)
Asynchronously subscribes subscribers to this Single on the specified
Scheduler . |
Single<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit)
Returns a Single that mirrors the source Single but applies a timeout policy for its emitted item.
|
Single<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit,
Scheduler scheduler)
Returns a Single that mirrors the source Single but applies a timeout policy for its emitted item, where
this policy is governed on a specified Scheduler.
|
Single<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit,
Single<? extends T> other)
Returns a Single that mirrors the source Single but applies a timeout policy for its emitted item.
|
Single<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit,
Single<? extends T> other,
Scheduler scheduler)
Returns a Single that mirrors the source Single but applies a timeout policy for its emitted item, using
a specified Scheduler.
|
Observable<T> |
toObservable()
Converts this Single into an
Observable . |
void |
unsafeSubscribe(Subscriber<? super T> subscriber)
Subscribes to a Single and invokes the
Single.OnSubscribe function without any contract protection,
error handling, unsubscribe, or execution hooks. |
static <T1,T2,R> Single<R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Func2<? super T1,? super T2,? extends R> zipFunction)
Returns a Single that emits the results of a specified combiner function applied to two items emitted by
two other Singles.
|
static <T1,T2,T3,R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Single<? extends T3> o3,
Func3<? super T1,? super T2,? super T3,? extends R> zipFunction)
Returns a Single that emits the results of a specified combiner function applied to three items emitted
by three other Singles.
|
static <T1,T2,T3,T4,R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Single<? extends T3> o3,
Single<? extends T4> o4,
Func4<? super T1,? super T2,? super T3,? super T4,? extends R> zipFunction)
Returns an Observable that emits the results of a specified combiner function applied to four items
emitted by four other Singles.
|
static <T1,T2,T3,T4,T5,R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Single<? extends T3> o3,
Single<? extends T4> o4,
Single<? extends T5> o5,
Func5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipFunction)
Returns an Observable that emits the results of a specified combiner function applied to five items
emitted by five other Singles.
|
static <T1,T2,T3,T4,T5,T6,R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Single<? extends T3> o3,
Single<? extends T4> o4,
Single<? extends T5> o5,
Single<? extends T6> o6,
Func6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipFunction)
Returns an Observable that emits the results of a specified combiner function applied to six items
emitted by six other Singles.
|
static <T1,T2,T3,T4,T5,T6,T7,R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Single<? extends T3> o3,
Single<? extends T4> o4,
Single<? extends T5> o5,
Single<? extends T6> o6,
Single<? extends T7> o7,
Func7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipFunction)
Returns an Observable that emits the results of a specified combiner function applied to seven items
emitted by seven other Singles.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Single<? extends T3> o3,
Single<? extends T4> o4,
Single<? extends T5> o5,
Single<? extends T6> o6,
Single<? extends T7> o7,
Single<? extends T8> o8,
Func8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipFunction)
Returns an Observable that emits the results of a specified combiner function applied to eight items
emitted by eight other Singles.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
zip(Single<? extends T1> o1,
Single<? extends T2> o2,
Single<? extends T3> o3,
Single<? extends T4> o4,
Single<? extends T5> o5,
Single<? extends T6> o6,
Single<? extends T7> o7,
Single<? extends T8> o8,
Single<? extends T9> o9,
Func9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipFunction)
Returns an Observable that emits the results of a specified combiner function applied to nine items
emitted by nine other Singles.
|
<T2,R> Single<R> |
zipWith(Single<? extends T2> other,
Func2<? super T,? super T2,? extends R> zipFunction)
Returns a Single that emits the result of applying a specified function to the pair of items emitted by
the source Single and another specified Single.
|
protected Single(Single.OnSubscribe<T> f)
Note: Use create(OnSubscribe)
to create a Single, instead of this constructor,
unless you specifically have a need for inheritance.
f
- OnExecute
to be executed when execute(SingleSubscriber)
or
subscribe(Subscriber)
is calledpublic static final <T> Single<T> create(Single.OnSubscribe<T> f)
SingleSubscriber
executes it or
a Subscriber
subscribes to it.
Write the function you pass to create
so that it behaves as a Single: It should invoke the
SingleSubscriber onSuccess
and/or
onError
methods appropriately.
A well-formed Single must invoke either the SingleSubscriber's onSuccess
method exactly once or
its onError
method exactly once.
create
does not operate by default on a particular Scheduler
.T
- the type of the item that this Single emitsf
- a function that accepts an SingleSubscriber<T>
, and invokes its onSuccess
or
onError
methods as appropriateSubscriber
subscribes to it, will execute the specified functionpublic <R> Single<R> compose(Single.Transformer<? super T,? extends R> transformer)
This method operates on the Single itself whereas lift(rx.Observable.Operator<? extends R, ? super T>)
operates on the Single's Subscribers or
Observers.
If the operator you are creating is designed to act on the individual item emitted by a Single, use
lift(rx.Observable.Operator<? extends R, ? super T>)
. If your operator is designed to transform the source Single as a whole (for instance, by
applying a particular set of existing RxJava operators to it) use compose
.
compose
does not operate by default on a particular Scheduler
.transformer
- implements the function that transforms the source Singlepublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2)
concat
does not operate by default on a particular Scheduler
.t1
- an Single to be concatenatedt2
- an Single to be concatenatedpublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenatedt2
- a Single to be concatenatedt3
- a Single to be concatenatedpublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenatedt2
- a Single to be concatenatedt3
- a Single to be concatenatedt4
- a Single to be concatenatedpublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenatedt2
- a Single to be concatenatedt3
- a Single to be concatenatedt4
- a Single to be concatenatedt5
- a Single to be concatenatedpublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenatedt2
- a Single to be concatenatedt3
- a Single to be concatenatedt4
- a Single to be concatenatedt5
- a Single to be concatenatedt6
- a Single to be concatenatedpublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6, Single<? extends T> t7)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenatedt2
- a Single to be concatenatedt3
- a Single to be concatenatedt4
- a Single to be concatenatedt5
- a Single to be concatenatedt6
- a Single to be concatenatedt7
- a Single to be concatenatedpublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6, Single<? extends T> t7, Single<? extends T> t8)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenatedt2
- a Single to be concatenatedt3
- a Single to be concatenatedt4
- a Single to be concatenatedt5
- a Single to be concatenatedt6
- a Single to be concatenatedt7
- a Single to be concatenatedt8
- a Single to be concatenatedpublic static final <T> Observable<T> concat(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6, Single<? extends T> t7, Single<? extends T> t8, Single<? extends T> t9)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenatedt2
- a Single to be concatenatedt3
- a Single to be concatenatedt4
- a Single to be concatenatedt5
- a Single to be concatenatedt6
- a Single to be concatenatedt7
- a Single to be concatenatedt8
- a Single to be concatenatedt9
- a Single to be concatenatedpublic static final <T> Single<T> error(java.lang.Throwable exception)
onError
method when the
subscriber subscribes to it.
error
does not operate by default on a particular Scheduler
.T
- the type of the item (ostensibly) emitted by the Singleexception
- the particular Throwable to pass to onError
onError
method when
the subscriber subscribes to itpublic static final <T> Single<T> from(java.util.concurrent.Future<? extends T> future)
Future
into a Single
.
You can convert any object that supports the Future
interface into a Single that emits the return
value of the Future.get()
method of that object, by passing the object into the from
method.
Important note: This Single is blocking; you cannot unsubscribe from it.
from
does not operate by default on a particular Scheduler
.T
- the type of object that the Future
returns, and also the type of item to be emitted by
the resulting Single
future
- the source Future
Single
that emits the item from the source Future
public static final <T> Single<T> from(java.util.concurrent.Future<? extends T> future, long timeout, java.util.concurrent.TimeUnit unit)
Future
into a Single
, with a timeout on the Future.
You can convert any object that supports the Future
interface into a Single
that emits
the return value of the Future.get()
method of that object, by passing the object into the
from
method.
Important note: This Single
is blocking; you cannot unsubscribe from it.
from
does not operate by default on a particular Scheduler
.T
- the type of object that the Future
returns, and also the type of item to be emitted by
the resulting Single
future
- the source Future
timeout
- the maximum time to wait before calling get
unit
- the TimeUnit
of the timeout
argumentSingle
that emits the item from the source Future
public static final <T> Single<T> from(java.util.concurrent.Future<? extends T> future, Scheduler scheduler)
Future
, operating on a specified Scheduler
, into a Single
.
You can convert any object that supports the Future
interface into a Single
that emits
the return value of the Future.get()
method of that object, by passing the object into the
from
method.
Scheduler
this operator will useT
- the type of object that the Future
returns, and also the type of item to be emitted by
the resulting Single
future
- the source Future
scheduler
- the Scheduler
to wait for the Future on. Use a Scheduler such as
Schedulers.io()
that can block and wait on the FutureSingle
that emits the item from the source Future
public static final <T> Single<T> just(T value)
Single
that emits a specified item.
To convert any object into a Single
that emits that object, pass that object into the
just
method.
just
does not operate by default on a particular Scheduler
.T
- the type of that itemvalue
- the item to emitSingle
that emits value
public static final <T> Single<T> merge(Single<? extends Single<? extends T>> source)
Single
that emits a Single
into a single Single
that emits the item
emitted by the nested Single
, without any transformation.
merge
does not operate by default on a particular Scheduler
.source
- a Single
that emits a Single
Single
that emits the item that is the result of flattening the Single
emitted
by source
public static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by
using the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedpublic static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedt3
- a Single to be mergedpublic static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedt3
- a Single to be mergedt4
- a Single to be mergedpublic static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedt3
- a Single to be mergedt4
- a Single to be mergedt5
- a Single to be mergedpublic static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedt3
- a Single to be mergedt4
- a Single to be mergedt5
- a Single to be mergedt6
- a Single to be mergedpublic static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6, Single<? extends T> t7)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedt3
- a Single to be mergedt4
- a Single to be mergedt5
- a Single to be mergedt6
- a Single to be mergedt7
- a Single to be mergedpublic static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6, Single<? extends T> t7, Single<? extends T> t8)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedt3
- a Single to be mergedt4
- a Single to be mergedt5
- a Single to be mergedt6
- a Single to be mergedt7
- a Single to be mergedt8
- a Single to be mergedpublic static final <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T> t2, Single<? extends T> t3, Single<? extends T> t4, Single<? extends T> t5, Single<? extends T> t6, Single<? extends T> t7, Single<? extends T> t8, Single<? extends T> t9)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the merge
method.
merge
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedt2
- a Single to be mergedt3
- a Single to be mergedt4
- a Single to be mergedt5
- a Single to be mergedt6
- a Single to be mergedt7
- a Single to be mergedt8
- a Single to be mergedt9
- a Single to be mergedpublic static final <T1,T2,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Func2<? super T1,? super T2,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic static final <T1,T2,T3,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Single<? extends T3> o3, Func3<? super T1,? super T2,? super T3,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source Singleo3
- a third source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic static final <T1,T2,T3,T4,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Single<? extends T3> o3, Single<? extends T4> o4, Func4<? super T1,? super T2,? super T3,? super T4,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source Singleo3
- a third source Singleo4
- a fourth source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic static final <T1,T2,T3,T4,T5,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Single<? extends T3> o3, Single<? extends T4> o4, Single<? extends T5> o5, Func5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source Singleo3
- a third source Singleo4
- a fourth source Singleo5
- a fifth source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic static final <T1,T2,T3,T4,T5,T6,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Single<? extends T3> o3, Single<? extends T4> o4, Single<? extends T5> o5, Single<? extends T6> o6, Func6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source Singleo3
- a third source Singleo4
- a fourth source Singleo5
- a fifth source Singleo6
- a sixth source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic static final <T1,T2,T3,T4,T5,T6,T7,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Single<? extends T3> o3, Single<? extends T4> o4, Single<? extends T5> o5, Single<? extends T6> o6, Single<? extends T7> o7, Func7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source Singleo3
- a third source Singleo4
- a fourth source Singleo5
- a fifth source Singleo6
- a sixth source Singleo7
- a seventh source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic static final <T1,T2,T3,T4,T5,T6,T7,T8,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Single<? extends T3> o3, Single<? extends T4> o4, Single<? extends T5> o5, Single<? extends T6> o6, Single<? extends T7> o7, Single<? extends T8> o8, Func8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source Singleo3
- a third source Singleo4
- a fourth source Singleo5
- a fifth source Singleo6
- a sixth source Singleo7
- a seventh source Singleo8
- an eighth source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic static final <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Single<R> zip(Single<? extends T1> o1, Single<? extends T2> o2, Single<? extends T3> o3, Single<? extends T4> o4, Single<? extends T5> o5, Single<? extends T6> o6, Single<? extends T7> o7, Single<? extends T8> o8, Single<? extends T9> o9, Func9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipFunction)
zip
does not operate by default on a particular Scheduler
.o1
- the first source Singleo2
- a second source Singleo3
- a third source Singleo4
- a fourth source Singleo5
- a fifth source Singleo6
- a sixth source Singleo7
- a seventh source Singleo8
- an eighth source Singleo9
- a ninth source SinglezipFunction
- a function that, when applied to the item emitted by each of the source Singles, results in an
item that will be emitted by the resulting Singlepublic final Observable<T> concatWith(Single<? extends T> t1)
concat
does not operate by default on a particular Scheduler
.t1
- a Single to be concatenated after the currentt1
public final <R> Single<R> flatMap(Func1<? super T,? extends Single<? extends R>> func)
flatMap
does not operate by default on a particular Scheduler
.func
- a function that, when applied to the item emitted by the source Single, returns a Singlefunc
when applied to the item emitted by the source Singlepublic final <R> Observable<R> flatMapObservable(Func1<? super T,? extends Observable<? extends R>> func)
flatMapObservable
does not operate by default on a particular Scheduler
.func
- a function that, when applied to the item emitted by the source Single, returns an
Observablefunc
when applied to the item emitted by the source Singlepublic final <R> Single<R> map(Func1<? super T,? extends R> func)
map
does not operate by default on a particular Scheduler
.func
- a function to apply to the item emitted by the Singlepublic final Observable<T> mergeWith(Single<? extends T> t1)
You can combine items emitted by multiple Singles so that they appear as a single Observable, by using
the mergeWith
method.
mergeWith
does not operate by default on a particular Scheduler
.t1
- a Single to be mergedpublic final Single<T> observeOn(Scheduler scheduler)
Scheduler
,
asynchronously.
Scheduler
this operator will usescheduler
- the Scheduler
to notify subscribers onScheduler
subscribeOn(rx.Scheduler)
public final Single<T> onErrorReturn(Func1<java.lang.Throwable,? extends T> resumeFunction)
onError
if it encounters an error.
By default, when a Single encounters an error that prevents it from emitting the expected item to its
subscriber, the Single invokes its subscriber's Observer.onError(java.lang.Throwable)
method, and then quits
without invoking any more of its subscriber's methods. The onErrorReturn
method changes this
behavior. If you pass a function (resumeFunction
) to a Single's onErrorReturn
method, if
the original Single encounters an error, instead of invoking its subscriber's
Observer.onError(java.lang.Throwable)
method, it will instead emit the return value of resumeFunction
.
You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
onErrorReturn
does not operate by default on a particular Scheduler
.resumeFunction
- a function that returns an item that the new Single will emit if the source Single encounters
an errorpublic final Subscription subscribe()
subscribe
does not operate by default on a particular Scheduler
.Subscription
reference can request the Single
stop work.OnErrorNotImplementedException
- if the Single tries to call Observer.onError(java.lang.Throwable)
public final Subscription subscribe(Action1<? super T> onSuccess)
subscribe
does not operate by default on a particular Scheduler
.onSuccess
- the Action1<T>
you have designed to accept the emission from the SingleSubscription
reference can request the Single
stop work.java.lang.IllegalArgumentException
- if onNext
is nullOnErrorNotImplementedException
- if the Single tries to call Observer.onError(java.lang.Throwable)
public final Subscription subscribe(Action1<? super T> onSuccess, Action1<java.lang.Throwable> onError)
subscribe
does not operate by default on a particular Scheduler
.onSuccess
- the Action1<T>
you have designed to accept the emission from the SingleonError
- the Action1<Throwable>
you have designed to accept any error notification from the
SingleSubscription
reference can request the Single
stop work.java.lang.IllegalArgumentException
- if onNext
is null, or
if onError
is nullpublic final void unsafeSubscribe(Subscriber<? super T> subscriber)
Single.OnSubscribe
function without any contract protection,
error handling, unsubscribe, or execution hooks.
Use this only for implementing an Observable.Operator
that requires nested subscriptions. For other
purposes, use subscribe(Subscriber)
which ensures the Rx contract and other functionality.
unsafeSubscribe
does not operate by default on a particular Scheduler
.subscriber
- the Subscriber that will handle the emission or notification from the Singlepublic final Subscription subscribe(Subscriber<? super T> subscriber)
A typical implementation of subscribe
does the following:
List<T>
object.Subscription
interface. This enables Subscribers to
unsubscribe, that is, to stop receiving the item or notification before the Single completes.
A Single<T>
instance is responsible for accepting all subscriptions and notifying all
Subscribers. Unless the documentation for a particular Single<T>
implementation indicates
otherwise, Subscribers should make no assumptions about the order in which multiple Subscribers will
receive their notifications.
For more information see the ReactiveX documentation.
subscribe
does not operate by default on a particular Scheduler
.subscriber
- the Subscriber
that will handle the emission or notification from the SingleSubscription
reference can request the Single
stop work.java.lang.IllegalStateException
- if subscribe
is unable to obtain an OnSubscribe<>
functionjava.lang.IllegalArgumentException
- if the Subscriber
provided as the argument to subscribe
is null
OnErrorNotImplementedException
- if the Subscriber
's onError
method is nulljava.lang.RuntimeException
- if the Subscriber
's onError
method itself threw a Throwable
public final Subscription subscribe(SingleSubscriber<? super T> te)
SingleSubscriber
that implements functions to handle the
item the Single emits or any error notification it issues.
A typical implementation of subscribe
does the following:
List<T>
object.Subscription
interface. This enables Subscribers to
unsubscribe, that is, to stop receiving the item or notification before the Single completes.
A Single<T>
instance is responsible for accepting all subscriptions and notifying all
Subscribers. Unless the documentation for a particular Single<T>
implementation indicates
otherwise, Subscribers should make no assumptions about the order in which multiple Subscribers will
receive their notifications.
For more information see the ReactiveX documentation.
subscribe
does not operate by default on a particular Scheduler
.te
- the SingleSubscriber
that will handle the emission or notification from the SingleSubscription
reference can request the Single
stop work.java.lang.IllegalStateException
- if subscribe
is unable to obtain an OnSubscribe<>
functionjava.lang.IllegalArgumentException
- if the SingleSubscriber
provided as the argument to subscribe
is null
OnErrorNotImplementedException
- if the SingleSubscriber
's onError
method is nulljava.lang.RuntimeException
- if the SingleSubscriber
's onError
method itself threw a Throwable
public final Single<T> subscribeOn(Scheduler scheduler)
Scheduler
.
Scheduler
this operator will usescheduler
- the Scheduler
to perform subscription actions onScheduler
observeOn(rx.Scheduler)
public final Observable<T> toObservable()
Observable
.
Observable
that emits a single item T.public final Single<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit)
TimeoutException
.
timeout
operates by default on the computation
Scheduler
.timeout
- maximum duration before the Single times outtimeUnit
- the unit of time that applies to the timeout
argument.TimeoutException
in case of a
timeoutpublic final Single<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, Scheduler scheduler)
TimeoutException
.
Scheduler
this operator will usetimeout
- maximum duration before the Single times outtimeUnit
- the unit of time that applies to the timeout
argumentscheduler
- the Scheduler to run the timeout timers onTimeoutException
in case of a
timeoutpublic final Single<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, Single<? extends T> other)
timeout
operates by default on the computation
Scheduler
.timeout
- maximum time before a timeout occurstimeUnit
- the unit of time that applies to the timeout
argumentother
- the fallback Single to use in case of a timeoutpublic final Single<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, Single<? extends T> other, Scheduler scheduler)
Scheduler
this operator will usetimeout
- maximum duration before a timeout occurstimeUnit
- the unit of time that applies to the timeout
argumentother
- the Single to use as the fallback in case of a timeoutscheduler
- the Scheduler
to run the timeout timers onpublic final <T2,R> Single<R> zipWith(Single<? extends T2> other, Func2<? super T,? super T2,? extends R> zipFunction)
zipWith
does not operate by default on a particular Scheduler
.T2
- the type of items emitted by the other
SingleR
- the type of items emitted by the resulting Singleother
- the other ObservablezipFunction
- a function that combines the pairs of items from the two Observables to generate the items to
be emitted by the resulting Singleother
Observable
and emits the results of zipFunction
applied to these pairs