Reactor

All Known Implementing Classes:

SimpleViewModelReactor, ViewModelReactor
```
public Reactor<Action,Mutation,State>
```
A Reactor is an UI-independent layer which manages the state of a view. The foremost role of a interface Reactor is to separate control flow from a view. Every view has its corresponding interface Reactor and delegates all logic to its interface Reactor. A interface Reactor has no dependency to a view, so it can be easily tested.
Reference: https://github.com/ReactorKit/ReactorKit

See Also:

interface Reactor, interface Reactor, interface Reactor, interface Reactor

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Reactor.DefaultImpls` A Reactor is an UI-independent layer which manages the state of a view. The foremost role of a `interface Reactor` is to separate control flow from a view. Every view has its corresponding `interface Reactor` and delegates all logic to its `interface Reactor`. A `interface Reactor` has no dependency to a view, so it can be easily tested.

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`io.reactivex.Observable<? extends State>`	`createStateStream()` Creates the State stream by transforming the `class ActionRelay` to a State observable.
`ActionRelay<Action>`	`getAction()` The Action from the view. Bind user inputs to this relay.
`State`	`getCurrentState()` The current State. This value is changed just after the state stream emits a new State.
`io.reactivex.disposables.CompositeDisposable`	`getDisposables()` The CompositeDisposable that contains the State Stream disposable.
`State`	`getInitialState()` The initial State.
`io.reactivex.Observable<? extends State>`	`getState()` The State stream. Use this observable to observe the state changes.
`io.reactivex.Observable<? extends Mutation>`	`mutate(Action action)` Commits mutation from the Action. This is the best place to perform side-effects such as async tasks.
`State`	`reduce(State state, Mutation mutation)` Generates a new state with the previous State and the Action. It should be purely functional so it should not perform any side-effects here. This method is called every time when the Mutation is committed.
`void`	`setCurrentState(State p)` The current State. This value is changed just after the state stream emits a new State.
`io.reactivex.Observable<? extends Action>`	`transformAction(io.reactivex.Observable<Action> action)` Transforms the Action. Use this function to combine with other observables. This method is called once before the state stream is created.
`io.reactivex.Observable<? extends Mutation>`	`transformMutation(io.reactivex.Observable<Mutation> mutation)` Transforms the Mutation stream. Implement this method to transform or combine with other observables. This method is called once before the state stream is created.
`io.reactivex.Observable<State>`	`transformState(io.reactivex.Observable<State> state)` Transforms the State stream. Use this function to perform side-effects such as logging. This method is called once after the state stream is created.

- Method Detail
  - getDisposables
```
io.reactivex.disposables.CompositeDisposable getDisposables()
```
    The CompositeDisposable that contains the State Stream disposable.
  - getAction
```
ActionRelay<Action> getAction()
```
    The Action from the view. Bind user inputs to this relay.
  - getState
```
io.reactivex.Observable<? extends State> getState()
```
    The State stream. Use this observable to observe the state changes.
  - getInitialState
```
State getInitialState()
```
    The initial State.
  - getCurrentState
```
State getCurrentState()
```
    The current State. This value is changed just after the state stream emits a new State.
  - setCurrentState
```
void setCurrentState(State p)
```
    The current State. This value is changed just after the state stream emits a new State.
  - mutate
```
io.reactivex.Observable<? extends Mutation> mutate(Action action)
```
    Commits mutation from the Action. This is the best place to perform side-effects such as async tasks.
  - reduce
```
State reduce(State state,
             Mutation mutation)
```
    Generates a new state with the previous State and the Action. It should be purely functional so it should not perform any side-effects here. This method is called every time when the Mutation is committed.
  - transformAction
```
io.reactivex.Observable<? extends Action> transformAction(io.reactivex.Observable<Action> action)
```
    Transforms the Action. Use this function to combine with other observables. This method is called once before the state stream is created.
  - transformMutation
```
io.reactivex.Observable<? extends Mutation> transformMutation(io.reactivex.Observable<Mutation> mutation)
```
    Transforms the Mutation stream. Implement this method to transform or combine with other observables. This method is called once before the state stream is created.
  - transformState
```
io.reactivex.Observable<State> transformState(io.reactivex.Observable<State> state)
```
    Transforms the State stream. Use this function to perform side-effects such as logging. This method is called once after the state stream is created.
  - createStateStream
```
io.reactivex.Observable<? extends State> createStateStream()
```
    Creates the State stream by transforming the class ActionRelay to a State observable.
    
    See Also:
    
    class ActionRelay

Interface Reactor<Action,Mutation,State>

Nested Class Summary

Method Summary

Method Detail

getDisposables

getAction

getState

getInitialState

getCurrentState

setCurrentState

mutate

reduce

transformAction

transformMutation

transformState

createStateStream