/**
 *  Implements a thread-safe queue.
 */

package mud.core;

import java.lang.*;
public class Queue extends java.lang.Object
{
    public Queue()
    {
        this(100,75);
    }
    
    public Queue(int initialSize, int load)
    {
        this.initialSize = initialSize;
        this.load = load;
        
        aQueue = new Object[initialSize];
        iSize = 0;
        iPointer = 0;
    }
  
 
    public synchronized void add(Object oItem)
    {
        if (load <= ((iSize * 100)/aQueue.length))
        {
            compact();
            
            if (load <= ((iSize * 100)/aQueue.length))
            {
                grow();
            }
        }
        
        iSize++;
        
        aQueue[iSize] = oItem;
    }
    
    public synchronized Object next()
    {
        Object oReturn;
        
        if (iPointer > iSize)
        {
            oReturn = null;
        }
        else
        {
            oReturn = aQueue[iPointer];
        
            iPointer++;
        }
        
        return oReturn;
    }
    
    protected synchronized void compact()
    {
        Object [] naQueue = new Object[aQueue.length];
        
        int np = 0;
        
        for (int i = iPointer; i < iSize; i++)
        {
            naQueue[np] = aQueue[i];
            np += 1;
        }
        
        aQueue = naQueue;
    }
        
        
    
    protected synchronized void grow()
    {
        Object [] naQueue = new Object[aQueue.length + initialSize];
        
        for (int i = 0; i < iSize; i++)
        {
            naQueue[i] = aQueue[i];
        }
        
        aQueue = naQueue;
    }

    public int size()
    {
        return iSize;
    }
    
    public int count()
    {
        return aQueue.length;
    }
    
    protected Object [] aQueue;
    protected int iSize;
    protected int iPointer;
    public int load = 75;
    public int initialSize = 100;
}