com.spotify.mobius.rx

Class RxMobius.SubtypeEffectHandlerBuilder<F,E>

java.lang.Object

com.spotify.mobius.rx.RxMobius.SubtypeEffectHandlerBuilder<F,E>

Enclosing class:

RxMobius

public static class RxMobius.SubtypeEffectHandlerBuilder<F,E>
extends java.lang.Object

Builder for a type-routing effect handler.

Register handlers for different subtypes of F using the add(...) methods, and call build() to create an instance of the effect handler. You can then create a loop with the router as the effect handler using RxMobius.loop(Update, Observable.Transformer).

The handler will look at the type of each incoming effect object and try to find a registered handler for that particular subtype of F. If a handler is found, it will be given the effect object, otherwise an exception will be thrown.

All the classes that the effect router know about must have a common type F. Note that instances of the builder are mutable and not thread-safe.

Method Summary

Modifier and Type	Method and Description
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	add(java.lang.Class<G> effectClass, rx.functions.Action0 action) Deprecated. use addAction(Class, Action0)
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	add(java.lang.Class<G> effectClass, rx.functions.Action0 action, rx.Scheduler scheduler) Deprecated. use addAction(Class, Action0, Scheduler)
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	add(java.lang.Class<G> effectClass, rx.functions.Action1<G> action) Deprecated. use addConsumer(Class, Action1)
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	add(java.lang.Class<G> effectClass, rx.functions.Action1<G> action, rx.Scheduler scheduler) Deprecated. use addConsumer(Class, Action1, Scheduler)
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	add(java.lang.Class<G> effectClass, rx.Observable.Transformer<G,E> effectHandler) Deprecated. use #addTransformer(Class, Transformer)
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	addAction(java.lang.Class<G> effectClass, rx.functions.Action0 action) Add an Action0 for handling effects of a given type.
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	addAction(java.lang.Class<G> effectClass, rx.functions.Action0 action, rx.Scheduler scheduler) Add an Action0 for handling effects of a given type.
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	addConsumer(java.lang.Class<G> effectClass, rx.functions.Action1<G> consumer) Add an Action1 for handling effects of a given type.
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	addConsumer(java.lang.Class<G> effectClass, rx.functions.Action1<G> consumer, rx.Scheduler scheduler) Add an Action1 for handling effects of a given type.
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	addFunction(java.lang.Class<G> effectClass, com.spotify.mobius.functions.Function<G,E> function) Add a Func1 for handling effects of a given type.
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	addFunction(java.lang.Class<G> effectClass, com.spotify.mobius.functions.Function<G,E> function, rx.Scheduler scheduler) Add a Func1 for handling effects of a given type.
<G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E>	addTransformer(java.lang.Class<G> effectClass, rx.Observable.Transformer<G,E> effectHandler) Add an Observable.Transformer for handling effects of a given type.
rx.Observable.Transformer<F,E>	build()
RxMobius.SubtypeEffectHandlerBuilder<F,E>	withFatalErrorHandler(rx.functions.Func1<rx.Observable.Transformer<? extends F,E>,rx.functions.Action1<java.lang.Throwable>> onErrorFunction) Optionally set a shared error handler in case a handler throws an uncaught exception.

Methods inherited from class java.lang.Object

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

Method Detail

add

@Deprecated
public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> add(java.lang.Class<G> effectClass,
                                                                               rx.Observable.Transformer<G,E> effectHandler)

Deprecated. use #addTransformer(Class, Transformer)

Add an Observable.Transformer for handling effects of a given type. The handler will receive all effect objects that extend the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the effect class to handle

effectHandler - the effect handler for the given effect class

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

add

@Deprecated
public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> add(java.lang.Class<G> effectClass,
                                                                               rx.functions.Action0 action)

Deprecated. use addAction(Class, Action0)

Add an Action0 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

action - the action that should be invoked for the effect

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

add

@Deprecated
public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> add(java.lang.Class<G> effectClass,
                                                                               rx.functions.Action0 action,
                                                                               rx.Scheduler scheduler)

