/*
    * Queue.java
    *
    * Created on den 16 september 2002, 11:31
    */
   
   package net.sourceforge.jsh3modtool.gui.imagetable.cache;
   
   import java.util.*;
  
  /*** 
   * Active queue that threads can listen on item addition and/or removal of items.
   * @author erma
   */
  public class Queue
  {
      private Object additionEvent = new Object();
      
      private Object removalEvent = new Object();
          
      protected Vector listeners = new Vector();
      
      protected int numberOfAvailablePlaces;
      protected Vector queueItems;
      
      /*** Creates a new instance of Queue */
      public Queue(  )
      {
          this( -1 );
      }
      
      /*** Creates a new instance of Queue
       * @param numberOfPlaces Maximum capacity
       */
      public Queue( int numberOfPlaces )
      {
          super( );
          numberOfAvailablePlaces = numberOfPlaces;
          if ( numberOfAvailablePlaces == -1 )
              queueItems = new Vector();
          else
              queueItems = new Vector( numberOfAvailablePlaces );
      }
      
      /***
       * Waits until there is an object in the queue
       * @return false if this wait() (thread) was interrupted; true otherwise
       */
      public boolean waitForFirstObject()
      {
          return waitForFirstObject(0);
      }
      
      /***
       * Waits until there is an object in the queue for the specified timeout time 
       * @param timeout the maximum time to wait in milliseconds.
       * @return false if this wait() (thread) was interrupted; true otherwise
       */
      public boolean waitForFirstObject( long timeout )
      {
          if ( size() > 0 )
              return true;
          
          synchronized( additionEvent )
          {            
              try
              {
                  additionEvent.wait( timeout );
                  return true;
              } catch ( InterruptedException ie )
              {
                  return false;
              }
          }
      }
      
      /***
       * Waits until there is an available place in the queue.
       * This method behaves exactly as if it simply performs the call waitForEmptySpace(0)
       * @return false if this wait() (thread) was interrupted; true otherwise
       */
      public boolean waitForEmptySpace()
      {
          return waitForEmptySpace(0);
      }
      
      /***
       * Waits until there is an available place in the queue for the specified timeout time 
       * @param timeout the maximum time to wait in milliseconds.
       * @return false if this wait() (thread) was interrupted; true otherwise
       */
      public boolean waitForEmptySpace(long timeout)
      {
          if ( numberOfAvailablePlaces == -1 )
              return true;
          
          if ( size() < numberOfAvailablePlaces )
              return true;
          
         synchronized( removalEvent )
         {
             try
             {
                 removalEvent.wait(timeout);
                 return true;
             } catch ( InterruptedException ie )
             {
                 return false;
             }
         }
     }
     
     
     /***
      * Waits until the queue is empty for the specified timeout time 
      * This method behaves exactly as if it simply performs the call waitForEmptyQueue(0)
      * @return false if this wait() (thread) was interrupted; true otherwise
      */
     public boolean waitForEmptyQueue()
     {
         return waitForEmptyQueue(0);
     }    
     
     /***
      * Waits until the queue is empty for the specified timeout time 
      * @param timeout the maximum time to wait in milliseconds.
      * @return false if this wait() (thread) was interrupted; true otherwise
      */
     public boolean waitForEmptyQueue( long timeout )
     {
         if ( ( size() == 0 ) || ( timeout < 0 ) )
             return true;
      
         long startTime = System.currentTimeMillis();
         
         synchronized( removalEvent )
         {
             try
             {
                 removalEvent.wait(timeout);
             } catch ( InterruptedException ie )
             {
                 return false;
             }
         }
         
         long stopTime = System.currentTimeMillis();
 
         // either I timoutted or there was an event, anyhow check if I should continue waiting
         if ( size() == 0 )
             return true;
         
         // There are still items in the queue, and if timeout was 0 (wait indefintely)
         if ( timeout == 0 )
             return waitForEmptyQueue( 0 );
         
         // Check if the timeout has expired
         if (  stopTime > ( timeout + startTime ) )
             return true;
 
         // Just wait some more time
         return waitForEmptyQueue( timeout - ( stopTime - startTime ) );
     }
     
     /***
      * Fire event that there is a new item in the queue
      */
     protected void fireAdditionEvent()
     {
         synchronized( additionEvent )
         {
             additionEvent.notify();
         }
     }    
     
     /***
      * Fire event that there is one less item in the queue
      */
     protected void fireRemovalEvent()
     {
         synchronized( removalEvent )
         {
             removalEvent.notify();
         }
     }
     
     /***
      * Adds the specified item to the queue.
      * @param item the item to add
      * @return true if it was sucessfully added; false if there was no place.
      */
     public boolean add( QueueItem item )
     {
         return addLast( item );
     } 
     
     /***
      * Adds the specified item to the end of the queue.
      * @param item the item to add
      * @return true if it was sucessfully added; false if there was no place.
      */
     public boolean addLast( QueueItem item )
     {   
         return add( item, queueItems.size() );
     }
     
     /***
      * Adds the specified item to the end of the queue.
      * @param item the item to add
      * @return true if it was sucessfully added; false if there was no place.
      */
     public boolean addFirst( QueueItem item )
     {      
         return add( item, 0 );
     }
     
     protected boolean add( QueueItem item, int index )
     {
         if ( item == null )
             return false;
         
         if ( ( numberOfAvailablePlaces != -1 ) && ( size() >= numberOfAvailablePlaces ) )
         {
             return false;
         }
         else
         {
             queueItems.add( index, item );
             fireItemAdded( item );
             fireAdditionEvent();
             return true;
         }  
     }
     
     /***
      * Removes all items in the queue
      */
     public void removeAll()
     {
         Enumeration items = queueItems.elements();
         while ( items.hasMoreElements() )
         {
             fireItemRemoved( (QueueItem) items.nextElement() );
         }
         queueItems.removeAllElements();
         fireRemovalEvent();
     }
     
     /***
      * Remove the item at the specified index and return it.
      * @param index the item index to remove
      * @return the removed item
      */
     protected QueueItem remove( int index )
     {
         if ( ( index < queueItems.size() ) && ( index >= 0 ) )
         {
             QueueItem item = (QueueItem) queueItems.remove( index );
             fireItemRemoved( item );
             fireRemovalEvent();
             return item;
         } 
         else
         {
             return null;
         }
     }
     
     /***
      * Removes the queueitem from the queue
      * @param item the item to remove from the queue
      * @return the removed item; null if there wasnt such item in the queue
      */
     public QueueItem remove( QueueItem item )
     {
         if ( queueItems.size() > 0 )
         {
             int pos = queueItems.indexOf( item );
             
             if ( pos != -1 )
             {
                 return remove( pos );
             } 
             else
             {
                 return null;
             }
         } 
         else
         {
             return null;
         }
     }
     
     /***
      * Removes the first item and returns it.
      * @return the removed item; null if there was no items in the queue
      */
     public QueueItem removeFirst()
     {
         return remove( 0 );
     }
     
     /***
      * Removes the last item and returns it.
      * @return the removed item; null if there was no items in the queue
      */
     public QueueItem removeLast()
     {
         return remove( size() - 1 );
     }
     
     /***
      * Returns the first item in the queue
      * @return the first item; null if the queue was empty
      */
     public QueueItem getFirst()
     {
         if ( queueItems.size() == 0 )
             return null;
         else
             return (QueueItem) queueItems.firstElement();
     }
     
     /***
      * Returns the last item in the queue
      * @return the last item; null if the queue was empty
      */
     public QueueItem getLast()
     {
         if ( queueItems.size() == 0 )
             return null;
         else
             return (QueueItem) queueItems.lastElement();
     }
     
     /*** Returns the size of the queue
      * @return the size of the queue
      */
     public int size()
     {
         return queueItems.size();
     }
     
     /*** Returns if the queue is empty.
      * @return if the queue is empty.
      */
     public boolean isEmpty()
     {
         return ( size() == 0 ? true : false );
     }
     
     /***
      * Add a QueueListener to this object
      * @param listener the listener
      */
     public void addListener( QueueListener listener )
     {
         listeners.add( listener );
     }
     
     /***
      * Remove a QueueListener from this object
      * @param listener the listener
      */
     public void removeListener( QueueListener listener )
     {
         listeners.remove( listener );
     }
     
     /***
      * Notify all listeners that an item has been added
      * @param item the item
      */
     protected void fireItemAdded( QueueItem item )
     {
         Enumeration elements = listeners.elements();
         while ( elements.hasMoreElements() )
         {
             ( ( QueueListener ) elements.nextElement() ).queueItemAdded( this, item );
         }   
     }
     
     /***
      * Notify all listeners that an item has been removed
      * @param item the item
      */
     protected void fireItemRemoved( QueueItem item )
     {
         Enumeration elements = listeners.elements();
         while ( elements.hasMoreElements() )
         {
             ( ( QueueListener ) elements.nextElement() ).queueItemRemoved( this, item );
         }   
     }
 }