Package org.hibernate.event.service.spi

Interface EventListenerGroup<T>

  • All Superinterfaces:
    Serializable
    public interface EventListenerGroup<T>
extends Serializable
    Contract for a groups of events listeners for a particular event type.

    • Method Detail

      • getEventType

        EventType<T> getEventType()
        Retrieve the event type associated with this groups of listeners.
        Returns:
        The event type.

      • isEmpty

        boolean isEmpty()
        Are there no listeners registered?
        Returns:
        true if no listeners are registered; false otherwise.

      • count

        int count()

      • addDuplicationStrategy

        void addDuplicationStrategy​(DuplicationStrategy strategy)
        Mechanism to more finely control the notion of duplicates.

        For example, say you are registering listeners for an extension library. This extension library could define a "marker interface" which indicates listeners related to it and register a strategy that checks against that marker interface.

        Parameters:
        strategy - The duplication strategy

      • appendListener

        void appendListener​(T listener)

      • appendListeners

        void appendListeners​(T... listeners)

      • prependListener

        void prependListener​(T listener)

      • prependListeners

        void prependListeners​(T... listeners)

      • clear

        @Deprecated
void clear()
        Deprecated.
        likely want to use clearListeners() instead, which doesn't also reset the registered DuplicationStrategy(ies).
        Clears both the list of event listeners and all DuplicationStrategy, including the default duplication strategy.

      • clearListeners

        void clearListeners()
        Removes all registered listeners

      • fireLazyEventOnEachListener

        <U> void fireLazyEventOnEachListener​(Supplier<U> eventSupplier,
                                     BiConsumer<T,​U> actionOnEvent)
        Fires an event on each registered event listener of this group. Implementation note (performance): the first argument is a supplier so that events can avoid being created when no listener is registered. the second argument is specifically designed to avoid needing a capturing lambda.
        Type Parameters:
        U - the kind of event
        Parameters:
        eventSupplier -
        actionOnEvent -

      • fireEventOnEachListener

        <U> void fireEventOnEachListener​(U event,
                                 BiConsumer<T,​U> actionOnEvent)
        Similar as fireLazyEventOnEachListener(Supplier, BiConsumer) except it doesn't use a {Supplier}: useful when there is no need to lazily initialize the event.
        Type Parameters:
        U - the kind of event
        Parameters:
        event -
        actionOnEvent -

      • fireEventOnEachListener

        <U,​X> void fireEventOnEachListener​(U event,
                                         X param,
                                         EventActionWithParameter<T,​U,​X> actionOnEvent)
        Similar to fireEventOnEachListener(Object, BiConsumer), but allows passing a third parameter to the consumer; our code based occasionally needs a third parameter: having this additional variant allows using the optimal iteration more extensively and reduce allocations.
        Type Parameters:
        U -
        X -
        Parameters:
        event -
        param -
        actionOnEvent -

      • fireEventOnEachListener

        <R,​U,​RL> CompletionStage<R> fireEventOnEachListener​(U event,
                                                                Function<RL,​Function<U,​CompletionStage<R>>> fun)
        Similar to fireEventOnEachListener(Object, Function), but Reactive friendly: it chains processing of the same event on each Reactive Listener, and returns a CompletionStage of type R. The various generic types allow using this for each concrete event type and flexible return types.

        Used by Hibernate Reactive

        Type Parameters:
        R - the return type of the returned CompletionStage
        U - the type of the event being fired on each listener
        RL - the type of ReactiveListener: each listener of type T will be casted to it.
        Parameters:
        event - The event being fired
        fun - The function combining each event listener with the event
        Returns:
        the composite completion stage of invoking fun(event) on each listener.

      • fireEventOnEachListener

        <R,​U,​RL,​X> CompletionStage<R> fireEventOnEachListener​(U event,
                                                                        X param,
                                                                        Function<RL,​BiFunction<U,​X,​CompletionStage<R>>> fun)
        Similar to fireEventOnEachListener(Object, Object, Function), but Reactive friendly: it chains processing of the same event on each Reactive Listener, and returns a CompletionStage of type R. The various generic types allow using this for each concrete event type and flexible return types.

        Used by Hibernate Reactive

        Type Parameters:
        R - the return type of the returned CompletionStage
        U - the type of the event being fired on each listener
        RL - the type of ReactiveListener: each listener of type T will be casted to it.
        X - an additional parameter to be passed to the function fun
        Parameters:
        event - The event being fired
        fun - The function combining each event listener with the event
        Returns:
        the composite completion stage of invoking fun(event) on each listener.

      • fireLazyEventOnEachListener

        <R,​U,​RL> CompletionStage<R> fireLazyEventOnEachListener​(Supplier<U> eventSupplier,
                                                                    Function<RL,​Function<U,​CompletionStage<R>>> fun)
        Similar to fireLazyEventOnEachListener(Supplier, BiConsumer), but Reactive friendly: it chains processing of the same event on each Reactive Listener, and returns a CompletionStage of type R. The various generic types allow using this for each concrete event type and flexible return types.

        This variant expects a Supplier of the event, rather than the event directly; this is useful for the event types which are commonly configured with no listeners at all, so to allow skipping creating the event; use only for event types which are known to be expensive while the listeners are commonly empty.

        Used by Hibernate Reactive

        Type Parameters:
        R - the return type of the returned CompletionStage
        U - the type of the event being fired on each listener
        RL - the type of ReactiveListener: each listener of type T will be casted to it.
        Parameters:
        eventSupplier - A supplier able to produce the actual event
        fun - The function combining each event listener with the event
        Returns:
        the composite completion stage of invoking fun(event) on each listener.