Uses of Class
rx.Single

Packages that use Single
Package
Description
rx
Base reactive classes: Observable, Single and Completable; base reactive consumers; other common base interfaces.
rx.internal.operators
Operators that allow composing Observables to transform and manipulate data in an asynchronous, functional and thread-safe manner.
rx.internal.util
 
rx.plugins
Callback types and a central plugin handler class to hook into the lifecycle of the base reactive types and schedulers.
rx.singles
Classes extending the Single base reactive class.

  • Uses of Single in rx

    Methods in rx that return Single
    Modifier and Type
    Method
    Description
    final <T> Single<T>
    Completable.andThen(Single<T> next)
    Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the next Single.
    <R> Single<R>
    Single.compose(Single.Transformer<? super T,? extends R> transformer)
    Transform a Single by applying a particular Transformer function to it.
    static <T> Single<T>
    Single.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>
    Single.defer(Callable<Single<T>> singleFactory)
    Returns a Single that calls a Single factory to create a Single for each new Observer that subscribes.
    final Single<T>
    Single.delay(long delay, TimeUnit unit)
    Returns an Single that emits the items emitted by the source Single shifted forward in time by a specified delay.
    final Single<T>
    Single.delay(long delay, TimeUnit unit, Scheduler scheduler)
    Returns an Single that emits the items emitted by the source Single shifted forward in time by a specified delay.
    final Single<T>
    Single.delaySubscription(Observable<?> other)
    Returns a Single that delays the subscription to this Single until the Observable completes.
    final Single<T>
    Single.doAfterTerminate(Action0 action)
    Registers an Action0 to be called when this Single invokes either SingleSubscriber.onSuccess(Object) onSuccess} or onError.
    final Single<T>
    Single.doOnError(Action1<Throwable> onError)
    Modifies the source Single so that it invokes an action if it calls onError.
    final Single<T>
    Single.doOnSubscribe(Action0 subscribe)
    Modifies the source Single so that it invokes the given action when it is subscribed from its subscribers.
    final Single<T>
    Single.doOnSuccess(Action1<? super T> onSuccess)
    Modifies the source Single so that it invokes an action when it calls onSuccess.
    final Single<T>
    Single.doOnUnsubscribe(Action0 action)
    Modifies the source Single so that it invokes the given action when it is unsubscribed from its subscribers.
    static <T> Single<T>
    Single.error(Throwable exception)
    Returns a Single that invokes a subscriber's onError method when the subscriber subscribes to it.
    final <R> Single<R>
    Single.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.
    static <T> Single<T>
    Single.from(Future<? extends T> future)
    Converts a Future into a Single.
    static <T> Single<T>
    Single.from(Future<? extends T> future, long timeout, TimeUnit unit)
    Converts a Future into a Single, with a timeout on the Future.
    static <T> Single<T>
    Single.from(Future<? extends T> future, Scheduler scheduler)
    Converts a Future, operating on a specified Scheduler, into a Single.
    static <T> Single<T>
    Single.fromCallable(Callable<? extends T> func)
    Returns a Single that invokes passed function and emits its result for each new Observer that subscribes.
    (package private) static <T> Single<? extends T>[]
    Single.iterableToArray(Iterable<? extends Single<? extends T>> singlesIterable)
    FOR INTERNAL USE ONLY.
    static <T> Single<T>
    Single.just(T value)
    Returns a Single that emits a specified item.
    final <R> Single<R>
    Single.lift(Observable.Operator<? extends R,? super T> lift)
    Lifts a function to the current Single and returns a new Single that when subscribed to will pass the values of the current Single through the Operator function.
    final <R> Single<R>
    Single.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>
    Single.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.
    private Single<Observable<T>>
    Single.nest()
    INTERNAL: Used with lift and operators.
    final Single<T>
    Single.observeOn(Scheduler scheduler)
    Modifies a Single to emit its item (or notify of its error) on a specified Scheduler, asynchronously.
    final Single<T>
    Single.onErrorResumeNext(Func1<Throwable,? extends Single<? extends T>> resumeFunctionInCaseOfError)
    Instructs a Single to pass control to another Single rather than invoking Observer.onError(Throwable) if it encounters an error.
    final Single<T>
    Single.onErrorResumeNext(Single<? extends T> resumeSingleInCaseOfError)
    Instructs a Single to pass control to another Single rather than invoking Observer.onError(Throwable) if it encounters an error.
    final Single<T>
    Single.onErrorReturn(Func1<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.
    final Single<T>
    Single.retry()
    Returns a Single that mirrors the source Single, resubscribing to it if it calls onError (infinite retry count).
    final Single<T>
    Single.retry(long count)
    Returns an Single that mirrors the source Single, resubscribing to it if it calls onError up to a specified number of retries.
    final Single<T>
    Single.retry(Func2<Integer,Throwable,Boolean> predicate)
    Returns an Single that mirrors the source Single, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
    final Single<T>
    Single.retryWhen(Func1<Observable<? extends Throwable>,? extends Observable<?>> notificationHandler)
    Returns a Single that emits the same values as the source Single with the exception of an onError.
    final Single<T>
    Single.subscribeOn(Scheduler scheduler)
    Asynchronously subscribes subscribers to this Single on the specified Scheduler.
    final Single<T>
    Single.takeUntil(Completable other)
    Returns a Single that emits the item emitted by the source Single until a Completable terminates.
    final <E> Single<T>
    Single.takeUntil(Observable<? extends E> other)
    Returns a Single that emits the item emitted by the source Single until an Observable emits an item.
    final <E> Single<T>
    Single.takeUntil(Single<? extends E> other)
    Returns a Single that emits the item emitted by the source Single until a second Single emits an item.
    final Single<T>
    Single.timeout(long timeout, TimeUnit timeUnit)
    Returns a Single that mirrors the source Single but applies a timeout policy for its emitted item.
    final Single<T>
    Single.timeout(long timeout, 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.
    final Single<T>
    Single.timeout(long timeout, TimeUnit timeUnit, Single<? extends T> other)
    Returns a Single that mirrors the source Single but applies a timeout policy for its emitted item.
    final Single<T>
    Single.timeout(long timeout, 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.
    final <T> Single<T>
    Completable.toSingle(Func0<? extends T> completionValueFunc0)
    Converts this Completable into a Single which when this Completable completes normally, calls the given supplier and emits its returned value through onSuccess.
    Single<T>
    Observable.toSingle()
    Returns a Single that emits the single item emitted by the source Observable, if that Observable emits only a single item.
    final <T> Single<T>
    Completable.toSingleDefault(T completionValue)
    Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
    static <T, Resource>
    Single<T>
    Single.using(Func0<Resource> resourceFactory, Func1<? super Resource,? extends Single<? extends T>> singleFactory, Action1<? super Resource> disposeAction)
    Constructs an Single that creates a dependent resource object which is disposed of on unsubscription.
    static <T, Resource>
    Single<T>
    Single.using(Func0<Resource> resourceFactory, Func1<? super Resource,? extends Single<? extends T>> singleFactory, Action1<? super Resource> disposeAction, boolean disposeEagerly)
    Constructs an Single that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and unsubscription does not occur before termination.
    static <R> Single<R>
    Single.zip(Iterable<? extends Single<?>> singles, FuncN<? extends R> zipFunction)
    Returns a Single that emits the result of specified combiner function applied to combination of items emitted, in sequence, by an Iterable of other Singles.
    static <T1, T2, R>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, Single<? extends T8> s8, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, Single<? extends T8> s8, Single<? extends T9> s9, 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.
    final <T2, R> Single<R>
    Single.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.
    Methods in rx with parameters of type Single
    Modifier and Type
    Method
    Description
    final <T> Single<T>
    Completable.andThen(Single<T> next)
    Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the next Single.
    private static <T> Observable<T>
    Single.asObservable(Single<T> t)
    static <T> Observable<T>
    Single.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>
    Single.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>
    Single.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>
    Single.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>
    Single.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>
    Single.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>
    Single.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>
    Single.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.
    final Observable<T>
    Single.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 Completable
    Completable.fromSingle(Single<?> single)
    Returns a Completable instance that when subscribed to, subscribes to the Single instance and emits a completion event if the single emits onSuccess or forwards any onError events.
    static <T> Single<T>
    Single.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>
    Single.merge(Single<? extends T> t1, Single<? extends T> t2)
    Flattens two Singles into a single Observable, without any transformation.
    static <T> Observable<T>
    Single.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>
    Single.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>
    Single.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>
    Single.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>
    Single.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>
    Single.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>
    Single.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.
    final Observable<T>
    Single.mergeWith(Single<? extends T> t1)
    Flattens this and another Single into a single Observable, without any transformation.
    final Single<T>
    Single.onErrorResumeNext(Single<? extends T> resumeSingleInCaseOfError)
    Instructs a Single to pass control to another Single rather than invoking Observer.onError(Throwable) if it encounters an error.
    final <E> Single<T>
    Single.takeUntil(Single<? extends E> other)
    Returns a Single that emits the item emitted by the source Single until a second Single emits an item.
    final Single<T>
    Single.timeout(long timeout, TimeUnit timeUnit, Single<? extends T> other)
    Returns a Single that mirrors the source Single but applies a timeout policy for its emitted item.
    final Single<T>
    Single.timeout(long timeout, 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.
    static <T1, T2, R>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, Single<? extends T8> s8, 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>
    Single<R>
    Single.zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, Single<? extends T8> s8, Single<? extends T9> s9, 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.
    final <T2, R> Single<R>
    Single.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.
    Method parameters in rx with type arguments of type Single
    Modifier and Type
    Method
    Description
    static <T> Single<T>
    Single.defer(Callable<Single<T>> singleFactory)
    Returns a Single that calls a Single factory to create a Single for each new Observer that subscribes.
    final <R> Single<R>
    Single.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.
    (package private) static <T> Single<? extends T>[]
    Single.iterableToArray(Iterable<? extends Single<? extends T>> singlesIterable)
    FOR INTERNAL USE ONLY.
    static <T> Single<T>
    Single.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.
    final Single<T>
    Single.onErrorResumeNext(Func1<Throwable,? extends Single<? extends T>> resumeFunctionInCaseOfError)
    Instructs a Single to pass control to another Single rather than invoking Observer.onError(Throwable) if it encounters an error.
    static <T, Resource>
    Single<T>
    Single.using(Func0<Resource> resourceFactory, Func1<? super Resource,? extends Single<? extends T>> singleFactory, Action1<? super Resource> disposeAction)
    Constructs an Single that creates a dependent resource object which is disposed of on unsubscription.
    static <T, Resource>
    Single<T>
    Single.using(Func0<Resource> resourceFactory, Func1<? super Resource,? extends Single<? extends T>> singleFactory, Action1<? super Resource> disposeAction, boolean disposeEagerly)
    Constructs an Single that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and unsubscription does not occur before termination.
    static <R> Single<R>
    Single.zip(Iterable<? extends Single<?>> singles, FuncN<? extends R> zipFunction)
    Returns a Single that emits the result of specified combiner function applied to combination of items emitted, in sequence, by an Iterable of other Singles.

  • Uses of Single in rx.internal.operators

    Fields in rx.internal.operators declared as Single
    Modifier and Type
    Field
    Description
    (package private) final Single<? extends T>
    SingleOnSubscribeDelaySubscriptionOther.main
     
    private final Single<? extends T>
    SingleOperatorOnErrorResumeNext.originalSingle
     
    (package private) final Single<T>
    SingleDoAfterTerminate.source
     
    (package private) final Single<T>
    SingleOnSubscribeMap.source
     
    Fields in rx.internal.operators with type parameters of type Single
    Modifier and Type
    Field
    Description
    private final Func1<Throwable,? extends Single<? extends T>>
    SingleOperatorOnErrorResumeNext.resumeFunctionInCaseOfError
     
    (package private) final Func1<? super Resource,? extends Single<? extends T>>
    SingleOnSubscribeUsing.singleFactory
     
    Methods in rx.internal.operators that return Single
    Modifier and Type
    Method
    Description
    static <T, R> Single<R>
    SingleOperatorZip.zip(Single<? extends T>[] singles, FuncN<? extends R> zipper)
     
    Methods in rx.internal.operators with parameters of type Single
    Modifier and Type
    Method
    Description
    static <T> SingleOperatorOnErrorResumeNext<T>
    SingleOperatorOnErrorResumeNext.withFunction(Single<? extends T> originalSingle, Func1<Throwable,? extends Single<? extends T>> resumeFunctionInCaseOfError)
     
    static <T> SingleOperatorOnErrorResumeNext<T>
    SingleOperatorOnErrorResumeNext.withOther(Single<? extends T> originalSingle, Single<? extends T> resumeSingleInCaseOfError)
     
    static <T, R> Single<R>
    SingleOperatorZip.zip(Single<? extends T>[] singles, FuncN<? extends R> zipper)
     
    Method parameters in rx.internal.operators with type arguments of type Single
    Modifier and Type
    Method
    Description
    static <T> SingleOperatorOnErrorResumeNext<T>
    SingleOperatorOnErrorResumeNext.withFunction(Single<? extends T> originalSingle, Func1<Throwable,? extends Single<? extends T>> resumeFunctionInCaseOfError)
     
    Constructors in rx.internal.operators with parameters of type Single
    Modifier
    Constructor
    Description
     
    SingleDoAfterTerminate(Single<T> source, Action0 action)
     
     
    SingleOnSubscribeDelaySubscriptionOther(Single<? extends T> main, Observable<?> other)
     
     
    SingleOnSubscribeMap(Single<T> source, Func1<? super T,? extends R> transformer)
     
    private
    SingleOperatorOnErrorResumeNext(Single<? extends T> originalSingle, Func1<Throwable,? extends Single<? extends T>> resumeFunctionInCaseOfError)
     
    Constructor parameters in rx.internal.operators with type arguments of type Single
    Modifier
    Constructor
    Description
     
    SingleOnSubscribeUsing(Func0<Resource> resourceFactory, Func1<? super Resource,? extends Single<? extends T>> observableFactory, Action1<? super Resource> disposeAction, boolean disposeEagerly)
     
    private
    SingleOperatorOnErrorResumeNext(Single<? extends T> originalSingle, Func1<Throwable,? extends Single<? extends T>> resumeFunctionInCaseOfError)
     

  • Uses of Single in rx.internal.util

    Subclasses of Single in rx.internal.util
    Modifier and Type
    Class
    Description
    final class 
    ScalarSynchronousSingle<T>
     
    Methods in rx.internal.util that return Single
    Modifier and Type
    Method
    Description
    <R> Single<R>
    ScalarSynchronousSingle.scalarFlatMap(Func1<? super T,? extends Single<? extends R>> func)
     
    Single<T>
    ScalarSynchronousSingle.scalarScheduleOn(Scheduler scheduler)
    Customized observeOn/subscribeOn implementation which emits the scalar value directly or with less overhead on the specified scheduler.
    Method parameters in rx.internal.util with type arguments of type Single
    Modifier and Type
    Method
    Description
    <R> Single<R>
    ScalarSynchronousSingle.scalarFlatMap(Func1<? super T,? extends Single<? extends R>> func)
     

  • Uses of Single in rx.plugins

    Fields in rx.plugins with type parameters of type Single
    Modifier and Type
    Field
    Description
    (package private) static Func2<Single,Observable.OnSubscribe,Observable.OnSubscribe>
    RxJavaHooks.onSingleStart
     
    Methods in rx.plugins that return types with arguments of type Single
    Modifier and Type
    Method
    Description
    static Func2<Single,Observable.OnSubscribe,Observable.OnSubscribe>
    RxJavaHooks.getOnSingleStart()
    Returns the current Single onStart hook function or null if it is set to the default pass-through.
    Methods in rx.plugins with parameters of type Single
    Modifier and Type
    Method
    Description
    static <T> Observable.OnSubscribe<T>
    RxJavaHooks.onSingleStart(Single<T> instance, Observable.OnSubscribe<T> onSubscribe)
    Hook to call before the child subscriber is subscribed to the OnSubscribe action.
    <T> Observable.OnSubscribe<T>
    RxJavaSingleExecutionHook.onSubscribeStart(Single<? extends T> singleInstance, Observable.OnSubscribe<T> onSubscribe)
    Deprecated.
    Method parameters in rx.plugins with type arguments of type Single
    Modifier and Type
    Method
    Description
    static void
    RxJavaHooks.setOnSingleStart(Func2<Single,Observable.OnSubscribe,Observable.OnSubscribe> onSingleStart)
    Sets the hook function that is called when a subscriber subscribes to a Single unless a lockdown is in effect.

  • Uses of Single in rx.singles

    Fields in rx.singles declared as Single
    Modifier and Type
    Field
    Description
    private final Single<? extends T>
    BlockingSingle.single
     
    Methods in rx.singles with parameters of type Single
    Modifier and Type
    Method
    Description
    static <T> BlockingSingle<T>
    BlockingSingle.from(Single<? extends T> single)
    Converts a Single into a BlockingSingle.
    Constructors in rx.singles with parameters of type Single
    Modifier
    Constructor
    Description
    private
    BlockingSingle(Single<? extends T> single)