Package discord4j.core.event

Class SinksEventDispatcher

java.lang.Object

discord4j.core.event.SinksEventDispatcher

All Implemented Interfaces:

EventDispatcher

@Experimental
public class SinksEventDispatcher
extends Object
implements EventDispatcher

Distributes Event instances to subscribers, using Reactor Sinks as backend.

The underlying sink and thread affinity for event publishing can be configured at construction time.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	SinksEventDispatcher.Builder	A builder to create EventDispatcher instances.

Field Summary

Fields inherited from interface discord4j.core.event.EventDispatcher

DEFAULT_EVENT_SCHEDULER

Constructor Summary

Constructors

Constructor	Description
SinksEventDispatcher(Function<Sinks.ManySpec,Sinks.Many<Event>> eventSinkFactory, EmissionStrategy emissionStrategy, Scheduler eventScheduler)	Creates a new event dispatcher using the given event sink factory and threading model.

Method Summary

Modifier and Type	Method	Description
<E extends Event> Flux<E>	on(Class<E> eventClass)	Retrieves a Flux with elements of the given Event type.
void	publish(Event event)	Publishes an Event to the dispatcher.
void	shutdown()	Signal that this event dispatcher must terminate and release its resources.

Methods inherited from class java.lang.Object

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

Methods inherited from interface discord4j.core.event.EventDispatcher

on, on

Constructor Details

SinksEventDispatcher

public SinksEventDispatcher(Function<Sinks.ManySpec,Sinks.Many<Event>> eventSinkFactory,
 EmissionStrategy emissionStrategy,
 Scheduler eventScheduler)

Creates a new event dispatcher using the given event sink factory and threading model.

Parameters:

eventSinkFactory - the custom sink factory for events

emissionStrategy - a strategy to handle emission failures

eventScheduler - a Scheduler to ensure a certain thread model on each published signal

Method Details

on

public <E extends Event> Flux<E> on(Class<E> eventClass)

Description copied from interface: EventDispatcher

Retrieves a Flux with elements of the given Event type. This Flux has to be subscribed to in order to start processing. See Event class for the list of possible event classes.

Note: Errors occurring while processing events will terminate your sequence. If you wish to use a version capable of handling errors for you, use EventDispatcher.on(Class, Function). See Reactive Streams Spec explaining this behavior.

A recommended pattern to use this method is wrapping your code that may throw exceptions within a flatMap block and use Mono.onErrorResume(Function), Flux.onErrorResume(Function) or equivalent methods to maintain the sequence active:

 client.getEventDispatcher().on(MessageCreateEvent.class)
     .flatMap(event -> myCodeThatMightThrow(event)
             .onErrorResume(error -> {
                 // log and then discard the error to keep the sequence alive
                 log.error("Failed to handle event!", error);
                 return Mono.empty();
             }))
     .subscribe();
 

For more alternatives to handling errors, please see Error Handling docs page.

Specified by:

on in interface EventDispatcher

Type Parameters:

E - the type of the event class

Parameters:

eventClass - the event class to obtain events from

Returns:

a new Flux with the requested events

publish

public void publish(Event event)

Description copied from interface: EventDispatcher

Publishes an Event to the dispatcher. Might throw an unchecked exception if the dispatcher can't handle this event.

Specified by:

publish in interface EventDispatcher

Parameters:

event - the Event to publish

shutdown

public void shutdown()

Description copied from interface: EventDispatcher

Signal that this event dispatcher must terminate and release its resources.

Specified by:

shutdown in interface EventDispatcher