public RAMOutputStream() 
{
    this(new RAMFile());
}

Construct an empty output buffer.

 RAMOutputStream(RAMFile f) 
{
    file = f;
    // make sure that we switch to the
    // first needed buffer lazily
    currentBufferIndex = -1;
    currentBuffer = null;
}

 public  void close() throws IOException 
{
    flush();
}

 public  void flush() throws IOException 
{
    file.setLastModified(System.currentTimeMillis());
    setFileLength();
}

 public long getFilePointer() 
{
    return currentBufferIndex <  0 ? 0 : bufferStart + bufferPosition;
}

 public long length() 
{
    return file.length;
}

 public  void reset() 
{
    try {
      seek(0);
    } catch (IOException e) {                     // should never happen
      throw new RuntimeException(e.toString());
    }
    file.setLength(0);
}

Resets this to an empty buffer.

 public  void seek(long pos) throws IOException 
{
    // set the file length in case we seek back
    // and flush() has not been called yet
    setFileLength();
    if (pos <  bufferStart || pos  >= bufferStart + bufferLength) {
      currentBufferIndex = (int) (pos / BUFFER_SIZE);
      switchCurrentBuffer();
    }
    bufferPosition = (int) (pos % BUFFER_SIZE);
}

 public long sizeInBytes() 
{
    return file.numBuffers() * BUFFER_SIZE;
}

Returns byte usage of all buffers.

 public  void writeByte(byte b) throws IOException 
{
    if (bufferPosition == bufferLength) {
      currentBufferIndex++;
      switchCurrentBuffer();
    }
    currentBuffer[bufferPosition++] = b;
}

 public  void writeBytes(byte[] b,
    int offset,
    int len) throws IOException 
{
    assert b != null;
    while (len  > 0) {
      if (bufferPosition ==  bufferLength) {
        currentBufferIndex++;
        switchCurrentBuffer();
      }
      int remainInBuffer = currentBuffer.length - bufferPosition;
      int bytesToCopy = len <  remainInBuffer ? len : remainInBuffer;
      System.arraycopy(b, offset, currentBuffer, bufferPosition, bytesToCopy);
      offset += bytesToCopy;
      len -= bytesToCopy;
      bufferPosition += bytesToCopy;
    }
}

 public  void writeTo(IndexOutput out) throws IOException 
{
    flush();
    final long end = file.length;
    long pos = 0;
    int buffer = 0;
    while (pos <  end) {
      int length = BUFFER_SIZE;
      long nextPos = pos + length;
      if (nextPos  > end) {                        // at the last buffer
        length = (int)(end - pos);
      }
      out.writeBytes(file.getBuffer(buffer++), length);
      pos = nextPos;
    }
}

Copy the current contents of this buffer to the named output.