package org.opentrafficsim.core.dsol;
   
   import java.io.Serializable;
   import java.util.Collection;
   import java.util.Comparator;
   import java.util.Iterator;
   import java.util.NoSuchElementException;
   import java.util.SortedSet;
   import java.util.TreeSet;
  
  import nl.tudelft.simulation.dsol.eventlists.EventListInterface;
  import nl.tudelft.simulation.dsol.formalisms.eventscheduling.SimEventInterface;
  import nl.tudelft.simulation.dsol.simtime.SimTime;
  
  /**
   * A SynchronizedRedBlackTree implementation of the eventlistInterface. This implementation is based on Java's TreeSet.
   * <p>
   * (c) copyright 2002-2005 <a href="http://www.simulation.tudelft.nl">Delft University of Technology </a>, the Netherlands. <br>
   * See for project information <a href="http://www.simulation.tudelft.nl"> www.simulation.tudelft.nl </a> <br>
   * License of use: <a href="http://www.gnu.org/copyleft/lesser.html">Lesser General Public License (LGPL) </a>, no warranty.
   * @author <a href="https://www.linkedin.com/in/peterhmjacobs">Peter Jacobs </a>
   * @version $Revision: 1.2 $ $Date: 2010/08/10 11:36:45 $
   * @param <T> the type of simulation time, e.g. SimTimeCalendarLong or SimTimeDouble or SimTimeDoubleUnit.
   * @since 1.5
   */
  public class SynchronizedRedBlackTree<T extends SimTime<?, ?, T>> implements EventListInterface<T>, Serializable
  {
      /** The default serial version UID for serializable classes. */
      private static final long serialVersionUID = 1L;
  
      /** wrapped treeset. */
      private TreeSet<SimEventInterface<T>> tree = new TreeSet<>();
  
      /**
       * Constructs a new <code>SynchronizedRedBlackTree</code>.
       */
      public SynchronizedRedBlackTree()
      {
          super();
      }
  
      /** {@inheritDoc} */
      @Override
      @SuppressWarnings("checkstyle:designforextension")
      public SimEventInterface<T> removeFirst()
      {
          synchronized (this.tree)
          {
              SimEventInterface<T> first = this.first();
              this.remove(first);
              return first;
          }
      }
  
      /** {@inheritDoc} */
      @Override
      @SuppressWarnings("checkstyle:designforextension")
      public SimEventInterface<T> removeLast()
      {
          synchronized (this.tree)
          {
              SimEventInterface<T> last = this.last();
              this.remove(last);
              return last;
          }
      }
  
      /**
       * we re-implemented the first method. Instead of throwing exceptions if the tree is empty, we return a null value.
       * @see java.util.TreeSet#first()
       * @return the first SimEvent in the tree.
       */
      @Override
      @SuppressWarnings("checkstyle:designforextension")
      public SimEventInterface<T> first()
      {
          synchronized (this.tree)
          {
              try
              {
                  return this.tree.first();
              }
              catch (NoSuchElementException noSuchElementException)
              {
                  return null;
              }
          }
      }
  
      /**
       * we re-implemented the last method. Instead of throwing exceptions if the tree is empty, we return a null value.
       * @see java.util.TreeSet#last()
       * @return the last SimEvent in the tree.
       */
      @Override
      @SuppressWarnings("checkstyle:designforextension")
      public SimEventInterface<T> last()
      {
          synchronized (this.tree)
         {
             try
             {
                 return this.tree.last();
             }
             catch (NoSuchElementException noSuchElementException)
             {
                 return null;
             }
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public Comparator<? super SimEventInterface<T>> comparator()
     {
         synchronized (this.tree)
         {
             return this.tree.comparator();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public SortedSet<SimEventInterface<T>> subSet(final SimEventInterface<T> fromElement, final SimEventInterface<T> toElement)
     {
         synchronized (this.tree)
         {
             return this.tree.subSet(fromElement, toElement);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public SortedSet<SimEventInterface<T>> headSet(final SimEventInterface<T> toElement)
     {
         synchronized (this.tree)
         {
             return this.tree.headSet(toElement);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public SortedSet<SimEventInterface<T>> tailSet(final SimEventInterface<T> fromElement)
     {
         synchronized (this.tree)
         {
             return this.tree.tailSet(fromElement);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public int size()
     {
         synchronized (this.tree)
         {
             return this.tree.size();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isEmpty()
     {
         synchronized (this.tree)
         {
             return this.tree.isEmpty();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean contains(final Object o)
     {
         synchronized (this.tree)
         {
             return this.tree.contains(o);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public Iterator<SimEventInterface<T>> iterator()
     {
         synchronized (this.tree)
         {
             return this.tree.iterator();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public Object[] toArray()
     {
         synchronized (this.tree)
         {
             return this.tree.toArray();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public <X> X[] toArray(final X[] a)
     {
         synchronized (this.tree)
         {
             return this.tree.toArray(a);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean add(final SimEventInterface<T> e)
     {
         synchronized (this.tree)
         {
             return this.tree.add(e);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean remove(final Object o)
     {
         synchronized (this.tree)
         {
             return this.tree.remove(o);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsAll(final Collection<?> c)
     {
         synchronized (this.tree)
         {
             return this.tree.containsAll(c);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean addAll(final Collection<? extends SimEventInterface<T>> c)
     {
         synchronized (this.tree)
         {
             return this.tree.addAll(c);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean retainAll(final Collection<?> c)
     {
         synchronized (this.tree)
         {
             return this.tree.retainAll(c);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeAll(final Collection<?> c)
     {
         synchronized (this.tree)
         {
             return this.tree.removeAll(c);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void clear()
     {
         this.tree.clear();
     }
 
     /** {@inheritDoc} */
     @Override
     public String toString()
     {
         return "SynchronizedRedBlackTree [" + this.tree.size() + " events]";
     }
 
 }