digital.bakehouse.rxusecase

Class RxUseCase<I,O>

java.lang.Object

digital.bakehouse.rxusecase.RxUseCase<I,O>

Direct Known Subclasses:

AsynchronousUseCase, ContinuousUseCase, SynchronousUseCase

public abstract class RxUseCase<I,O>
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
RxUseCase()

Method Summary

Modifier and Type	Method and Description
static void	addDecorator(UseCaseDecorator decorator)
io.reactivex.Observable<Response<O>>	create()
io.reactivex.Observable<Response<O>>	create(I input)
io.reactivex.Observable<Response<O>>	create(Request<I> request)
<T extends RxUseCase<I,O>> T	decorateWith(java.util.Collection<UseCaseDecorator> decorators)
<T extends RxUseCase<I,O>> T	decorateWith(UseCaseDecorator decorator)
<T extends RxUseCase<I,O>> T	decorateWithNothing()
protected abstract io.reactivex.Observable<Response<O>>	execute(I input)
Response<O>	get()
Response<O>	get(I input)
Response<O>	get(Request<I> request)
protected io.reactivex.Observable<Response<O>>	justFail(java.lang.String code, java.lang.String message)
protected io.reactivex.Observable<Response<O>>	justSucceed(O output)
static void	removeDecorator(UseCaseDecorator decorator)
static <I,O> io.reactivex.Observable<Response<O>>	toRx(Asynchronous<I,O> operation, I input)
static <I,O> io.reactivex.Observable<Response<O>>	toRx(Continuous<I,O> operation, I input)
static <I,O> io.reactivex.Observable<Response<O>>	toRx(Synchronous<I,O> operation, I input)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(Asynchronous<I,O> operation, I input)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(Asynchronous<I,O> operation, Request<I> request)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(Continuous<I,O> operation, I input)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(Continuous<I,O> operation, Request<I> request)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(io.reactivex.Observable<O> stream, I input)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(io.reactivex.Observable<O> stream, Request<I> request)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(Synchronous<I,O> operation, I input)
static <I,O> io.reactivex.Observable<Response<O>>	wrap(Synchronous<I,O> operation, Request<I> request)

Methods inherited from class java.lang.Object

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

Constructor Detail

RxUseCase

public RxUseCase()

Method Detail

create

public final io.reactivex.Observable<Response<O>> create()

create

public final io.reactivex.Observable<Response<O>> create(I input)

create

public final io.reactivex.Observable<Response<O>> create(Request<I> request)

get

public final Response<O> get()

get

public final Response<O> get(I input)

get

public final Response<O> get(Request<I> request)

execute

protected abstract io.reactivex.Observable<Response<O>> execute(I input)

justSucceed

protected io.reactivex.Observable<Response<O>> justSucceed(O output)

justFail

protected io.reactivex.Observable<Response<O>> justFail(java.lang.String code,
                                                        java.lang.String message)

decorateWith

public final <T extends RxUseCase<I,O>> T decorateWith(java.util.Collection<UseCaseDecorator> decorators)

decorateWith

public final <T extends RxUseCase<I,O>> T decorateWith(UseCaseDecorator decorator)

decorateWithNothing

public final <T extends RxUseCase<I,O>> T decorateWithNothing()

addDecorator

public static void addDecorator(UseCaseDecorator decorator)

removeDecorator

public static void removeDecorator(UseCaseDecorator decorator)

toRx

public static <I,O> io.reactivex.Observable<Response<O>> toRx(Synchronous<I,O> operation,
                                                              I input)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(Synchronous<I,O> operation,
                                                              I input)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(Synchronous<I,O> operation,
                                                              Request<I> request)

toRx

public static <I,O> io.reactivex.Observable<Response<O>> toRx(Asynchronous<I,O> operation,
                                                              I input)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(Asynchronous<I,O> operation,
                                                              I input)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(Asynchronous<I,O> operation,
                                                              Request<I> request)

toRx

public static <I,O> io.reactivex.Observable<Response<O>> toRx(Continuous<I,O> operation,
                                                              I input)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(Continuous<I,O> operation,
                                                              I input)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(Continuous<I,O> operation,
                                                              Request<I> request)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(io.reactivex.Observable<O> stream,
                                                              I input)

wrap

public static <I,O> io.reactivex.Observable<Response<O>> wrap(io.reactivex.Observable<O> stream,
                                                              Request<I> request)