hu.akarnokd.rxjava2.basetypes

## Class Solo<T>

- java.lang.Object
- - hu.akarnokd.rxjava2.basetypes.Solo<T>

Type Parameters:
  `T` - the value type

All Implemented Interfaces:
  org.reactivestreams.Publisher<T>

Direct Known Subclasses:
  SoloProcessor

    public abstract class Solo<T>
    extends java.lang.Object
    implements org.reactivestreams.Publisher<T>

Base class with fluent API for supporting a Publisher with exactly 1 element or an error.

Since:
  0.13.0

### Constructor Summary

Constructors
Constructor and Description
`Solo()`

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
`static <T> Solo<T>` `amb(java.lang.Iterable<? extends Solo<? extends T>> sources)` Emit the events of the Solo that reacts first.
`static <T> Solo<T>` `ambArray(Solo<? extends T>... sources)` Emit the events of the Solo that reacts first.
`Solo<T>` `ambWith(Solo<? extends T> other)` Signal the events of this or the other Solo whichever signals first.
`Solo<T>` `andThen(Nono other)` Run the given Nono after this Solo completes successfully and emit that original success value only if the Nono completes normally.
`io.reactivex.Flowable<T>` `andThen(org.reactivestreams.Publisher<? extends T> other)` Emits the success value of this Solo and then continues with the events of the other Publisher.
`T` `blockingGet()` Blockingly awaits indefinitely the success value of this Solo or rethrows its error (wrapped into a RuntimeException if necessary).
`T` `blockingGet(long timeout, java.util.concurrent.TimeUnit unit)` Blockingly awaits at most the given timeout for the success value of this Solo or rethrows its error (wrapped into a RuntimeException if necessary).
`void` `blockingSubscribe()` Blocks until this Solo terminates and ignores the signals it produced.
`void` `blockingSubscribe(io.reactivex.functions.Consumer<? super T> onNext)` Blocks until this Solo terminates and calls the onNext with the success value.
`void` `blockingSubscribe(io.reactivex.functions.Consumer<? super T> onNext, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)` Blocks until this solo terminates and calls the onNext with the success value or calls the onError with the error Throwable.
`void` `blockingSubscribe(io.reactivex.functions.Consumer<? super T> onNext, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError, io.reactivex.functions.Action onComplete)` Blocks until this Solo produces its terminal signal and calls the appropriate callback(s) based on the signal type.
`Solo<T>` `cache()` Caches the value or error event of the upstream Solo and relays/replays it to Subscribers.
`<R> Solo<R>` `compose(io.reactivex.functions.Function<? super Solo<T>,? extends Solo<R>> composer)` Applies a function to this Solo and returns the Solo it returned.
`static <T> io.reactivex.Flowable<T>` `concat(java.lang.Iterable<? extends Solo<? extends T>> sources)` Concatenate the values in order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `concat(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)` Concatenate the values in order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `concat(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources, int prefetch)` Concatenate the values in order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `concatArray(Solo<? extends T>... sources)` Concatenate the values in order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `concatArrayDelayError(Solo<? extends T>... sources)` Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `concatDelayError(java.lang.Iterable<? extends Solo<? extends T>> sources)` Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `concatDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)` Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `concatDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources, int prefetch)` Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `concatDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources, int prefetch, boolean tillTheEnd)` Concatenate the values in order from a sequence of Solo sources, delaying errors till a source terminates or the whole sequence terminates.
`io.reactivex.Flowable<T>` `concatWith(Solo<T> other)` Emits the success value of this Solo followed by the event of the other Solo.
`static <T> Solo<T>` `create(io.reactivex.SingleOnSubscribe<T> onCreate)` Create a Solo that for each incoming Subscriber calls a callback to emit a sync or async events in a thread-safe, backpressure-aware and cancellation-safe manner.
`static <T> Solo<T>` `defer(java.util.concurrent.Callable<? extends Solo<T>> supplier)` Defers the creation of the actual Solo to the time when a Subscriber subscribes to the returned Solo.
`Solo<T>` `delay(long delay, java.util.concurrent.TimeUnit unit)` Delay the emission of the signal of this Solo with the specified time amount.
`Solo<T>` `delay(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Delay the emission of the signal of this Solo with the specified time amount on the specified scheduler.
`Solo<T>` `delay(org.reactivestreams.Publisher<?> other)` Delay the emission of the signal until the other Publisher signals an item or completes.
`Solo<T>` `delaySubscription(long delay, java.util.concurrent.TimeUnit unit)` Delay the subscription to this Solo until the specified delay elapses.
`Solo<T>` `delaySubscription(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Delay the subscription to this Solo until the specified delay elapses.
`Solo<T>` `delaySubscription(org.reactivestreams.Publisher<?> other)` Delay the subscription to this Solo until the other Publisher signals a value or completes.
`Solo<T>` `doAfterNext(io.reactivex.functions.Consumer<? super T> onAfterNext)` Executes a callback after the value is emitted to downstream.
`Solo<T>` `doAfterTerminate(io.reactivex.functions.Action onAfterTerminate)` Executes the callback after this Solo terminates and the downstream is notified.
`Solo<T>` `doFinally(io.reactivex.functions.Action onFinally)` Executes the callback exactly if the upstream terminates or the downstream cancels the sequence.
`Solo<T>` `doOnCancel(io.reactivex.functions.Action onCancel)` Executes the callback if the downstream cancels the sequence.
`Solo<T>` `doOnComplete(io.reactivex.functions.Action onComplete)` Executes a callback when the upstream completes normally.
`Solo<T>` `doOnError(io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)` Executes a callback when the upstream signals an error.
`Solo<T>` `doOnNext(io.reactivex.functions.Consumer<? super T> onNext)` Executes a callback before the value is emitted to downstream.
`Solo<T>` `doOnRequest(io.reactivex.functions.LongConsumer onRequest)` Executes the callback when the downstream requests from this Solo.
`Solo<T>` `doOnSubscribe(io.reactivex.functions.Consumer<? super org.reactivestreams.Subscription> onSubscribe)` Executes a callback when the upstream calls onSubscribe.
`static <T> Solo<T>` `error(java.util.concurrent.Callable<? extends java.lang.Throwable> errorSupplier)` Returns a Solo that signals the error returned from the errorSupplier to each individual Subscriber.
`static <T> Solo<T>` `error(java.lang.Throwable error)` Returns a Solo that signals the given error to Subscribers.
`Perhaps<T>` `filter(io.reactivex.functions.Predicate<? super T> predicate)` Applies a predicate to the value and emits it if the predicate returns true, completes otherwise.
`<R> Solo<R>` `flatMap(io.reactivex.functions.Function<? super T,? extends Solo<? extends R>> mapper)` Maps the success value of this Solo into another Solo and emits its signals.
`<R> Solo<R>` `flatMap(io.reactivex.functions.Function<? super T,? extends Solo<? extends R>> onSuccessMapper, io.reactivex.functions.Function<? super java.lang.Throwable,? extends Solo<? extends R>> onErrorMapper)` Maps the success value or the failure of this Solo into another Solo and emits its signal.
`<R> io.reactivex.Flowable<R>` `flatMapPublisher(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)` Maps the success value of this Solo into a Publisher and emits its signals.
`static <T> Solo<T>` `fromCallable(java.util.concurrent.Callable<T> callable)` Returns a Solo that calls the callable and emits its value or error.
`static <T> Solo<T>` `fromFuture(java.util.concurrent.Future<? extends T> future)` When subscribed, the future is awaited blockingly and indefinitely for its result value; null result will yield a NoSuchElementException.
`static <T> Solo<T>` `fromFuture(java.util.concurrent.Future<? extends T> future, long timeout, java.util.concurrent.TimeUnit unit)` When subscribed, the future is awaited blockingly for a given amount of time for its result value; null result will yield a NoSuchElementException and a timeout will yield a TimeoutException.
`static <T> Solo<T>` `fromPublisher(org.reactivestreams.Publisher<T> source)` Wraps a Publisher into a Solo and signals its only value, NoSuchElementException if empty or IndexOutOfBoundsException if it has more than one element.
`static <T> Solo<T>` `fromSingle(io.reactivex.SingleSource<T> source)` Wraps a Single into a Solo and signals its events.
`static <T> io.reactivex.functions.Function<Solo<T>,Solo<T>>` `getOnAssemblyHandler()` Returns the current onAssembly handler.
`Solo<T>` `hide()` Hides the identity of this Solo, including its Subscription and allows preventing fusion and other optimizations for diagnostic purposes.
`Nono` `ignoreElement()` Ignore the solo value of this Solo and only signal the terminal events.
`static <T> Solo<T>` `just(T item)` Returns a Solo that signals the given item and completes.
`<R> Solo<R>` `lift(io.reactivex.functions.Function<org.reactivestreams.Subscriber<? super R>,org.reactivestreams.Subscriber<? super T>> onLift)` Map the downstream Subscriber into an upstream Subscriber.
`<R> Solo<R>` `map(io.reactivex.functions.Function<? super T,? extends R> mapper)` Maps the value of this Solo into another value via function.
`Solo<T>` `mapError(io.reactivex.functions.Function<? super java.lang.Throwable,? extends java.lang.Throwable> errorMapper)` Maps the Throwable error of this Solo into another Throwable error type.
`static <T> io.reactivex.Flowable<T>` `merge(java.lang.Iterable<? extends Solo<? extends T>> sources)` Merge the values in arbitrary order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `merge(java.lang.Iterable<? extends Solo<? extends T>> sources, int maxConcurrency)` Merge the values in arbitrary order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `merge(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)` Merge the values in arbitrary order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `merge(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources, int maxConcurrency)` Merge the values in arbitrary order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `mergeArray(int maxConcurrency, Solo<? extends T>... sources)` Merge the values in arbitrary order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `mergeArray(Solo<? extends T>... sources)` Merge the values in arbitrary order from a sequence of Solo sources.
`static <T> io.reactivex.Flowable<T>` `mergeArrayDelayError(int maxConcurrency, Solo<? extends T>... sources)` Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `mergeArrayDelayError(Solo<? extends T>... sources)` Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `mergeDelayError(java.lang.Iterable<? extends Solo<? extends T>> sources)` Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `mergeDelayError(java.lang.Iterable<? extends Solo<? extends T>> sources, int maxConcurrency)` Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `mergeDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)` Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.
`static <T> io.reactivex.Flowable<T>` `mergeDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources, int maxConcurrency)` Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.
`io.reactivex.Flowable<T>` `mergeWith(Solo<T> other)` Merges the values of this Solo and the other Solo into a Flowable sequence.
`static <T> Solo<T>` `never()` Returns a Solo that never signals an item or terminal event.
`Solo<T>` `observeOn(io.reactivex.Scheduler scheduler)` Returns a Solo that delivers the onNext, onError and onComplete signals from this Solo on the specified scheduler.
`protected static <T> Solo<T>` `onAssembly(Solo<T> source)`
`Solo<T>` `onErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable,? extends Solo<T>> errorHandler)` If the upstream signals an error, call a function and subscribe to the Solo it returns.
`Solo<T>` `onErrorResumeWith(Solo<T> next)` If the upstream signals an error, switch over to the next Solo and emits its signal instead.
`Solo<T>` `onErrorReturnItem(T item)` If the upstream signals an error, signal an item instead.
`io.reactivex.Flowable<T>` `repeat()` Repeats this Solo indefinitely.
`io.reactivex.Flowable<T>` `repeat(io.reactivex.functions.BooleanSupplier stop)` Repeats this Solo until the given boolean supplier returns true when an repeat iteration of this Solo completes.
`io.reactivex.Flowable<T>` `repeat(long times)` Repeats this Solo at most the given number of times.
`io.reactivex.Flowable<T>` `repeatWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Object>,? extends org.reactivestreams.Publisher<?>> handler)` Repeats this Solo when the Publisher returned by the handler function emits an item or terminates if this Publisher terminates.
`Solo<T>` `retry()` Retry this Solo indefinitely if it fails.
`Solo<T>` `retry(long times)` Retry this Solo at most the given number of times if it fails.
`Solo<T>` `retry(io.reactivex.functions.Predicate<? super java.lang.Throwable> predicate)` Retry this Solo if the predicate returns true for the latest failure Throwable.
`Solo<T>` `retryWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler)` Retry this solo if the Publisher returned by the handler signals an item in response to the failure Throwable.
`static <T> void` `setOnAssemblyHandler(io.reactivex.functions.Function<Solo<T>,Solo<T>> handler)` Set the onAssembly handler.
`io.reactivex.disposables.Disposable` `subscribe()` Subscribe to this Solo and ignore any signal it produces.
`io.reactivex.disposables.Disposable` `subscribe(io.reactivex.functions.Consumer<? super T> onNext)` Subscribes to this Solo and calls the onNext if this Solo succeeds.
`io.reactivex.disposables.Disposable` `subscribe(io.reactivex.functions.Consumer<? super T> onNext, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)` Subscribes to this Solo and calls the appropriate callback for the resulting signal.
`io.reactivex.disposables.Disposable` `subscribe(io.reactivex.functions.Consumer<? super T> onNext, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError, io.reactivex.functions.Action onComplete)` Subscribes to this Solo and calls the appropriate callback for the resulting signal.
`void` `subscribe(org.reactivestreams.Subscriber<? super T> s)`
`protected abstract void` `subscribeActual(org.reactivestreams.Subscriber<? super T> s)` Implement this method to react to a Subscriber subscribing to this Solo.
`Solo<T>` `subscribeOn(io.reactivex.Scheduler scheduler)` Returns a Solo that subscribes to this Solo on the specified scheduler and makes sure downstream requests are forwarded there as well.
`<E extends org.reactivestreams.Subscriber<? super T>> E` `subscribeWith(E s)` Subscribe with a Subscriber (subclass) and return it as is.
`Solo<T>` `takeUntil(org.reactivestreams.Publisher<?> other)` Signal a NoSuchElementException if the other signals before this Solo signals.
`io.reactivex.subscribers.TestSubscriber<T>` `test()` Creates a TestSubscriber and subscribes it to this Solo.
`io.reactivex.subscribers.TestSubscriber<T>` `test(boolean cancel)` Creates a TestSubscriber, optionally cancels it, and subscribes it to this Solo.
`io.reactivex.subscribers.TestSubscriber<T>` `test(long initialRequest)` Creates a TestSubscriber with the given initial request and subscribes it to this Solo.
`io.reactivex.subscribers.TestSubscriber<T>` `test(long initialRequest, boolean cancel)` Creates a TestSubscriber with the given initial request, optionally cancels it, and subscribes it to this Solo.
`Solo<T>` `timeout(long timeout, java.util.concurrent.TimeUnit unit)` Signal a TimeoutException if there is no item from this Solo within the given timeout time.
`Solo<T>` `timeout(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Signal a TimeoutException if there is no item from this Solo within the given timeout time, running on the specified scheduler.
`Solo<T>` `timeout(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler, Solo<T> fallback)` Fall back to another Solo if this Solo doesn't signal within the given time period, waiting on the specified scheduler.
`Solo<T>` `timeout(long timeout, java.util.concurrent.TimeUnit unit, Solo<T> fallback)` Fall back to another Solo if this Solo doesn't signal within the given time period.
`Solo<T>` `timeout(org.reactivestreams.Publisher<?> other)` Signal a TimeoutException if the other Publisher signals or completes before this Solo signals a value.
`Solo<T>` `timeout(org.reactivestreams.Publisher<?> other, Solo<T> fallback)` Fall back to another Solo if the other Publisher signals or completes before this Solo signals a value.
`static Solo<java.lang.Long>` `timer(long delay, java.util.concurrent.TimeUnit unit)` Signals a 0L after the specified amount of time has passed since subscription.
`static Solo<java.lang.Long>` `timer(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Signals a 0L after the specified amount of time has passed since subscription on the specified scheduler.
`<R> R` `to(io.reactivex.functions.Function<? super Solo<T>,R> converter)` Applies the function, fluently to this Solo and returns the value it returns.
`io.reactivex.Flowable<T>` `toFlowable()` Converts this Solo into a Flowable.
`java.util.concurrent.Future<T>` `toFuture()` Converts this Solo into a Future and signals its single value.
`io.reactivex.Observable<T>` `toObservable()` Converts this Solo into an Observable.
`io.reactivex.Single<T>` `toSingle()` Converts this Soli into a Single.
`Solo<T>` `unsubscribeOn(io.reactivex.Scheduler scheduler)` Returns a Solo which when cancelled, cancels this Solo on the specified scheduler.
`static <T,R> Solo<T>` `using(java.util.concurrent.Callable<R> resourceSupplier, io.reactivex.functions.Function<? super R,? extends Solo<T>> sourceSupplier, io.reactivex.functions.Consumer<? super R> disposer)` Generate a resource and a Solo based on that resource and then dispose that resource eagerly when the Solo terminates or the downstream cancels the sequence.
`static <T,R> Solo<T>` `using(java.util.concurrent.Callable<R> resourceSupplier, io.reactivex.functions.Function<? super R,? extends Solo<T>> sourceSupplier, io.reactivex.functions.Consumer<? super R> disposer, boolean eager)` Generate a resource and a Solo based on that resource and then dispose that resource eagerly when the Solo terminates or the downstream cancels the sequence.
`static <T,R> Solo<R>` `zip(java.lang.Iterable<? extends Solo<? extends T>> sources, io.reactivex.functions.Function<? super java.lang.Object[],? extends R> zipper)` Combines the solo values of all the sources via a zipper function into a single resulting value.
`static <T,R> Solo<R>` `zipArray(io.reactivex.functions.Function<? super java.lang.Object[],? extends R> zipper, Solo<? extends T>... sources)` Combines the solo values of all the sources via a zipper function into a single resulting value.
`<U,R> Solo<R>` `zipWith(Solo<U> other, io.reactivex.functions.BiFunction<? super T,? super U,? extends R> zipper)` Combines the values of this and the other Solo via a BiFunction.

### Methods inherited from class java.lang.Object

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

### Constructor Detail

#### Solo

    public Solo()

### Method Detail

#### getOnAssemblyHandler

    public static <T> io.reactivex.functions.Function<Solo<T>,Solo<T>> getOnAssemblyHandler()

Returns the current onAssembly handler.

Type Parameters:
  `T` - the target value type
Returns:
  the current handler, maybe null

#### setOnAssemblyHandler

    public static <T> void setOnAssemblyHandler(io.reactivex.functions.Function<Solo<T>,Solo<T>> handler)

Set the onAssembly handler.

Type Parameters:
  `T` - the target value type
Parameters:
  `handler` - the handler, null clears the handler

#### onAssembly

    protected static <T> Solo<T> onAssembly(Solo<T> source)

#### create

    public static <T> Solo<T> create(io.reactivex.SingleOnSubscribe<T> onCreate)

Create a Solo that for each incoming Subscriber calls a callback to emit a sync or async events in a thread-safe, backpressure-aware and cancellation-safe manner.

Type Parameters:
  `T` - the value type emitted
Parameters:
  `onCreate` - the callback called for each individual subscriber with an abstraction of the incoming Subscriber.
Returns:
  th new Solo instance

#### just

    public static <T> Solo<T> just(T item)

Returns a Solo that signals the given item and completes.

Type Parameters:
  `T` - the value type
Parameters:
  `item` - the item, not null
Returns:
  the new Solo instance

#### error

    public static <T> Solo<T> error(java.lang.Throwable error)

Returns a Solo that signals the given error to Subscribers.

Type Parameters:
  `T` - the value type
Parameters:
  `error` - the error to signal, not null
Returns:
  the new Solo instance

#### error

    public static <T> Solo<T> error(java.util.concurrent.Callable<? extends java.lang.Throwable> errorSupplier)

Returns a Solo that signals the error returned from the errorSupplier to each individual Subscriber.

Type Parameters:
  `T` - the value type
Parameters:
  `errorSupplier` - the supplier called for each Subscriber to return a Throwable to be signalled
Returns:
  the new Solo instance

#### fromCallable

    public static <T> Solo<T> fromCallable(java.util.concurrent.Callable<T> callable)

Returns a Solo that calls the callable and emits its value or error.

Type Parameters:
  `T` - the value type
Parameters:
  `callable` - the callable to call
Returns:
  the new Solo instance

#### never

    public static <T> Solo<T> never()

Returns a Solo that never signals an item or terminal event.

Type Parameters:
  `T` - the value type
Returns:
  the new Solo instance

#### defer

    public static <T> Solo<T> defer(java.util.concurrent.Callable<? extends Solo<T>> supplier)

Defers the creation of the actual Solo to the time when a Subscriber subscribes to the returned Solo.

Type Parameters:
  `T` - the value type
Parameters:
  `supplier` - the supplier of the actual Solo
Returns:
  the new Solo instance

#### fromPublisher

    public static <T> Solo<T> fromPublisher(org.reactivestreams.Publisher<T> source)

Wraps a Publisher into a Solo and signals its only value, NoSuchElementException if empty or IndexOutOfBoundsException if it has more than one element.

Type Parameters:
  `T` - the value type
Parameters:
  `source` - the source Publisher
Returns:
  the new Solo instance

#### fromSingle

    public static <T> Solo<T> fromSingle(io.reactivex.SingleSource<T> source)

Wraps a Single into a Solo and signals its events.

Type Parameters:
  `T` - the value type
Parameters:
  `source` - the source Single
Returns:
  the new Solo instance

#### fromFuture

    public static <T> Solo<T> fromFuture(java.util.concurrent.Future<? extends T> future)

When subscribed, the future is awaited blockingly and indefinitely for its result value; null result will yield a NoSuchElementException.

Type Parameters:
  `T` - the value type
Parameters:
  `future` - the future to await
Returns:
  the new Solo instance
Since:
  0.14.0

#### fromFuture

    public static <T> Solo<T> fromFuture(java.util.concurrent.Future<? extends T> future,
                                         long timeout,
                                         java.util.concurrent.TimeUnit unit)

When subscribed, the future is awaited blockingly for a given amount of time for its result value; null result will yield a NoSuchElementException and a timeout will yield a TimeoutException.

Type Parameters:
  `T` - the value type
Parameters:
  `future` - the future to await
  `timeout` - the timeout value
  `unit` - the time unit
Returns:
  the new Solo instance
Since:
  0.14.0

#### amb

    public static <T> Solo<T> amb(java.lang.Iterable<? extends Solo<? extends T>> sources)

Emit the events of the Solo that reacts first.

Type Parameters:
  `T` - the common value type
Parameters:
  `sources` - the Iterable sequence of Solo sources
Returns:
  the new Solo instance

#### ambArray

    public static <T> Solo<T> ambArray(Solo<? extends T>... sources)

Emit the events of the Solo that reacts first.

Type Parameters:
  `T` - the common value type
Parameters:
  `sources` - the array of Solo sources
Returns:
  the new Solo instance

#### concat

    public static <T> io.reactivex.Flowable<T> concat(java.lang.Iterable<? extends Solo<? extends T>> sources)

Concatenate the values in order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### concat

    public static <T> io.reactivex.Flowable<T> concat(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)

Concatenate the values in order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### concat

    public static <T> io.reactivex.Flowable<T> concat(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources,
                                                      int prefetch)

Concatenate the values in order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `prefetch` - the number of sources to prefetch from upstream
Returns:
  the new Flowable instance

#### concatArray

    public static <T> io.reactivex.Flowable<T> concatArray(Solo<? extends T>... sources)

Concatenate the values in order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### concatDelayError

    public static <T> io.reactivex.Flowable<T> concatDelayError(java.lang.Iterable<? extends Solo<? extends T>> sources)

Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### concatDelayError

    public static <T> io.reactivex.Flowable<T> concatDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)

Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### concatDelayError

    public static <T> io.reactivex.Flowable<T> concatDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources,
                                                                int prefetch)

Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `prefetch` - the number of sources to prefetch from upstream
Returns:
  the new Flowable instance

