digital.bakehouse.rxusecase

Class RxUseCase<I,O>

java.lang.Object

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

Type Parameters:

I - Input type

O - Output type

Direct Known Subclasses:

AsynchronousUseCase, ContinuousUseCase, DelegateUseCase, SynchronousUseCase

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

RxUseCase wraps the logic / action / mechanism that the use-case implements, into an Observable that can be subscribed to. It can act as an interactor, communicating to with internal or external components or systems for: - validating data, current state or context - retrieving or setting data, local or remote - subscribing to continuous data changes - doing any sort of operations, long or short running, one-shot or continously emitting It should be thought of as a self-contained operation with single contextual responsibility.

RxUseCase has a standard interface of passing and getting data. It: - operates with the Request parameter, which wraps the input required by the use-case - emits a Response object which encapsulates either a successful output or the failure returned by the use-case This enables another way of describing use-cases as entities which act as a standard input - standard output proxies to the outside world.

Constructor Summary

Constructors

Constructor and Description
RxUseCase()

Method Summary

Modifier and Type	Method and Description
static void	addDecorator(UseCaseDecorator decorator) Add a global decorator for use-cases.
io.reactivex.Observable<Response<O>>	create() Create use-case observable without passing any input.
io.reactivex.Observable<Response<O>>	create(I input) Create use-case observable with input.
io.reactivex.Observable<Response<O>>	create(Request<I> request) Create use-case observable passing a Request parameter.
<T extends RxUseCase<I,O>> T	decorateWith(java.util.Collection<UseCaseDecorator> decorators) Decorate this use-case with a list of UseCaseDecorator implementations.
<T extends RxUseCase<I,O>> T	decorateWith(UseCaseDecorator decorator) Add a UseCaseDecorator to the list of items decorating this use-case.
<T extends RxUseCase<I,O>> T	decorateWithNothing() Remove all the decorators previously set for this use-case including the global ones.
protected abstract io.reactivex.Observable<Response<O>>	execute(I input) Create use-case observable with input.
static <I,O> RxUseCase<I,O>	fromAsynchronous(Asynchronous<I,O> operation) Create a use-case from a Asynchronous operation.
static <I,O> RxUseCase<I,O>	fromContinuous(Continuous<I,O> operation) Create a use-case from a Continuous operation.
static <I,O> RxUseCase<I,O>	fromSource(RxSource<I,O> source) Create a use-case from an implementation of RxSource.
static <I,O> RxUseCase<I,O>	fromSynchronous(Synchronous<I,O> operation) Create a use-case from a Synchronous operation.
Response<O>	get() Get use-case response.
Response<O>	get(I input) Get use-case response for the input.
Response<O>	get(Request<I> request) Get use-case response passing a Request parameter.
protected io.reactivex.Observable<Response<O>>	justFail(java.lang.String code, java.lang.String message) Emit the passed code and message wrapped into a Response.
protected io.reactivex.Observable<Response<O>>	justSucceed(O output) Emit the passed object wrapped into a Response.
<T extends RxUseCase<I,O>> T	origin(java.lang.String origin) Set the originator of the use-case
static void	removeDecorator(UseCaseDecorator decorator) Remove a global decorator of use-cases.
protected static <O> io.reactivex.Observable<Response<O>>	safeCreate(io.reactivex.ObservableOnSubscribe<Response<O>> subscriber) Create an Observable using a SafeEmitter.
protected static <I,O> io.reactivex.Observable<Response<O>>	toRx(Asynchronous<I,O> operation, I input) Transform an Asynchronous operation into an Observable.
protected static <I,O> io.reactivex.Observable<Response<O>>	toRx(Continuous<I,O> operation, I input) Transform a Continuous operation into an Observable.
protected static <I,O> io.reactivex.Observable<Response<O>>	toRx(Synchronous<I,O> operation, I input) Transform a Synchronous operation into an Observable.

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 use-case observable without passing any input. This effectively will invoke create(Object) passing null as input. The sole purpose of this method is to simplify the use-case usage when no input is required by the use-case.

Returns:

Observable stream

create

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

Create use-case observable with input. The passed input will be wrapped into a Request object and passed to the create(Request) method.

Parameters:

input - Use-case input

Returns:

Observable stream

create

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

Create use-case observable passing a Request parameter. This method is the entry point to the logic/mechanism/action that this use-case represents. Typically the subscription to the returned Observable will trigger the execution of the use-case.

Parameters:

request - Use-case request

Returns:

Observable stream

get

public final Response<O> get()

Get use-case response. This effectively will invoke get(Object) passing null as input. The sole purpose of this method is to simplify the use-case usage when no input is required by the use-case.

Returns:

Use-case response.

get

public final Response<O> get(I input)

Get use-case response for the input. The passed input will be wrapped into a Request object and passed to the get(Request) method.

Parameters:

input - Use-case input

Returns:

Use-case response

get

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

Get use-case response passing a Request parameter. This method is pointing to the entry point to the logic/mechanism/action that this use-case represents. It is useful in situations when the response of the use-case is required to be retrieved in a blocking manner. The method will block until the first item is emitted by create(Request), return it. See Observable.blockingFirst() for reference.

Parameters:

request - Use-case request

