public BoundedFIFO(int maxSize) 
{
                    
   if(maxSize <  1) {
      throw new IllegalArgumentException("The maxSize argument ("+maxSize+
			    ") is not a positive integer.");
    }
    this.maxSize = maxSize;
    buf = new LoggingEvent[maxSize];
}

Instantiate a new BoundedFIFO with a maximum size passed as argument.

 public LoggingEvent get() 
{
    if(numElements == 0) 
      return null;
    LoggingEvent r = buf[first];
    buf[first] = null; // help garbage collection
    if(++first == maxSize) {
	first = 0;
    }
    numElements--;    
    return r;
}

Get the first element in the buffer. Returns null if there are no elements in the buffer.

 public int getMaxSize() 
{
    return maxSize;
}

Get the maximum size of the buffer.

 public boolean isFull() 
{
    return numElements == maxSize;
}

Return true if the buffer is full, that is, whether the number of elements in the buffer equals the buffer size.

 public int length() 
{
    return numElements;
}

Get the number of elements in the buffer. This number is guaranteed to be in the range 0 to maxSize (inclusive).

 int min(int a,
    int b) 
{
    return a <  b ? a : b;
}

 public  void put(LoggingEvent o) 
{
    if(numElements != maxSize) {      
      buf[next] = o;    
      if(++next == maxSize) {
	next = 0;
      }
      numElements++;
    }
}

Place a LoggingEvent in the buffer. If the buffer is full then the event is silently dropped. It is the caller's responsability to make sure that the buffer has free space.

 public synchronized  void resize(int newSize) 
{
    if(newSize == maxSize) 
      return;
   LoggingEvent[] tmp = new LoggingEvent[newSize];
   // we should not copy beyond the buf array
   int len1 = maxSize - first;
   // we should not copy beyond the tmp array
   len1 = min(len1, newSize);
   // er.. how much do we actually need to copy?
   // We should not copy more than the actual number of elements.
   len1 = min(len1, numElements);
   // Copy from buf starting a first, to tmp, starting at position 0, len1 elements.
   System.arraycopy(buf, first, tmp, 0, len1);
   // Are there any uncopied elements and is there still space in the new array?
   int len2 = 0;
   if((len1 <  numElements) && (len1 <  newSize)) {
     len2 = numElements - len1;
     len2 = min(len2, newSize - len1);
     System.arraycopy(buf, 0, tmp, len1, len2);
   }
   this.buf = tmp;
   this.maxSize = newSize;    
   this.first=0;   
   this.numElements = len1+len2;
   this.next = this.numElements;
   if(this.next == this.maxSize) // this should never happen, but again, it just might.
     this.next = 0;
}

Resize the buffer to a new size. If the new size is smaller than the old size events might be lost.

 public boolean wasEmpty() 
{
    return numElements == 1;
}

Returns true if there is just one element in the buffer. In other words, if there were no elements before the last #put operation completed.

 public boolean wasFull() 
{
    return (numElements+1 == maxSize);
}

Returns true if the number of elements in the buffer plus 1 equals the maximum buffer size, returns false otherwise.