package org.djutils.event;
   
   import java.io.Serializable;
   import java.rmi.RemoteException;
   import java.util.List;
   import java.util.Set;
   
   import org.djutils.event.reference.Reference;
   import org.djutils.event.reference.ReferenceType;
  
  /**
   * The LocalEventProducer defines the registration and fireEvent operations of an event producer. This behavior includes adding
   * and removing listeners for a specific event type, and firing events for all kinds of different payloads. The EventListener
   * and EventProducer together form a combination of the Publish-Subscribe design pattern and the Observer design pattern using
   * the notify(event) method. See <a href="https://en.wikipedia.org/wiki/Publish-subscribe_pattern" target=
   * "_blank">https://en.wikipedia.org/wiki/Publish-subscribe_pattern</a>,
   * <a href="https://en.wikipedia.org/wiki/Observer_pattern" target="_blank">https://en.wikipedia.org/wiki/Observer_pattern</a>,
   * and <a href="https://howtodoinjava.com/design-patterns/behavioral/observer-design-pattern/" target=
   * "_blank">https://howtodoinjava.com/design-patterns/behavioral/observer-design-pattern/</a>.
   * <p>
   * The EventProducer forms the reference implementation of the publish side of the pub/sub design pattern. The storage of the
   * listeners is done in a Map with the EventType as the key, and a List of References (weak or strong) to the Listeners. Note
   * that the term 'Local' used in the class name is opposed to remote event producers such as the RmiEventProducer.
   * </p>
   * <p>
   * Copyright (c) 2002-2024 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved. See
   * for project information <a href="https://djutils.org" target="_blank"> https://djutils.org</a>. The DJUTILS project is
   * distributed under a three-clause BSD-style license, which can be found at
   * <a href="https://djutils.org/docs/license.html" target="_blank"> https://djutils.org/docs/license.html</a>. This class was
   * originally part of the DSOL project, see <a href="https://simulation.tudelft.nl/dsol/manual" target="_blank">
   * https://simulation.tudelft.nl/dsol/manual</a>.
   * </p>
   * @author <a href="https://www.linkedin.com/in/peterhmjacobs">Peter Jacobs </a>
   * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
   */
  public class LocalEventProducer implements EventProducer, Serializable
  {
      /** The default serial version UID for serializable classes. */
      private static final long serialVersionUID = 20200207;
  
      /** The collection of interested listeners. */
      private EventListenerMap eventListenerMap = new EventListenerMap();
  
      @Override
      public EventListenerMap getEventListenerMap()
      {
          return this.eventListenerMap;
      }
  
      /* **************************************************************************************************** */
      /* *********************** (RE) IMPLEMENTATION OF METHODS WITHOUT REMOTEEXCEPTION ********************* */
      /* **************************************************************************************************** */
  
      @Override
      public boolean addListener(final EventListener listener, final EventType eventType, final int position,
              final ReferenceType referenceType)
      {
          try
          {
              return EventProducer.super.addListener(listener, eventType, position, referenceType);
          }
          catch (RemoteException exception)
          {
              throw new RuntimeException(exception);
          }
      }
  
      @Override
      public boolean addListener(final EventListener listener, final EventType eventType)
      {
          try
          {
              return EventProducer.super.addListener(listener, eventType);
          }
          catch (RemoteException exception)
          {
              throw new RuntimeException(exception);
          }
      }
  
      @Override
      public boolean addListener(final EventListener listener, final EventType eventType, final ReferenceType referenceType)
      {
          try
          {
              return EventProducer.super.addListener(listener, eventType, referenceType);
          }
          catch (RemoteException exception)
          {
              throw new RuntimeException(exception);
  
          }
      }
  
      @Override
      public boolean addListener(final EventListener listener, final EventType eventType, final int position)
      {
          try
          {
             return EventProducer.super.addListener(listener, eventType, position);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public int removeAllListeners()
     {
         try
         {
             return EventProducer.super.removeAllListeners();
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public int removeAllListeners(final Class<?> ofClass)
     {
         try
         {
             return EventProducer.super.removeAllListeners(ofClass);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public boolean removeListener(final EventListener listener, final EventType eventType)
     {
         try
         {
             return EventProducer.super.removeListener(listener, eventType);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public boolean hasListeners()
     {
         try
         {
             return EventProducer.super.hasListeners();
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public int numberOfListeners(final EventType eventType)
     {
         try
         {
             return EventProducer.super.numberOfListeners(eventType);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public List<Reference<EventListener>> getListenerReferences(final EventType eventType)
     {
         try
         {
             return EventProducer.super.getListenerReferences(eventType);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public Set<EventType> getEventTypesWithListeners()
     {
         try
         {
             return EventProducer.super.getEventTypesWithListeners();
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public void fireEvent(final Event event)
     {
         try
         {
             EventProducer.super.fireEvent(event);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public <C extends Comparable<C> & Serializable> void fireTimedEvent(final TimedEvent<C> event)
     {
         try
         {
             EventProducer.super.fireTimedEvent(event);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public void fireEvent(final EventType eventType)
     {
         try
         {
             EventProducer.super.fireEvent(eventType);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public <C extends Comparable<C> & Serializable> void fireTimedEvent(final EventType eventType, final C time)
     {
         try
         {
             EventProducer.super.fireTimedEvent(eventType, time);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public void fireEvent(final EventType eventType, final Serializable value)
     {
         try
         {
             EventProducer.super.fireEvent(eventType, value);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public <C extends Comparable<C> & Serializable> void fireTimedEvent(final EventType eventType, final Serializable value,
             final C time)
 
     {
         try
         {
             EventProducer.super.fireTimedEvent(eventType, value, time);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public void fireUnverifiedEvent(final EventType eventType)
     {
         try
         {
             EventProducer.super.fireUnverifiedEvent(eventType);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public <C extends Comparable<C> & Serializable> void fireUnverifiedTimedEvent(final EventType eventType, final C time)
 
     {
         try
         {
             EventProducer.super.fireUnverifiedTimedEvent(eventType, time);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public void fireUnverifiedEvent(final EventType eventType, final Serializable value)
     {
         try
         {
             EventProducer.super.fireUnverifiedEvent(eventType, value);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
     @Override
     public <C extends Comparable<C> & Serializable> void fireUnverifiedTimedEvent(final EventType eventType,
             final Serializable value, final C time)
     {
         try
         {
             EventProducer.super.fireUnverifiedTimedEvent(eventType, value, time);
         }
         catch (RemoteException exception)
         {
             throw new RuntimeException(exception);
 
         }
     }
 
 }