Returns:

Observable stream

execute

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

Create use-case observable with input. This method will get called by invoking any of the: create(), create(Object), create(Request) methods. Implement it to define the logic/mechanism/action that this use-case represents.

Parameters:

input - Use-case input

Returns:

Observable stream

justSucceed

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

Emit the passed object wrapped into a Response. Utility method that builds and returns an Observable that emits a successful Response wrapping the output.

Parameters:

output - Use-case output

Returns:

Observable stream

justFail

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

Emit the passed code and message wrapped into a Response. Utility method that builds and returns an Observable that emits a failure Response wrapping the passed error code and error message

Parameters:

code - Error code

message - Error message

Returns:

Observable stream

origin

public final <T extends RxUseCase<I,O>> T origin(java.lang.String origin)

Set the originator of the use-case

Type Parameters:

T - Type of this use-case

Parameters:

origin - Originator

Returns:

This use-case

decorateWith

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

Decorate this use-case with a list of UseCaseDecorator implementations. Effectively, the use-case observable returned from execute(Object) method will be decorated in a chain manner with items in this list. The order of elements in the passed list is important because the decorators may decide to pre and post-process streams, for ex. by filtering out the emission of certain elements. NOTE: Invoking this method will disable the global decorators for this instance of this use-case.

See UseCaseDecorator for reference

Type Parameters:

T - Type of this use-case

Parameters:

decorators - List of decorators

Returns:

This use-case

decorateWith

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

Add a UseCaseDecorator to the list of items decorating this use-case. NOTE: Invoking this method will disable the global decorators for this instance of this use-case. Please see decorateWith(Collection) and UseCaseDecorator for reference

Type Parameters:

T - Type of this use-case

Parameters:

decorator - Decorator of use-case

Returns:

This use-case

decorateWithNothing

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

Remove all the decorators previously set for this use-case including the global ones.

Type Parameters:

T - Type of this use-case

Returns:

This use-case

addDecorator

public static void addDecorator(UseCaseDecorator decorator)

Add a global decorator for use-cases. All use-case observables returned from their respective execute(Object) method will be decorated by this item, unless they define local UseCaseDecorator or clear the decoration mechanism, see decorateWith(Collection), decorateWith(UseCaseDecorator) and decorateWithNothing() for this.

Parameters:

decorator - Global decorator

removeDecorator

public static void removeDecorator(UseCaseDecorator decorator)

Remove a global decorator of use-cases.

Parameters:

decorator - Global decorator

fromSynchronous

public static <I,O> RxUseCase<I,O> fromSynchronous(Synchronous<I,O> operation)

Create a use-case from a Synchronous operation. This method will wrap the logic / action / mechanism defined in the operation into an instance of RxUseCase.

See Synchronous for reference.

Type Parameters:

I - Input type

O - Output type

Parameters:

operation - Use-case operation

Returns:

Rx use-case

fromAsynchronous

public static <I,O> RxUseCase<I,O> fromAsynchronous(Asynchronous<I,O> operation)

Create a use-case from a Asynchronous operation. This method will wrap the logic / action / mechanism defined in the operation into an instance of RxUseCase.

See Asynchronous for reference.

Type Parameters:

I - Input type

O - Output type

Parameters:

operation - Use-case operation

Returns:

Rx use-case

fromContinuous

public static <I,O> RxUseCase<I,O> fromContinuous(Continuous<I,O> operation)

Create a use-case from a Continuous operation. This method will wrap the logic / action / mechanism defined in the operation into an instance of RxUseCase.

See Continuous for reference.

Type Parameters:

I - Input type

O - Output type

Parameters:

operation - Use-case operation

Returns:

Rx use-case

fromSource

public static <I,O> RxUseCase<I,O> fromSource(RxSource<I,O> source)

Create a use-case from an implementation of RxSource. This method will wrap the logic / action / mechanism defined in the source into an instance of RxUseCase. It is useful for situations when extending RxUseCase class is not an option, and the other operations are not suitable.

See RxSource for reference.

Type Parameters:

I - Input type

O - Output type

Parameters:

source - Observable source

Returns:

Rx use-case

toRx

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

Transform a Synchronous operation into an Observable.

Type Parameters:

I - Input type

O - Output type

Parameters:

operation - Use-case operation

input - Operation input

Returns:

Observable stream

toRx

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

Transform an Asynchronous operation into an Observable.

Type Parameters:

I - Input type

O - Output type

Parameters:

operation - Use-case operation

input - Operation input

Returns:

Observable stream

toRx

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

Transform a Continuous operation into an Observable.

Type Parameters:

I - Input type

O - Output type

Parameters:

operation - Use-case operation

input - Operation input

Returns:

Observable stream

safeCreate

protected static <O> io.reactivex.Observable<Response<O>> safeCreate(io.reactivex.ObservableOnSubscribe<Response<O>> subscriber)

Create an Observable using a SafeEmitter. This will allow invocations of Emitter.onNext(Object), Emitter.onNext(Object) and Emitter.onNext(Object) without first verifying the ObservableEmitter.isDisposed() status.

See SafeEmitter for reference.

Type Parameters:

O - Output type

Parameters:

subscriber - OnSubscribe hook

Returns:

Observable stream