#### concatDelayError

    public static <T> io.reactivex.Flowable<T> concatDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources,
                                                                int prefetch,
                                                                boolean tillTheEnd)

Concatenate the values in order from a sequence of Solo sources, delaying errors till a source terminates or the whole sequence terminates.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `prefetch` - the number of sources to prefetch from upstream
  `tillTheEnd` - if true, errors are delayed to the very end; if false, an error will be signalled at the end of one source
Returns:
  the new Flowable instance

#### concatArrayDelayError

    public static <T> io.reactivex.Flowable<T> concatArrayDelayError(Solo<? extends T>... sources)

Concatenate the values in order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### merge

    public static <T> io.reactivex.Flowable<T> merge(java.lang.Iterable<? extends Solo<? extends T>> sources)

Merge the values in arbitrary order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### merge

    public static <T> io.reactivex.Flowable<T> merge(java.lang.Iterable<? extends Solo<? extends T>> sources,
                                                     int maxConcurrency)

Merge the values in arbitrary order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `maxConcurrency` - the maximum number of active subscriptions
Returns:
  the new Flowable instance

#### merge

    public static <T> io.reactivex.Flowable<T> merge(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)

Merge the values in arbitrary order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### merge

    public static <T> io.reactivex.Flowable<T> merge(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources,
                                                     int maxConcurrency)

