StatisticsEventProvider (jeve 3.0.0 API)

java.lang.Object
- de.skuzzle.jeve.providers.StatisticsEventProvider<S,P>

Type Parameters:

S - The type of the ListenerStore this provider uses.

P - The type of the wrapped provider.

All Implemented Interfaces:

EventProvider<S>
```
public class StatisticsEventProvider<S extends ListenerStore,P extends EventProvider<S>>
extends Object
implements EventProvider<S>
```
EventProvider which delegates all method calls to a wrapped instance and counts all dispatch actions.

Since:

2.0.0

Author:

Simon Taddiken

Constructor Summary

Constructors
Constructor and Description

StatisticsEventProvider(P wrapped)
Creates a new StatisticsEventProvider which counts dispatch action of the given EventProvider.

Constructors
Constructor and Description
`StatisticsEventProvider(P wrapped)` Creates a new StatisticsEventProvider which counts dispatch action of the given `EventProvider`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`canDispatch()` Gets whether this EventProvider is ready for dispatching.
`void`	`close()` Closes this EventProvider and its `ListenerStore` (thus, removes all registered Listeners from the store).
`void`	`dispatch(DefaultDispatchable event)` Dispatches the given event by calling its `DefaultDispatchable.defaultDispatch(EventProvider, ExceptionCallback)` method, passing `this` as first argument and the currently set ExceptionCallback as second argument.
`<L extends Listener,E extends Event<?,L>> void`	`dispatch(E event, BiConsumer<L,E> bc)` Notifies all listeners of a certain kind about an occurred event.
`<L extends Listener,E extends Event<?,L>> void`	`dispatch(E event, BiConsumer<L,E> bc, ExceptionCallback ec)` Notifies all listeners of a certain kind about an occurred event with explicit error handling.
`Map<Class<? extends Listener>,Integer>`	`getNotificationStatistics()` Gets a map containing statistics about how often a certain kind of listener has been notified.
`P`	`getWrapped()` Gets the underlying EventProvider which is wrapped by this StatisticsEventProvider.
`boolean`	`isSequential()` Returns whether this EventProvider is sequential, which means it strictly notifies listeners in the order in which they were registered for a certain event.
`S`	`listeners()` Retrieves the `ListenerStore` which supplies `Listeners` to this EventProvider.
`void`	`setExceptionCallback(ExceptionCallback ec)` Sets the default `ExceptionCallback` which will be notified about exceptions when dispatching events without explicitly specifying an ExceptionCallback.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface de.skuzzle.jeve.EventProvider
configure, createDefault, dispatch, dispatch, dispatch

- Constructor Detail
  - StatisticsEventProvider
```
public StatisticsEventProvider(P wrapped)
```
    Creates a new StatisticsEventProvider which counts dispatch action of the given EventProvider.
    
    Parameters:
    
    wrapped - The provider to wrap.
- Method Detail
  - getWrapped
```
public P getWrapped()
```
    Gets the underlying EventProvider which is wrapped by this StatisticsEventProvider.
    
    Returns:
    
    The wrapped provider.
  - getNotificationStatistics
```
public Map<Class<? extends Listener>,Integer> getNotificationStatistics()
```
    Gets a map containing statistics about how often a certain kind of listener has been notified. The returned map is read only and backed by the internal map. Thus, once retrieved the map, its contents may change over time.
    
    Returns:
    
    A read only map view of the current notification statistics.
  - dispatch
```
public <L extends Listener,E extends Event<?,L>> void dispatch(E event,
                                                               BiConsumer<L,E> bc)
```
    Description copied from interface: EventProvider
    Notifies all listeners of a certain kind about an occurred event. If this provider is not ready for dispatching as determined by EventProvider.canDispatch(), this method returns immediately without doing anything. This method will stop notifying further listeners if the passed event has been marked 'handled' using Event.setHandled(boolean).
    Consider an UserListener interface:
```
 public interface UserListener extends Listener {
     public void userAdded(UserEvent e);

     public void userDeleted(UserEvent e);
 }
 
```
    Notifying all registered UserListeners about an added user is as easy as calling
```
 eventProvider.dispatchEvent(event, UserListener::userAdded)
 
```
    This method uses the global ExceptionCallback provided to EventProvider.setExceptionCallback(ExceptionCallback) or an default instance if none has been explicitly set.
    
    Note on concurrency: This method operates on a copy of the list of targeted listeners. This allows you to add/remove listeners from within a listening method.
    
    Please note that neither parameter to this method must be null.
    Specified by:
    
    dispatch in interface EventProvider<S extends ListenerStore>
    
    Type Parameters:
    
    L - Type of the listeners which will be notified.
    
    E - Type of the event which will be passed to a listener.
    
    Parameters:
    
    event - The occurred event which shall be passed to each listener.
    
    bc - Function to delegate the event to the specific callback method of the listener.
  - dispatch
