Source for java.io.BufferedOutputStream

   1: /* BufferedOutputStream.java -- Buffer output into large blocks before writing
   2:    Copyright (C) 1998, 2000, 2003 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package java.io;
  40: 
  41: /**
  42:   * This class accumulates bytes written in a buffer instead of immediately
  43:   * writing the data to the underlying output sink. The bytes are instead
  44:   * as one large block when the buffer is filled, or when the stream is
  45:   * closed or explicitly flushed. This mode operation can provide a more
  46:   * efficient mechanism for writing versus doing numerous small unbuffered
  47:   * writes.
  48:   *
  49:   * @author Aaron M. Renn (arenn@urbanophile.com)
  50:   */
  51: public class BufferedOutputStream extends FilterOutputStream
  52: {
  53:   /**
  54:    * This is the default buffer size
  55:    */
  56:   private static final int DEFAULT_BUFFER_SIZE = 512;
  57: 
  58:   /**
  59:    * This is the internal byte array used for buffering output before
  60:    * writing it.
  61:    */
  62:   protected byte[] buf;
  63: 
  64:   /**
  65:    * This is the number of bytes that are currently in the buffer and
  66:    * are waiting to be written to the underlying stream.  It always points to
  67:    * the index into the buffer where the next byte of data will be stored
  68:    */
  69:   protected int count;
  70: 
  71:   /**
  72:    * This method initializes a new <code>BufferedOutputStream</code> instance
  73:    * that will write to the specified subordinate <code>OutputStream</code>
  74:    * and which will use a default buffer size of 512 bytes.
  75:    *
  76:    * @param out The underlying <code>OutputStream</code> to write data to
  77:    */
  78:   public BufferedOutputStream(OutputStream out)
  79:   {
  80:     this(out, DEFAULT_BUFFER_SIZE);
  81:   }
  82: 
  83:   /**
  84:    * This method initializes a new <code>BufferedOutputStream</code> instance
  85:    * that will write to the specified subordinate <code>OutputStream</code>
  86:    * and which will use the specified buffer size
  87:    *
  88:    * @param out The underlying <code>OutputStream</code> to write data to
  89:    * @param size The size of the internal buffer
  90:    */
  91:   public BufferedOutputStream(OutputStream out, int size)
  92:   {
  93:     super(out);
  94: 
  95:     buf = new byte[size];
  96:   }
  97: 
  98:   /**
  99:    * This method causes any currently buffered bytes to be immediately
 100:    * written to the underlying output stream.
 101:    *
 102:    * @exception IOException If an error occurs
 103:    */
 104:   public synchronized void flush() throws IOException
 105:   {
 106:     if (count == 0)
 107:       return;
 108: 
 109:     out.write(buf, 0, count);
 110:     count = 0;
 111:     out.flush();
 112:   }
 113: 
 114:   /**
 115:    * This method flushes any remaining buffered bytes then closes the
 116:    * underlying output stream.  Any further attempts to write to this stream
 117:    * may throw an exception
 118:    *
 119:   public synchronized void close() throws IOException
 120:   {
 121:     flush();
 122:     out.close();
 123:   }
 124:   */
 125: 
 126:   /**
 127:    * This method runs when the object is garbage collected.  It is
 128:    * responsible for ensuring that all buffered bytes are written and
 129:    * for closing the underlying stream.
 130:    *
 131:    * @exception IOException If an error occurs (ignored by the Java runtime)
 132:    *
 133:   protected void finalize() throws IOException
 134:   {
 135:     close();
 136:   }
 137:   */
 138: 
 139:   /**
 140:    * This method writes a single byte of data.  This will be written to the
 141:    * buffer instead of the underlying data source.  However, if the buffer
 142:    * is filled as a result of this write request, it will be flushed to the
 143:    * underlying output stream.
 144:    *
 145:    * @param b The byte of data to be written, passed as an int
 146:    *
 147:    * @exception IOException If an error occurs
 148:    */
 149:   public synchronized void write(int b) throws IOException
 150:   {
 151:     if (count == buf.length)
 152:       flush();
 153: 
 154:     buf[count] = (byte)(b & 0xFF);
 155:     ++count;
 156:   }
 157: 
 158:   /**
 159:    * This method writes <code>len</code> bytes from the byte array
 160:    * <code>buf</code> starting at position <code>offset</code> in the buffer.
 161:    * These bytes will be written to the internal buffer.  However, if this
 162:    * write operation fills the buffer, the buffer will be flushed to the
 163:    * underlying output stream.
 164:    *
 165:    * @param buf The array of bytes to write.
 166:    * @param offset The index into the byte array to start writing from.
 167:    * @param len The number of bytes to write.
 168:    *
 169:    * @exception IOException If an error occurs
 170:    */
 171:   public synchronized void write(byte[] buf, int offset, int len)
 172:     throws IOException
 173:   {
 174:     // Buffer can hold everything.  Note that the case where LEN < 0
 175:     // is automatically handled by the downstream write.
 176:     if (len < (this.buf.length - count))
 177:       {
 178:         System.arraycopy(buf, offset, this.buf, count, len);
 179:         count += len;
 180:       }
 181:     else
 182:       {
 183:         // The write was too big.  So flush the buffer and write the new
 184:         // bytes directly to the underlying stream, per the JDK 1.2
 185:         // docs.
 186:         flush();
 187:         out.write (buf, offset, len);
 188:       }
 189:   }
 190: 
 191: } // class BufferedOutputStream