Merge the values in arbitrary order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `maxConcurrency` - the maximum number of active subscriptions
Returns:
  the new Flowable instance

#### mergeArray

    public static <T> io.reactivex.Flowable<T> mergeArray(Solo<? extends T>... sources)

Merge the values in arbitrary order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### mergeArray

    public static <T> io.reactivex.Flowable<T> mergeArray(int maxConcurrency,
                                                          Solo<? extends T>... sources)

Merge the values in arbitrary order from a sequence of Solo sources.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `maxConcurrency` - the maximum number of active subscriptions
Returns:
  the new Flowable instance

#### mergeDelayError

    public static <T> io.reactivex.Flowable<T> mergeDelayError(java.lang.Iterable<? extends Solo<? extends T>> sources)

Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### mergeDelayError

    public static <T> io.reactivex.Flowable<T> mergeDelayError(java.lang.Iterable<? extends Solo<? extends T>> sources,
                                                               int maxConcurrency)

Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `maxConcurrency` - the maximum number of active subscriptions
Returns:
  the new Flowable instance

#### mergeDelayError

    public static <T> io.reactivex.Flowable<T> mergeDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources)

Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### mergeDelayError

    public static <T> io.reactivex.Flowable<T> mergeDelayError(org.reactivestreams.Publisher<? extends Solo<? extends T>> sources,
                                                               int maxConcurrency)

Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `maxConcurrency` - the maximum number of active subscriptions
Returns:
  the new Flowable instance

