FileDocCategorySizeDatePackage
BoundedFIFO.javaAPI DocApache log4j 1.2.154763Sat Aug 25 00:09:40 BST 2007org.apache.log4j.helpers

BoundedFIFO

public class BoundedFIFO extends Object
BoundedFIFO serves as the bounded first-in-first-out buffer heavily used by the {@link org.apache.log4j.AsyncAppender}.
author
Ceki Gülcü
since
version 0.9.1

Fields Summary
LoggingEvent[]
buf
int
numElements
int
first
int
next
int
maxSize
Constructors Summary
public BoundedFIFO(int maxSize)
Instantiate a new BoundedFIFO with a maximum size passed as argument.


                    
  
    
   if(maxSize < 1) {
      throw new IllegalArgumentException("The maxSize argument ("+maxSize+
			    ") is not a positive integer.");
    }
    this.maxSize = maxSize;
    buf = new LoggingEvent[maxSize];
Methods Summary
public org.apache.log4j.spi.LoggingEventget()
Get the first element in the buffer. Returns null if there are no elements in the buffer.

    if(numElements == 0) 
      return null;
    
    LoggingEvent r = buf[first];
    buf[first] = null; // help garbage collection

    if(++first == maxSize) {
	first = 0;
    }
    numElements--;    
    return r;
public intgetMaxSize()
Get the maximum size of the buffer.

    return maxSize;
public booleanisFull()
Return true if the buffer is full, that is, whether the number of elements in the buffer equals the buffer size.

    return numElements == maxSize;
public intlength()
Get the number of elements in the buffer. This number is guaranteed to be in the range 0 to maxSize (inclusive).

    return numElements;
intmin(int a, int b)

    return a < b ? a : b;
public voidput(org.apache.log4j.spi.LoggingEvent o)
Place a {@link 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.

    if(numElements != maxSize) {      
      buf[next] = o;    
      if(++next == maxSize) {
	next = 0;
      }
      numElements++;
    }
public synchronized voidresize(int newSize)
Resize the buffer to a new size. If the new size is smaller than the old size events might be lost.

since
1.1

    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;
public booleanwasEmpty()
Returns true if there is just one element in the buffer. In other words, if there were no elements before the last {@link #put} operation completed.

    return numElements == 1;
public booleanwasFull()
Returns true if the number of elements in the buffer plus 1 equals the maximum buffer size, returns false otherwise.

    return (numElements+1 == maxSize);