BufferedIndexOutput.java

package org.apache.lucene.store;

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.io.IOException;

/** Base implementation class for buffered {@link IndexOutput}. */
public abstract class BufferedIndexOutput extends IndexOutput {
  /** The default buffer size in bytes ({@value #DEFAULT_BUFFER_SIZE}). */
  public static final int DEFAULT_BUFFER_SIZE = 16384;

  private final int bufferSize;
  private final byte[] buffer;
  private long bufferStart = 0;           // position in file of buffer
  private int bufferPosition = 0;         // position in buffer

  /**
   * Creates a new {@link BufferedIndexOutput} with the default buffer size
   * ({@value #DEFAULT_BUFFER_SIZE} bytes see {@link #DEFAULT_BUFFER_SIZE})
   */
  public BufferedIndexOutput() {
    this(DEFAULT_BUFFER_SIZE);
  }
  
  /**
   * Creates a new {@link BufferedIndexOutput} with the given buffer size. 
   * @param bufferSize the buffer size in bytes used to buffer writes internally.
   * @throws IllegalArgumentException if the given buffer size is less or equal to <tt>0</tt>
   */
  public BufferedIndexOutput(int bufferSize) {
    if (bufferSize <= 0) {
      throw new IllegalArgumentException("bufferSize must be greater than 0 (got " + bufferSize + ")");
    }
    this.bufferSize = bufferSize;
    buffer = new byte[bufferSize];
  }

  @Override
  public void writeByte(byte b) throws IOException {
    if (bufferPosition >= bufferSize)
      flush();
    buffer[bufferPosition++] = b;
  }

  @Override
  public void writeBytes(byte[] b, int offset, int length) throws IOException {
    int bytesLeft = bufferSize - bufferPosition;
    // is there enough space in the buffer?
    if (bytesLeft >= length) {
      // we add the data to the end of the buffer
      System.arraycopy(b, offset, buffer, bufferPosition, length);
      bufferPosition += length;
      // if the buffer is full, flush it
      if (bufferSize - bufferPosition == 0)
        flush();
    } else {
      // is data larger then buffer?
      if (length > bufferSize) {
        // we flush the buffer
        if (bufferPosition > 0)
          flush();
        // and write data at once
        flushBuffer(b, offset, length);
        bufferStart += length;
      } else {
        // we fill/flush the buffer (until the input is written)
        int pos = 0; // position in the input data
        int pieceLength;
        while (pos < length) {
          pieceLength = (length - pos < bytesLeft) ? length - pos : bytesLeft;
          System.arraycopy(b, pos + offset, buffer, bufferPosition, pieceLength);
          pos += pieceLength;
          bufferPosition += pieceLength;
          // if the buffer is full, flush it
          bytesLeft = bufferSize - bufferPosition;
          if (bytesLeft == 0) {
            flush();
            bytesLeft = bufferSize;
          }
        }
      }
    }
  }

  @Override
  public void flush() throws IOException {
    flushBuffer(buffer, bufferPosition);
    bufferStart += bufferPosition;
    bufferPosition = 0;
  }

  /** Expert: implements buffer write.  Writes bytes at the current position in
   * the output.
   * @param b the bytes to write
   * @param len the number of bytes to write
   */
  private void flushBuffer(byte[] b, int len) throws IOException {
    flushBuffer(b, 0, len);
  }

  /** Expert: implements buffer write.  Writes bytes at the current position in
   * the output.
   * @param b the bytes to write
   * @param offset the offset in the byte array
   * @param len the number of bytes to write
   */
  protected abstract void flushBuffer(byte[] b, int offset, int len) throws IOException;
  
  @Override
  public void close() throws IOException {
    flush();
  }

  @Override
  public long getFilePointer() {
    return bufferStart + bufferPosition;
  }

  @Override
  public abstract long length() throws IOException;
  
  /**
   * Returns size of the used output buffer in bytes.
   * */
  public final int getBufferSize() {
    return bufferSize;
  }

}