#### mergeArrayDelayError

    public static <T> io.reactivex.Flowable<T> mergeArrayDelayError(Solo<? extends T>... sources)

Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
Returns:
  the new Flowable instance

#### mergeArrayDelayError

    public static <T> io.reactivex.Flowable<T> mergeArrayDelayError(int maxConcurrency,
                                                                    Solo<? extends T>... sources)

Merge the values in arbitrary order from a sequence of Solo sources, delaying errors till all sources terminate.

Type Parameters:
  `T` - the common base value type
Parameters:
  `sources` - the sequence of sources
  `maxConcurrency` - the maximum number of active subscriptions
Returns:
  the new Flowable instance

#### timer

    public static Solo<java.lang.Long> timer(long delay,
                                             java.util.concurrent.TimeUnit unit)

Signals a 0L after the specified amount of time has passed since subscription.

Parameters:
  `delay` - the delay time
  `unit` - the time unit
Returns:
  the new Solo instance

#### timer

    public static Solo<java.lang.Long> timer(long delay,
                                             java.util.concurrent.TimeUnit unit,
                                             io.reactivex.Scheduler scheduler)

Signals a 0L after the specified amount of time has passed since subscription on the specified scheduler.

Parameters:
  `delay` - the delay time
  `unit` - the time unit
  `scheduler` - the scheduler to wait on
