package net.sf.logdistiller.util;
   
   /*
    * Licensed 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;
  import java.io.Reader;
  
  /**
   * A reader reading its content from another reader, but buffering the data to be able to give it back on demand. When
   * data is given back, it is not maintained in memory any more. When using this class, take care to get data regularly,
   * or all the data read will stay in memory, risking OutOfMemoryException !
   *
   * @see #freeData
   */
  public class BufferingReader
      extends Reader
  {
      private int bufferBlockSize;
  
      private char[] buffer;
  
      private int begin = 0;
  
      private int end = 0;
  
      private final Reader reader;
  
      public BufferingReader( Reader reader, int bufferBlockSize )
      {
          this.reader = reader;
          this.bufferBlockSize = bufferBlockSize;
          buffer = new char[bufferBlockSize];
      }
  
      public BufferingReader( Reader reader )
      {
          this( reader, 16384 );
      }
  
      public boolean ready()
          throws IOException
      {
          return reader.ready();
      }
  
      public void close()
          throws IOException
      {
          reader.close();
      }
  
      public int read( char[] cbuf, int off, int len )
          throws IOException
      {
          int count = reader.read( cbuf, off, len );
          if ( count > 0 )
          {
              if ( end + count >= buffer.length )
              {
                  prepareBuffer( count + ( end - begin ) );
              }
              System.arraycopy( cbuf, off, buffer, end, count );
              end += count;
          }
          return count;
      }
  
      /**
       * Get the length of data available in the buffer.
       *
       * @return available data length
       */
      public int getDataLength()
      {
          return ( end - begin );
      }
  
      /**
       * Get some data that have been buffered, and free corresponding space in the buffer.
       *
       * @param count the number of characters to get
       * @return the corresponding data
       * @throws IndexOutOfBoundsException if the amount of data asked is more than what is available in the buffer
       * @see #getDataLength()
       */
      public String freeData( int count )
      {
         if ( count > getDataLength() )
         {
             throw new IndexOutOfBoundsException( "asked for " + count + " chars, but buffer contains only "
                 + getDataLength() + " chars." );
         }
         String data = new String( buffer, begin, count );
         begin += count;
         return data;
     }
 
     /**
      * Get the size of the buffer.
      *
      * @return the buffer size
      */
     public int getBufferSize()
     {
         return buffer.length;
     }
 
     /**
      * Shrink the buffer to its minimal size to store actual data. In normal use, the buffer grows as needed but never
      * shrinks.
      */
     public void shrinkBuffer()
     {
         int size = calculateBufferSize( end - begin );
         if ( size < buffer.length )
         {
             char[] oldBuffer = buffer;
             buffer = new char[size];
             end -= begin;
             System.arraycopy( oldBuffer, begin, buffer, 0, end );
             begin = 0;
         }
     }
 
     /**
      * prepare the internal buffer to insert some data. Existing data in the buffer are moved to the beginning of the
      * buffer (so that begin = 0), and a new buffer is reallocated if its length was not sufficient.
      *
      * @param size the minimal size of the buffer
      */
     private void prepareBuffer( int size )
     {
         char[] oldBuffer = buffer;
         if ( size > buffer.length )
         {
             // buffer is not big enough: must enlarge (to a multiple of bufferBlockSize)
             buffer = new char[calculateBufferSize( size )];
         }
         end -= begin;
         System.arraycopy( oldBuffer, begin, buffer, 0, end );
         begin = 0;
     }
 
     private int calculateBufferSize( int size )
     {
         return bufferBlockSize * ( size / bufferBlockSize + 1 );
     }
 }