```
public <L extends Listener,E extends Event<?,L>> void dispatch(E event,
                                                               BiConsumer<L,E> bc,
                                                               ExceptionCallback ec)
```
    Description copied from interface: EventProvider
    Notifies all listeners of a certain kind about an occurred event with explicit error handling. If this provider is not ready for dispatching as determined by EventProvider.canDispatch(), this method returns immediately without doing anything. This method will stop notifying further listeners if the passed event has been marked 'handled' using Event.setHandled(boolean).
    Consider an UserListener interface:
```
 public interface UserListener extends Listener {
     public void userAdded(UserEvent e);

     public void userDeleted(UserEvent e);
 }
 
```
    Notifying all registered UserListeners about an added user is as easy as calling
```
 final ExceptionCallback callBack = new EceptionCallback() { ... };
 eventProvider.dispatchEvent(event, UserListener::userAdded, callBack);
 
```
    The ExceptionCallback gets notified when any of the listeners throws an unexpected exception. If the exception handler itself throws an exception, it will be ignored. The callback provided to this method takes precedence over the global callback provided by EventProvider.setExceptionCallback(ExceptionCallback).
    
    Note on concurrency: This method operates on a copy of the list of targeted listeners. This allows you to add/remove listeners from within a listening method.
    
    Please note that neither parameter to this method must be null.
    Specified by:
    
    dispatch in interface EventProvider<S extends ListenerStore>
    
    Type Parameters:
    
    L - Type of the listeners which will be notified.
    
    E - Type of the event which will be passed to a listener.
    
    Parameters:
    
    event - The occurred event which shall be passed to each listener.
    
    bc - Function to delegate the event to the specific callback method of the listener.
    
    ec - Callback to be notified when any of the listeners throws an exception.
  - dispatch
```
public void dispatch(DefaultDispatchable event)
```
    Description copied from interface: EventProvider
    
    Dispatches the given event by calling its DefaultDispatchable.defaultDispatch(EventProvider, ExceptionCallback) method, passing this as first argument and the currently set ExceptionCallback as second argument. The defaultDispatch method will in return call EventProvider.dispatch(Event, BiConsumer, ExceptionCallback) on this provider.
    
    Specified by:
    
    dispatch in interface EventProvider<S extends ListenerStore>
    
    Parameters:
    
    event - The event to dispatch using its default dispatch method.
    
    See Also:
    
    DefaultDispatchable
  - close
```
public void close()
```
    Description copied from interface: EventProvider
    
    Closes this EventProvider and its ListenerStore (thus, removes all registered Listeners from the store). Depending on the actual implementation, the EventProvider might not be able to dispatch further events after closing. On some implementations closing might have no additional effect.
    
    Specified by:
    
    close in interface EventProvider<S extends ListenerStore>
  - listeners
```
public S listeners()
```
    Description copied from interface: EventProvider
    
    Retrieves the ListenerStore which supplies Listeners to this EventProvider.
    
    Specified by:
    
    listeners in interface EventProvider<S extends ListenerStore>
    
    Returns:
    
    The listener store.
  - canDispatch
```
public boolean canDispatch()
```
    Description copied from interface: EventProvider
    
    Gets whether this EventProvider is ready for dispatching.
    
    Specified by:
    
    canDispatch in interface EventProvider<S extends ListenerStore>
    
    Returns:
    
    Whether further events can be dispatched using dispatch
  - setExceptionCallback
```
public void setExceptionCallback(ExceptionCallback ec)
```
    Description copied from interface: EventProvider
    
    Sets the default ExceptionCallback which will be notified about exceptions when dispatching events without explicitly specifying an ExceptionCallback. The ExceptionCallback which is installed by default simply prints the stack traces to the error console.
    You can reset the ExceptionCallback to the default handler by providing null as parameter.
    
    Specified by:
    
    setExceptionCallback in interface EventProvider<S extends ListenerStore>
    
    Parameters:
    
    ec - The ExceptionCallback for handling event handler exceptions, or null to use the default behavior.
  - isSequential
```
public boolean isSequential()
```
    Description copied from interface: EventProvider
    
    Returns whether this EventProvider is sequential, which means it strictly notifies listeners in the order in which they were registered for a certain event.
    Note: Implementors must obey the result of the isSequential property of the currently used ListenerStore. If the store is not sequential, this provider won't be either.
    
    Specified by:
    
    isSequential in interface EventProvider<S extends ListenerStore>
    
    Returns:
    
    Whether this instance is sequential.

Class StatisticsEventProvider<S extends ListenerStore,P extends EventProvider<S>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface de.skuzzle.jeve.EventProvider

Constructor Detail

StatisticsEventProvider

Method Detail

getWrapped

getNotificationStatistics

dispatch

dispatch

dispatch

close

listeners

canDispatch

setExceptionCallback

isSequential