Returns:
  the new Solo instance

#### using

    public static <T,R> Solo<T> using(java.util.concurrent.Callable<R> resourceSupplier,
                                      io.reactivex.functions.Function<? super R,? extends Solo<T>> sourceSupplier,
                                      io.reactivex.functions.Consumer<? super R> disposer)

Generate a resource and a Solo based on that resource and then dispose that resource eagerly when the Solo terminates or the downstream cancels the sequence.

Type Parameters:
  `T` - the value type
  `R` - the resource type
Parameters:
  `resourceSupplier` - the callback to get a resource for each subscriber
  `sourceSupplier` - the function that returns a Solo for the generated resource
  `disposer` - the consumer of the resource once the upstream terminates or the downstream cancels
Returns:
  the new Solo instance

#### using

    public static <T,R> Solo<T> using(java.util.concurrent.Callable<R> resourceSupplier,
                                      io.reactivex.functions.Function<? super R,? extends Solo<T>> sourceSupplier,
                                      io.reactivex.functions.Consumer<? super R> disposer,
                                      boolean eager)

Generate a resource and a Solo based on that resource and then dispose that resource eagerly when the Solo terminates or the downstream cancels the sequence.

Type Parameters:
  `T` - the value type
  `R` - the resource type
Parameters:
  `resourceSupplier` - the callback to get a resource for each subscriber
  `sourceSupplier` - the function that returns a Solo for the generated resource
  `disposer` - the consumer of the resource once the upstream terminates or the downstream cancels
  `eager` - if true, the resource is disposed before the terminal event is emitted if false, the resource is disposed after the terminal event has been emitted
Returns:
  the new Solo instance

#### zip

    public static <T,R> Solo<R> zip(java.lang.Iterable<? extends Solo<? extends T>> sources,
                                    io.reactivex.functions.Function<? super java.lang.Object[],? extends R> zipper)

Combines the solo values of all the sources via a zipper function into a single resulting value.

Type Parameters:
  `T` - the common input base type
  `R` - the result type
Parameters:
  `sources` - the sequence of Solo sources
  `zipper` - the function takin in an array of values and returns a solo value
Returns:
  the new Solo instance

#### zipArray

    public static <T,R> Solo<R> zipArray(io.reactivex.functions.Function<? super java.lang.Object[],? extends R> zipper,
                                         Solo<? extends T>... sources)

Combines the solo values of all the sources via a zipper function into a single resulting value.

Type Parameters:
  `T` - the common input base type
  `R` - the result type
Parameters:
  `sources` - the sequence of Solo sources
  `zipper` - the function takin in an array of values and returns a solo value
Returns:
  the new Solo instance

#### ambWith

    public final Solo<T> ambWith(Solo<? extends T> other)

Signal the events of this or the other Solo whichever signals first.

Parameters:
  `other` - the other Solo
Returns:
  the new Solo instance

#### andThen

    public final Solo<T> andThen(Nono other)

Run the given Nono after this Solo completes successfully and emit that original success value only if the Nono completes normally.

Parameters:
  `other` - the other Nono to execute
Returns:
  the new Solo instance

#### andThen

    public final io.reactivex.Flowable<T> andThen(org.reactivestreams.Publisher<? extends T> other)

Emits the success value of this Solo and then continues with the events of the other Publisher.

Parameters:
  `other` - the other Publisher instance
Returns:
  the new Flowable instance

#### concatWith

    public final io.reactivex.Flowable<T> concatWith(Solo<T> other)

Emits the success value of this Solo followed by the event of the other Solo.

Parameters:
  `other` - the other Solo instance
Returns:
  the new Flowable instance

#### mergeWith

    public final io.reactivex.Flowable<T> mergeWith(Solo<T> other)

Merges the values of this Solo and the other Solo into a Flowable sequence.

Parameters:
  `other` - the other Solo instance
Returns:
  the new Flowable instance

#### zipWith

    public final <U,R> Solo<R> zipWith(Solo<U> other,
                                       io.reactivex.functions.BiFunction<? super T,? super U,? extends R> zipper)

Combines the values of this and the other Solo via a BiFunction.

Type Parameters:
  `U` - the other value type
  `R` - the result value type
Parameters:
  `other` - the other Solo source
  `zipper` - the bi-function taking the success value from this and the other Solo and returns a solo value to be emitted.
Returns:
  the new Solo instance

#### map

    public final <R> Solo<R> map(io.reactivex.functions.Function<? super T,? extends R> mapper)

Maps the value of this Solo into another value via function.

Type Parameters:
  `R` - the output value type
Parameters:
  `mapper` - the function that receives the success value of this Solo and returns a replacement value.
Returns:
  the new Solo instance

#### mapError

    public final Solo<T> mapError(io.reactivex.functions.Function<? super java.lang.Throwable,? extends java.lang.Throwable> errorMapper)

Maps the Throwable error of this Solo into another Throwable error type.

Parameters:
  `errorMapper` - the function that receives the Throwable and should return a Throwable to be emitted.
