public BufferedIndexInput() 
{

}

 public BufferedIndexInput(int bufferSize) 
{
    checkBufferSize(bufferSize);
    this.bufferSize = bufferSize;
}

Inits BufferedIndexInput with a specific bufferSize

 public Object clone() 
{
    BufferedIndexInput clone = (BufferedIndexInput)super.clone();
    clone.buffer = null;
    clone.bufferLength = 0;
    clone.bufferPosition = 0;
    clone.bufferStart = getFilePointer();
    return clone;
}

 public int getBufferSize() 
{
    return bufferSize;
}

Returns buffer size. @see #setBufferSize

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

 protected  void newBuffer(byte[] newBuffer) 
{
    // Subclasses can do something here
    buffer = newBuffer;
}

 public byte readByte() throws IOException 
{
		  // next byte to read
    if (bufferPosition  >= bufferLength)
      refill();
    return buffer[bufferPosition++];
}

 public  void readBytes(byte[] b,
    int offset,
    int len) throws IOException 
{
    readBytes(b, offset, len, true);
}

 public  void readBytes(byte[] b,
    int offset,
    int len,
    boolean useBuffer) throws IOException 
{
    if(len < = (bufferLength-bufferPosition)){
      // the buffer contains enough data to satisfy this request
      if(len >0) // to allow b to be null if len is 0...
        System.arraycopy(buffer, bufferPosition, b, offset, len);
      bufferPosition+=len;
    } else {
      // the buffer does not have enough data. First serve all we've got.
      int available = bufferLength - bufferPosition;
      if(available  > 0){
        System.arraycopy(buffer, bufferPosition, b, offset, available);
        offset += available;
        len -= available;
        bufferPosition += available;
      }
      // and now, read the remaining 'len' bytes:
      if (useBuffer && len< bufferSize){
        // If the amount left to read is small enough, and
        // we are allowed to use our buffer, do it in the usual
        // buffered way: fill the buffer and copy from it:
        refill();
        if(bufferLength< len){
          // Throw an exception when refill() could not read len bytes:
          System.arraycopy(buffer, 0, b, offset, bufferLength);
          throw new IOException("read past EOF");
        } else {
          System.arraycopy(buffer, 0, b, offset, len);
          bufferPosition=len;
        }
      } else {
        // The amount left to read is larger than the buffer
        // or we've been asked to not use our buffer -
        // there's no performance reason not to read it all
        // at once. Note that unlike the previous code of
        // this function, there is no need to do a seek
        // here, because there's no need to reread what we
        // had in the buffer.
        long after = bufferStart+bufferPosition+len;
        if(after  > length())
          throw new IOException("read past EOF");
        readInternal(b, offset, len);
        bufferStart = after;
        bufferPosition = 0;
        bufferLength = 0;                    // trigger refill() on read
      }
    }
}

 abstract protected  void readInternal(byte[] b,
    int offset,
    int length) throws IOException
Expert: implements buffer refill. Reads bytes from the current position
in the input.

 public  void seek(long pos) throws IOException 
{
    if (pos  >= bufferStart && pos <  (bufferStart + bufferLength))
      bufferPosition = (int)(pos - bufferStart);  // seek within buffer
    else {
      bufferStart = pos;
      bufferPosition = 0;
      bufferLength = 0;				  // trigger refill() on read()
      seekInternal(pos);
    }
}

 abstract protected  void seekInternal(long pos) throws IOException
Expert: implements seek. Sets current position in this file, where the
next #readInternal(byte[],int,int)  will occur.

 public  void setBufferSize(int newSize) 
{
    assert buffer == null || bufferSize == buffer.length: "buffer=" + buffer + " bufferSize=" + bufferSize + " buffer.length=" + (buffer != null ? buffer.length : 0);
    if (newSize != bufferSize) {
      checkBufferSize(newSize);
      bufferSize = newSize;
      if (buffer != null) {
        // Resize the existing buffer and carefully save as
        // many bytes as possible starting from the current
        // bufferPosition
        byte[] newBuffer = new byte[newSize];
        final int leftInBuffer = bufferLength-bufferPosition;
        final int numToCopy;
        if (leftInBuffer  > newSize)
          numToCopy = newSize;
        else
          numToCopy = leftInBuffer;
        System.arraycopy(buffer, bufferPosition, newBuffer, 0, numToCopy);
        bufferStart += bufferPosition;
        bufferPosition = 0;
        bufferLength = numToCopy;
        newBuffer(newBuffer);
      }
    }
}

Change the buffer size used by this IndexInput