app.futured.arkitekt.rxusecases.disposables

Class FlowableDisposablesOwner.DefaultImpls

app.futured.arkitekt.rxusecases.disposables.FlowableDisposablesOwner.DefaultImpls

Enclosing interface:

FlowableDisposablesOwner

public static class FlowableDisposablesOwner.DefaultImpls

This interface gives your class ability to execute class FlowableUseCase use cases and automatically add resulting disposables to one composite disposable. You may find handy to implement this interface in custom Presenters, ViewHolders etc.

Consider using interface DisposablesOwner to support all of the basic RxJava 2 types.

It is your responsibility to clear this composite disposable when all running tasks should be stopped.

See Also:

class FlowableUseCase, interface DisposablesOwner

Method Summary

Modifier and Type	Method and Description
static <T> io.reactivex.disposables.Disposable	execute(FlowableDisposablesOwner $this, FlowableUseCase<kotlin.Unit,T> $receiver, kotlin.jvm.functions.Function1<? super app.futured.arkitekt.rxusecases.disposables.FlowableUseCaseConfig.Builder<T>,kotlin.Unit> config) Executes the use case and adds its disposable to shared, automatically disposed, composite disposable. In case some variant of FlowableUseCase.execute method has already been called on this instance of class FlowableUseCase, previous one is disposed, no matter what current state of internal Flowable is. This behavior can be disabled by passing false to FlowableUseCaseConfig.disposePrevious method.
static <ARGS,T> io.reactivex.disposables.Disposable	execute(FlowableDisposablesOwner $this, FlowableUseCase<ARGS,T> $receiver, ARGS args, kotlin.jvm.functions.Function1<? super app.futured.arkitekt.rxusecases.disposables.FlowableUseCaseConfig.Builder<T>,kotlin.Unit> config) Executes the use case and adds its disposable to shared, automatically disposed, composite disposable. In case some variant of FlowableUseCase.execute method has already been called on this instance of class FlowableUseCase, previous one is disposed, no matter what current state of internal Flowable is. This behavior can be disabled by passing false to FlowableUseCaseConfig.disposePrevious method.
static <T> io.reactivex.disposables.Disposable	executeStream(FlowableDisposablesOwner $this, io.reactivex.Flowable<T> $receiver, kotlin.jvm.functions.Function1<? super app.futured.arkitekt.rxusecases.disposables.FlowableUseCaseConfig.Builder<T>,kotlin.Unit> config) Executes the Flowable and adds its disposable to shared, automatically disposed, composite disposable.

Method Detail

execute

@NotNull
public static <T> io.reactivex.disposables.Disposable execute(FlowableDisposablesOwner $this,
                                                                       @NotNull
                                                                       FlowableUseCase<kotlin.Unit,T> $receiver,
                                                                       @NotNull
                                                                       kotlin.jvm.functions.Function1<? super app.futured.arkitekt.rxusecases.disposables.FlowableUseCaseConfig.Builder<T>,kotlin.Unit> config)

Executes the use case and adds its disposable to shared, automatically disposed, composite disposable. In case some variant of FlowableUseCase.execute method has already been called on this instance of class FlowableUseCase, previous one is disposed, no matter what current state of internal Flowable is. This behavior can be disabled by passing false to FlowableUseCaseConfig.disposePrevious method.

Parameters:

$receiver - FlowablerConfig used to process results of internal Flowable.

config - FlowablerConfig used to process results of internal Flowable.

Returns:

disposable of internal Flowable. This disposable is disposed automatically. It might be used to dispose use case when you need to dispose it in advance on your own.

See Also:

FlowableUseCase.execute, class FlowableUseCase

execute

@NotNull
public static <ARGS,T> io.reactivex.disposables.Disposable execute(FlowableDisposablesOwner $this,
                                                                            @NotNull
                                                                            FlowableUseCase<ARGS,T> $receiver,
                                                                            ARGS args,
                                                                            @NotNull
                                                                            kotlin.jvm.functions.Function1<? super app.futured.arkitekt.rxusecases.disposables.FlowableUseCaseConfig.Builder<T>,kotlin.Unit> config)

Executes the use case and adds its disposable to shared, automatically disposed, composite disposable. In case some variant of FlowableUseCase.execute method has already been called on this instance of class FlowableUseCase, previous one is disposed, no matter what current state of internal Flowable is. This behavior can be disabled by passing false to FlowableUseCaseConfig.disposePrevious method.

Parameters:

$receiver - Arguments used for initial use case initialisation.

args - class FlowableUseCaseConfig used to process results of internal Flowable.

config - class FlowableUseCaseConfig used to process results of internal Flowable.

Returns:

disposable of internal Flowable. This disposable is disposed automatically. It might be used to dispose use case when you need to dispose it in advance on your own.

See Also:

FlowableUseCase.execute, class FlowableUseCase

executeStream

@NotNull
public static <T> io.reactivex.disposables.Disposable executeStream(FlowableDisposablesOwner $this,
                                                                             @NotNull
                                                                             io.reactivex.Flowable<T> $receiver,
                                                                             @NotNull
                                                                             kotlin.jvm.functions.Function1<? super app.futured.arkitekt.rxusecases.disposables.FlowableUseCaseConfig.Builder<T>,kotlin.Unit> config)

Executes the Flowable and adds its disposable to shared, automatically disposed, composite disposable.

Parameters:

$receiver - class FlowableUseCaseConfig used to process results of internal Flowable.

config - class FlowableUseCaseConfig used to process results of internal Flowable.

Returns:

disposable of internal Flowable. It might be used to dispose use case when you need to dispose it in advance on your own.