Returns:
  the new Solo instance

#### filter

    public final Perhaps<T> filter(io.reactivex.functions.Predicate<? super T> predicate)

Applies a predicate to the value and emits it if the predicate returns true, completes otherwise.

Parameters:
  `predicate` - the predicate called with the solo value
Returns:
  the new Perhaps instance

#### timeout

    public final Solo<T> timeout(long timeout,
                                 java.util.concurrent.TimeUnit unit)

Signal a TimeoutException if there is no item from this Solo within the given timeout time.

Parameters:
  `timeout` - the timeout value
  `unit` - the time unit
Returns:
  the new Solo instance

#### timeout

    public final Solo<T> timeout(long timeout,
                                 java.util.concurrent.TimeUnit unit,
                                 io.reactivex.Scheduler scheduler)

Signal a TimeoutException if there is no item from this Solo within the given timeout time, running on the specified scheduler.

Parameters:
  `timeout` - the timeout value
  `unit` - the time unit
  `scheduler` - the scheduler to wait on
Returns:
  the new Solo instance

#### timeout

    public final Solo<T> timeout(long timeout,
                                 java.util.concurrent.TimeUnit unit,
                                 Solo<T> fallback)

Fall back to another Solo if this Solo doesn't signal within the given time period.

Parameters:
  `timeout` - the timeout value
  `unit` - the time unit
  `fallback` - the other Solo to subscribe to
Returns:
  the new Solo instance

#### timeout

    public final Solo<T> timeout(long timeout,
                                 java.util.concurrent.TimeUnit unit,
                                 io.reactivex.Scheduler scheduler,
                                 Solo<T> fallback)

Fall back to another Solo if this Solo doesn't signal within the given time period, waiting on the specified scheduler.

Parameters:
  `timeout` - the timeout value
  `unit` - the time unit
  `scheduler` - the scheduler to wait on
  `fallback` - the fallback Solo to subscribe to
Returns:
  the new Solo instance

#### timeout

    public final Solo<T> timeout(org.reactivestreams.Publisher<?> other)

Signal a TimeoutException if the other Publisher signals or completes before this Solo signals a value.

Parameters:
  `other` - the other Publisher triggers the TimeoutException when it signals its first item or completes.
Returns:
  the new Solo instance

#### timeout

    public final Solo<T> timeout(org.reactivestreams.Publisher<?> other,
                                 Solo<T> fallback)

Fall back to another Solo if the other Publisher signals or completes before this Solo signals a value.

Parameters:
  `other` - the other Publisher triggers the TimeoutException when it signals its first item or completes.
  `fallback` - the fallback Solo to subscribe to in case of a timeout
Returns:
  the new Solo instance

#### onErrorReturnItem

    public final Solo<T> onErrorReturnItem(T item)

If the upstream signals an error, signal an item instead.

Parameters:
  `item` - the item to signal if the upstream fails
Returns:
  the new Solo instance

#### onErrorResumeWith

    public final Solo<T> onErrorResumeWith(Solo<T> next)

If the upstream signals an error, switch over to the next Solo and emits its signal instead.

Parameters:
  `next` - the other Solo to switch to in case of an upstream error
Returns:
  the new Solo instance

#### onErrorResumeNext

    public final Solo<T> onErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable,? extends Solo<T>> errorHandler)

If the upstream signals an error, call a function and subscribe to the Solo it returns.

Parameters:
  `errorHandler` - the function receiving the upstream error and returns a Solo to resume with.
Returns:
  the new Solo instance

#### flatMap

    public final <R> Solo<R> flatMap(io.reactivex.functions.Function<? super T,? extends Solo<? extends R>> mapper)

Maps the success value of this Solo into another Solo and emits its signals.

Type Parameters:
  `R` - the result type
Parameters:
  `mapper` - the function that receives the success value and returns another Solo to subscribe to
Returns:
  the new Solo instance

#### flatMap

    public final <R> Solo<R> flatMap(io.reactivex.functions.Function<? super T,? extends Solo<? extends R>> onSuccessMapper,
                                     io.reactivex.functions.Function<? super java.lang.Throwable,? extends Solo<? extends R>> onErrorMapper)

Maps the success value or the failure of this Solo into another Solo and emits its signal.

Type Parameters:
  `R` - the result type
Parameters:
  `onSuccessMapper` - the function that receives the success value and return another Solo to subscribe to
  `onErrorMapper` - the function that receives the Throwable error and return another Solo to subscribe to
Returns:
  th new Solo instance

