/*
    * Copyright 2010 Fraunhofer Gesellschaft, Munich, Germany,
    * for its Fraunhofer Institute for Computer Architecture and Software
    * Technology (FIRST), Berlin, Germany. All rights reserved.
    * http://www.first.fraunhofer.de/
    */
   
   package net.kwfgrid.gwes.util;
   
  import org.apache.log4j.Logger;
  
  /**
   * Code modified from Data Structures & Problem Solving Using Java
   * by Mark Allen Weiss, 1998.
   *
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: Queue.java 1433 2010-11-29 18:06:07Z hoheisel $
   */
  public class Queue {
  
      /**
       * log4j logger.
       */
      static final Logger logger = Logger.getLogger(Queue.class);
  
      private Object[] theArray;
      private int currentSize;
      private int front;
      private int back;
      final public Object enqueueSync;
      final public Object isEmptySync;
      private static final int TIMEOUT = 10000;
  
      static final int DEFAULT_CAPACITY = 16;
  
      /**
       * Construct the queue.
       */
      public Queue() {
          enqueueSync = new Object();
          isEmptySync = new Object();
          theArray = new Object[DEFAULT_CAPACITY];
          makeEmpty();
      }
  
      /**
       * Test if the queue is logically empty.
       * @return true if empty, false otherwise.
       */
      public boolean isEmpty() {
          return currentSize == 0;
      }
  
      /**
       * Get the least recently inserted item in the queue.
       * Does not alter the queue.
       * @return the least recently inserted item in the queue.
       */
      public Object getFront() {
          if (isEmpty())
              return null;
          return theArray[front];
      }
  
      /**
       * Return and remove the least recently inserted item
       * from the queue.
       * @return the least recently inserted item in the queue.
       */
      public synchronized Object dequeue() {
          if (isEmpty())
              return null;
          currentSize--;
  
          Object returnValue = theArray[front];
          theArray[front] = null;
          front = increment(front);
          if(currentSize == 0) {
              synchronized(isEmptySync) {
                  isEmptySync.notifyAll();
              }
          }
          return returnValue;
      }
  
      /**
       * Insert a new item into the queue.
       * @param x the item to insert.
       */
      public synchronized void enqueue(Object x) {
          if (currentSize == theArray.length)
              doubleQueue();
          back = increment(back);
          theArray[back] = x;
          currentSize++;
          synchronized(enqueueSync) {
              enqueueSync.notify();
          }
     }
 
     /**
      * Make the queue logically empty.
      */
     public void makeEmpty() {
         currentSize = 0;
         front = 0;
         back = -1;
     }
 
     /**
      * Internal method to expand theArray.
      */
     private void doubleQueue() {
         Object[] newArray;
 
         newArray = new Object[theArray.length * 2];
 
         // Copy elements that are logically in the queue
         for (int i = 0; i < currentSize; i++, front = increment(front))
             newArray[i] = theArray[front];
 
         theArray = newArray;
         front = 0;
         back = currentSize - 1;
     }
 
     /**
      * Internal method to increment with wraparound.
      * @param x any index in theArray's range.
      * @return x+1, or 0 if x is at the end of theArray.
      */
     private int increment(int x) {
         if (++x == theArray.length)
             x = 0;
         return x;
     }
 
     /**
      * Get the current size of the queue
      */
     public int getCurrentSize() {
         return currentSize;
     }
 
     /**
      * Wait for queue to be empty
      */
     public void waitUntilEmpty()
             throws InterruptedException {
         logger.debug("waitUntilEmpty() ...");
         synchronized(isEmptySync) {
             while(!isEmpty()) isEmptySync.wait(TIMEOUT);
         }
         logger.debug("waitUntilEmpty() ... done");
     }
 
     /**
      * Wait for queue to be filled
      */
     public void waitForEnqueue()
             throws InterruptedException {
         logger.debug("waitForEnqueue() ...");
         synchronized(enqueueSync) {
             while(isEmpty()) enqueueSync.wait(TIMEOUT);
         }
         logger.debug("waitForEnqueue() ... done");
     }
 
 }