Deprecated. use addAction(Class, Action0, Scheduler)

Add an Action0 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

action - the action that should be invoked for the effect

scheduler - the scheduler that should be used to invoke the action

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

add

@Deprecated
public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> add(java.lang.Class<G> effectClass,
                                                                               rx.functions.Action1<G> action)

Deprecated. use addConsumer(Class, Action1)

Add an Action1 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

action - the action that should be invoked for the effect

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

add

@Deprecated
public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> add(java.lang.Class<G> effectClass,
                                                                               rx.functions.Action1<G> action,
                                                                               rx.Scheduler scheduler)

Deprecated. use addConsumer(Class, Action1, Scheduler)

Add an Action1 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

action - the action that should be invoked for the effect

scheduler - the scheduler that should be used to invoke the action

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

addFunction

public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> addFunction(java.lang.Class<G> effectClass,
                                                                           com.spotify.mobius.functions.Function<G,E> function)

Add a Func1 for handling effects of a given type. The function will be invoked once for every received effect object that extends the given class. The returned event will be forwarded to the Mobius loop.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

function - the function that should be invoked for the effect

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

addFunction

public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> addFunction(java.lang.Class<G> effectClass,
                                                                           com.spotify.mobius.functions.Function<G,E> function,
                                                                           rx.Scheduler scheduler)

Add a Func1 for handling effects of a given type. The function will be invoked once for every received effect object that extends the given class. The returned event will be forwarded to the Mobius loop.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

function - the function that should be invoked for the effect

scheduler - the scheduler that should be used when invoking the function

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

addTransformer

public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> addTransformer(java.lang.Class<G> effectClass,
                                                                              rx.Observable.Transformer<G,E> effectHandler)

Add an Observable.Transformer for handling effects of a given type. The handler will receive all effect objects that extend the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the effect class to handle

effectHandler - the effect handler for the given effect class

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

addAction

public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> addAction(java.lang.Class<G> effectClass,
                                                                         rx.functions.Action0 action)

Add an Action0 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

action - the action that should be invoked for the effect

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

addAction

public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> addAction(java.lang.Class<G> effectClass,
                                                                         rx.functions.Action0 action,
                                                                         rx.Scheduler scheduler)

Add an Action0 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

action - the action that should be invoked for the effect

scheduler - the scheduler that should be used to invoke the action

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

addConsumer

public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> addConsumer(java.lang.Class<G> effectClass,
                                                                           rx.functions.Action1<G> consumer)

Add an Action1 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

consumer - the consumer that should be invoked for the effect

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

addConsumer

public <G extends F> RxMobius.SubtypeEffectHandlerBuilder<F,E> addConsumer(java.lang.Class<G> effectClass,
                                                                           rx.functions.Action1<G> consumer,
                                                                           rx.Scheduler scheduler)

Add an Action1 for handling effects of a given type. The action will be invoked once for every received effect object that extends the given class.

Adding handlers for two effect classes where one is a super-class of the other is considered a collision and is not allowed. Registering the same class twice is also considered a collision.

Type Parameters:

G - the effect class as a type parameter

Parameters:

effectClass - the class to handle

consumer - the consumer that should be invoked for the effect

scheduler - the scheduler that should be used to invoke the action

Returns:

this builder

Throws:

java.lang.IllegalArgumentException - if there is a handler collision

withFatalErrorHandler

public RxMobius.SubtypeEffectHandlerBuilder<F,E> withFatalErrorHandler(rx.functions.Func1<rx.Observable.Transformer<? extends F,E>,rx.functions.Action1<java.lang.Throwable>> onErrorFunction)

Optionally set a shared error handler in case a handler throws an uncaught exception.

The default is to use RxJavaHooks.onError(Throwable). Note that any exception thrown by a handler is a fatal error and this method doesn't enable safe error handling, only configurable crash reporting.

Parameters:

onErrorFunction - a function that gets told which sub-transformer failed and should return an appropriate handler for exceptions thrown.

build

public rx.Observable.Transformer<F,E> build()