#### flatMapPublisher

    public final <R> io.reactivex.Flowable<R> flatMapPublisher(io.reactivex.functions.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Maps the success value of this Solo into a Publisher and emits its signals.

Type Parameters:
  `R` - the result type
Parameters:
  `mapper` - the function that takes the success value of this Solo and returns a Publisher
Returns:
  the new Flowable instance

#### takeUntil

    public final Solo<T> takeUntil(org.reactivestreams.Publisher<?> other)

Signal a NoSuchElementException if the other signals before this Solo signals.

Parameters:
  `other` - the other Publisher
Returns:
  the new Solo instance

#### delay

    public final Solo<T> delay(long delay,
                               java.util.concurrent.TimeUnit unit)

Delay the emission of the signal of this Solo with the specified time amount.

Parameters:
  `delay` - the delay time
  `unit` - the delay time unit
Returns:
  the new Solo instance

#### delay

    public final Solo<T> delay(long delay,
                               java.util.concurrent.TimeUnit unit,
                               io.reactivex.Scheduler scheduler)

Delay the emission of the signal of this Solo with the specified time amount on the specified scheduler.

Parameters:
  `delay` - the delay time
  `unit` - the delay time unit
  `scheduler` - the scheduler to wait on
Returns:
  the new Solo instance

#### delay

    public final Solo<T> delay(org.reactivestreams.Publisher<?> other)

Delay the emission of the signal until the other Publisher signals an item or completes.

Parameters:
  `other` - the other Publisher that has to signal to emit the origina signal from this Solo
Returns:
  the new Solo instance

#### delaySubscription

    public final Solo<T> delaySubscription(org.reactivestreams.Publisher<?> other)

Delay the subscription to this Solo until the other Publisher signals a value or completes.

Parameters:
  `other` - the other Publisher to trigger the actual subscription
Returns:
  the new Solo type

#### delaySubscription

    public final Solo<T> delaySubscription(long delay,
                                           java.util.concurrent.TimeUnit unit)

Delay the subscription to this Solo until the specified delay elapses.

Parameters:
  `delay` - the delay time
  `unit` - the delay unit
Returns:
  the new Solo type

#### delaySubscription

    public final Solo<T> delaySubscription(long delay,
                                           java.util.concurrent.TimeUnit unit,
                                           io.reactivex.Scheduler scheduler)

Delay the subscription to this Solo until the specified delay elapses.

Parameters:
  `delay` - the delay time
  `unit` - the delay unit
  `scheduler` - the scheduler to wait on
Returns:
  the new Solo type

#### toFlowable

    public final io.reactivex.Flowable<T> toFlowable()

Converts this Solo into a Flowable.

Returns:
  the new Flowable instance

#### toObservable

    public final io.reactivex.Observable<T> toObservable()

Converts this Solo into an Observable.

Returns:
  the new Observable instance

#### toSingle

    public final io.reactivex.Single<T> toSingle()

Converts this Soli into a Single.

Returns:
  the new Single instance

#### doOnSubscribe

    public final Solo<T> doOnSubscribe(io.reactivex.functions.Consumer<? super org.reactivestreams.Subscription> onSubscribe)

Executes a callback when the upstream calls onSubscribe.

Parameters:
  `onSubscribe` - the consumer called with the upstream Subscription
Returns:
  the new Solo instance

#### doOnRequest

    public final Solo<T> doOnRequest(io.reactivex.functions.LongConsumer onRequest)

Executes the callback when the downstream requests from this Solo.

Parameters:
  `onRequest` - the callback called with the request amount
Returns:
  the new Solo instance

#### doOnCancel

    public final Solo<T> doOnCancel(io.reactivex.functions.Action onCancel)

Executes the callback if the downstream cancels the sequence.

Parameters:
  `onCancel` - the action to call
Returns:
  the new Solo instance

#### doOnNext

    public final Solo<T> doOnNext(io.reactivex.functions.Consumer<? super T> onNext)

Executes a callback before the value is emitted to downstream.

Parameters:
  `onNext` - the consumer called with the current value before it is is emitted to downstream.
Returns:
  the new Solo instance

#### doAfterNext

    public final Solo<T> doAfterNext(io.reactivex.functions.Consumer<? super T> onAfterNext)

Executes a callback after the value is emitted to downstream.

Parameters:
  `onAfterNext` - the consumer called with the current value after it is is emitted to downstream.
Returns:
  the new Solo instance

#### doOnError

    public final Solo<T> doOnError(io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)

Executes a callback when the upstream signals an error.

Parameters:
  `onError` - the consumer called before the error is emitted to the downstream
Returns:
  the new Solo instance

#### doOnComplete

    public final Solo<T> doOnComplete(io.reactivex.functions.Action onComplete)

Executes a callback when the upstream completes normally.

Parameters:
  `onComplete` - the consumer called before the completion event is emitted to the downstream.
Returns:
  the new Solo instance

#### doAfterTerminate

    public final Solo<T> doAfterTerminate(io.reactivex.functions.Action onAfterTerminate)

Executes the callback after this Solo terminates and the downstream is notified.

Parameters:
  `onAfterTerminate` - the callback to call after the downstream is notified
Returns:
  the new Solo instance

#### doFinally

    public final Solo<T> doFinally(io.reactivex.functions.Action onFinally)

Executes the callback exactly if the upstream terminates or the downstream cancels the sequence.

Parameters:
  `onFinally` - the action to call
Returns:
  the new Solo instance

#### ignoreElement

    public final Nono ignoreElement()

Ignore the solo value of this Solo and only signal the terminal events.

Returns:
  the new Nono instance

#### hide

    public final Solo<T> hide()

Hides the identity of this Solo, including its Subscription and allows preventing fusion and other optimizations for diagnostic purposes.

Returns:
  the new Solo instance

#### to

    public final <R> R to(io.reactivex.functions.Function<? super Solo<T>,R> converter)

Applies the function, fluently to this Solo and returns the value it returns.

Type Parameters:
  `R` - the result type
Parameters:
  `converter` - the function receiving this Solo and returns a value to be returned
Returns:
  the value returned by the function

#### compose

    public final <R> Solo<R> compose(io.reactivex.functions.Function<? super Solo<T>,? extends Solo<R>> composer)

Applies a function to this Solo and returns the Solo it returned.

Type Parameters:
  `R` - the result type
Parameters:
  `composer` - the function that receives this Solo and should return a Solo
Returns:
  the new Solo instance

#### lift

    public final <R> Solo<R> lift(io.reactivex.functions.Function<org.reactivestreams.Subscriber<? super R>,org.reactivestreams.Subscriber<? super T>> onLift)

Map the downstream Subscriber into an upstream Subscriber.

Type Parameters:
  `R` - the downstream value type
Parameters:
  `onLift` - the function called with the downstream's Subscriber and should return a Subscriber to be subscribed to this Solo.
Returns:
  the new Solo type

#### repeat

    public final io.reactivex.Flowable<T> repeat()

Repeats this Solo indefinitely.

Returns:
  the new Flowable instance

#### repeat

    public final io.reactivex.Flowable<T> repeat(long times)

Repeats this Solo at most the given number of times.

Parameters:
  `times` - the number of times to repeat
Returns:
  the new Flowable instance

#### repeat

    public final io.reactivex.Flowable<T> repeat(io.reactivex.functions.BooleanSupplier stop)

Repeats this Solo until the given boolean supplier returns true when an repeat iteration of this Solo completes.

Parameters:
  `stop` - the supplier of a boolean value that should return true to stop repeating.
Returns:
  the new Flowable instance

#### repeatWhen

    public final io.reactivex.Flowable<T> repeatWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Object>,? extends org.reactivestreams.Publisher<?>> handler)

Repeats this Solo when the Publisher returned by the handler function emits an item or terminates if this Publisher terminates.

Parameters:
  `handler` - the function that receives Flowable that emits an item when this Solo completes and returns a Publisher that should emit an item to trigger a repeat or terminate to trigger a termination.
Returns:
  the new Flowable instance

#### retry

    public final Solo<T> retry()

Retry this Solo indefinitely if it fails.

Returns:
  the new Solo instance

#### retry

    public final Solo<T> retry(long times)

Retry this Solo at most the given number of times if it fails.

Parameters:
  `times` - the number of times, Long.MAX_VALUE means indefinitely
Returns:
  the new Solo instance

#### retry

    public final Solo<T> retry(io.reactivex.functions.Predicate<? super java.lang.Throwable> predicate)

Retry this Solo if the predicate returns true for the latest failure Throwable.

Parameters:
  `predicate` - the predicate receiving the latest Throwable and if returns true, the Solo is retried.
Returns:
  the new Solo instance

#### retryWhen

    public final Solo<T> retryWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler)

Retry this solo if the Publisher returned by the handler signals an item in response to the failure Throwable.

