Package discord4j.core.event

Class 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.

    • Constructor Detail

      • 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 Detail

      • 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