/**********************************************************************
    * ChannelOutputStream.java
    * created on 16.08.2004 by netseeker
    * $Source: /cvsroot/ejoe/EJOE/src/de/netseeker/ejoe/io/ByteBufferOutputStream.java,v $
    * $Date: 2007/11/17 10:57:03 $
    * $Revision: 1.19 $
    *
    * ====================================================================
    *
   *  Copyright 2005-2006 netseeker aka Michael Manske
   *
   *  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.
   * ====================================================================
   *
   * This file is part of the ejoe framework.
   * For more information on the author, please see
   * <http://www.manskes.de/>.
   *
   *********************************************************************/
  
  package de.netseeker.ejoe.io;
  
  import java.io.IOException;
  import java.io.OutputStream;
  import java.nio.ByteBuffer;
  
  import de.netseeker.ejoe.EJConstants;
  import de.netseeker.ejoe.cache.ByteBufferAllocator;
  
  /***
   * Implements an input stream for a NIO ByteBuffer. This class is based on an article found at the homepage of Michael
   * W. Spille.
   * 
   * @author Michael W. Spille
   * @author netseeker aka Michael Manske
   * @link http://www.krisnmike.com/mike/nio.html
   * @since 0.3.0
   */
  public class ByteBufferOutputStream extends OutputStream
  {
      private ByteBuffer buffer;
  
      private boolean    _closed = false;
  
      /***
       * 
       */
      public ByteBufferOutputStream()
      {
          this( EJConstants.NIO_BYTEBUFFER_STREAM_SIZE );
      }
  
      /***
       * @param startingSize
       */
      public ByteBufferOutputStream(int startingSize)
      {
          buffer = ByteBufferAllocator.allocate( startingSize, true );
      }
  
      /***
       * @param buffer
       */
      public ByteBufferOutputStream(ByteBuffer buffer)
      {
          this.buffer = buffer;
      }
  
      /***
       * Reset the underlying byte buffer back to the starting state
       */
      public void reset()
      {
          if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
          buffer.clear();
      }
  
      /***
       * @return
       */
      public ByteBuffer getBackingBuffer()
      {
          if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
          return (buffer);
      }
  
      /*
       * (non-Javadoc)
       * 
      * @see java.io.OutputStream#write(int)
      */
     public void write( int b ) throws IOException
     {
         if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
         if ( !buffer.hasRemaining() )
         {
             realloc( buffer.limit() + EJConstants.NIO_BYTEBUFFER_STREAM_SIZE );
         }
         buffer.put( (byte) b );
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.io.OutputStream#write(byte[])
      */
     public void write( byte[] b ) throws IOException
     {
         if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
         if ( buffer.remaining() < b.length )
         {
             realloc( buffer.limit() + (b.length - buffer.remaining()) + EJConstants.NIO_BYTEBUFFER_STREAM_SIZE );
         }
         buffer.put( b );
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.io.OutputStream#write(byte[], int, int)
      */
     public void write( byte[] b, int off, int len )
     {
         if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
         if ( buffer.remaining() < len )
         {
             realloc( buffer.limit() + (len - buffer.remaining()) + EJConstants.NIO_BYTEBUFFER_STREAM_SIZE );
         }
         buffer.put( b, off, len );
     }
 
     /***
      * @param b
      */
     public void write( ByteBuffer b )
     {
         if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
         if ( buffer.remaining() < b.remaining() )
         {
             realloc( buffer.limit() + (b.remaining() - buffer.remaining()) + EJConstants.NIO_BYTEBUFFER_STREAM_SIZE );
         }
         buffer.put( b );
     }
 
     public void putInt( int i )
     {
         if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
         if ( buffer.remaining() < 4 )
         {
             realloc( buffer.limit() + (4 - buffer.remaining()) + EJConstants.NIO_BYTEBUFFER_STREAM_SIZE );
         }
 
         buffer.putInt( i );
     }
 
     private void realloc( int newSize )
     {
         ByteBuffer newOutBytes = ByteBufferAllocator.allocate( newSize, true );
         //newOutBytes.clear();
         buffer.flip();
         newOutBytes.put( buffer );
         buffer = newOutBytes;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.io.OutputStream#flush()
      */
     public void flush()
     {
         if ( _closed ) throw new IllegalStateException( "This stream was already closed!" );
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.io.OutputStream#close()
      */
     public void close() throws IOException
     {
         _closed = true;
     }
 }