Parameters:
  `handler` - the function that receives a Flowable that signals the failure Throwable of this Solo and returns a Publisher which triggers a retry or termination.
Returns:
  the new Solo instance

#### subscribeOn

    public final Solo<T> subscribeOn(io.reactivex.Scheduler scheduler)

Returns a Solo that subscribes to this Solo on the specified scheduler and makes sure downstream requests are forwarded there as well.

Parameters:
  `scheduler` - the scheduler to subscribe on
Returns:
  the new Solo instance

#### observeOn

    public final Solo<T> observeOn(io.reactivex.Scheduler scheduler)

Returns a Solo that delivers the onNext, onError and onComplete signals from this Solo on the specified scheduler.

Parameters:
  `scheduler` - the scheduler to emit the events on
Returns:
  the new Solo instance

#### unsubscribeOn

    public final Solo<T> unsubscribeOn(io.reactivex.Scheduler scheduler)

Returns a Solo which when cancelled, cancels this Solo on the specified scheduler.

Parameters:
  `scheduler` - the scheduler to cancel this Solo
Returns:
  the new Solo instance

#### cache

    public final Solo<T> cache()

Caches the value or error event of the upstream Solo and relays/replays it to Subscribers.

Returns:
  the new Solo instance
Since:
  0.14.1

#### subscribe

    public final void subscribe(org.reactivestreams.Subscriber<? super T> s)

Specified by:
  `subscribe` in interface `org.reactivestreams.Publisher<T>`

#### subscribeActual

    protected abstract void subscribeActual(org.reactivestreams.Subscriber<? super T> s)

Implement this method to react to a Subscriber subscribing to this Solo.

Parameters:
  `s` - the downstream Subscriber, never null

#### subscribeWith

    public final <E extends org.reactivestreams.Subscriber<? super T>> E subscribeWith(E s)

Subscribe with a Subscriber (subclass) and return it as is.

Type Parameters:
  `E` - the Subscriber subclass type
Parameters:
  `s` - the soubscriber, not null
Returns:
  the `s` as is

#### subscribe

    public final io.reactivex.disposables.Disposable subscribe()

Subscribe to this Solo and ignore any signal it produces.

Returns:
  the Disposable that allows cancelling the subscription

#### subscribe

    public final io.reactivex.disposables.Disposable subscribe(io.reactivex.functions.Consumer<? super T> onNext)

Subscribes to this Solo and calls the onNext if this Solo succeeds.

Parameters:
  `onNext` - called when this Solo succeeds
Returns:
  the Disposable that allows cancelling the subscription

#### subscribe

    public final io.reactivex.disposables.Disposable subscribe(io.reactivex.functions.Consumer<? super T> onNext,
                                                               io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)

Subscribes to this Solo and calls the appropriate callback for the resulting signal.

Parameters:
  `onNext` - called when this Solo succeeds
  `onError` - called when this Solo fails
Returns:
  the Disposable that allows cancelling the subscription

#### subscribe

    public final io.reactivex.disposables.Disposable subscribe(io.reactivex.functions.Consumer<? super T> onNext,
                                                               io.reactivex.functions.Consumer<? super java.lang.Throwable> onError,
                                                               io.reactivex.functions.Action onComplete)

Subscribes to this Solo and calls the appropriate callback for the resulting signal.

Parameters:
  `onNext` - called when this Solo succeeds
  `onError` - called when this Solo fails
  `onComplete` - called when this Solo succeeds after the call to onNext
Returns:
  the Disposable that allows cancelling the subscription

#### blockingSubscribe

    public final void blockingSubscribe()

Blocks until this Solo terminates and ignores the signals it produced.

#### blockingSubscribe

    public final void blockingSubscribe(io.reactivex.functions.Consumer<? super T> onNext)

Blocks until this Solo terminates and calls the onNext with the success value.

Parameters:
  `onNext` - the callback to call when this Solo completes with a success value

#### blockingSubscribe

    public final void blockingSubscribe(io.reactivex.functions.Consumer<? super T> onNext,
                                        io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)

Blocks until this solo terminates and calls the onNext with the success value or calls the onError with the error Throwable.

Parameters:
  `onNext` - the callback to call when this Solo completes with a success value
  `onError` - the callback to call when this Solo fails with an error

#### blockingSubscribe

    public final void blockingSubscribe(io.reactivex.functions.Consumer<? super T> onNext,
                                        io.reactivex.functions.Consumer<? super java.lang.Throwable> onError,
                                        io.reactivex.functions.Action onComplete)

Blocks until this Solo produces its terminal signal and calls the appropriate callback(s) based on the signal type.

Parameters:
  `onNext` - called when the Solo succeeds
  `onError` - called when the Solo fails
  `onComplete` - called when the Solo succeeds after the call to onNext.

#### blockingGet

    public final T blockingGet()

Blockingly awaits indefinitely the success value of this Solo or rethrows its error (wrapped into a RuntimeException if necessary).

Returns:
  the success value of this Solo

#### blockingGet

    public final T blockingGet(long timeout,
                               java.util.concurrent.TimeUnit unit)

Blockingly awaits at most the given timeout for the success value of this Solo or rethrows its error (wrapped into a RuntimeException if necessary).

Parameters:
  `timeout` - the time to wait for a success value
  `unit` - the time unit of the timeout
Returns:
  the success value of this Solo

#### test

    public final io.reactivex.subscribers.TestSubscriber<T> test()

Creates a TestSubscriber and subscribes it to this Solo.

Returns:
  the new TestSubscriber instance

#### test

    public final io.reactivex.subscribers.TestSubscriber<T> test(boolean cancel)

Creates a TestSubscriber, optionally cancels it, and subscribes it to this Solo.

Parameters:
  `cancel` - if true, the TestSubscriber will be cancelled before subscribing to this Solo
Returns:
  the new TestSubscriber instance

#### test

    public final io.reactivex.subscribers.TestSubscriber<T> test(long initialRequest)

Creates a TestSubscriber with the given initial request and subscribes it to this Solo.

Parameters:
  `initialRequest` - the initial request amount, non-negative
Returns:
  the new TestSubscriber

#### test

    public final io.reactivex.subscribers.TestSubscriber<T> test(long initialRequest,
                                                                 boolean cancel)

Creates a TestSubscriber with the given initial request, optionally cancels it, and subscribes it to this Solo.

Parameters:
  `initialRequest` - the initial request amount, non-negative
  `cancel` - if true, the TestSubscriber will be cancelled before subscribing to this Solo
Returns:
  the new TestSubscriber

#### toFuture

    public final java.util.concurrent.Future<T> toFuture()

Converts this Solo into a Future and signals its single value.

Returns:
  the new Future instance