1 files changed, 192 insertions, 0 deletions
diff --git a/libjava/classpath/java/io/BufferedOutputStream.java b/libjava/classpath/java/io/BufferedOutputStream.java
new file mode 100644
index 0000000..ce7ebc7
--- /dev/null
+++ b/libjava/classpath/java/io/BufferedOutputStream.java
@@ -0,0 +1,192 @@
+/* BufferedOutputStream.java -- Buffer output into large blocks before writing
+   Copyright (C) 1998, 2000, 2003 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.io;
+
+/**
+  * This class accumulates bytes written in a buffer instead of immediately
+  * writing the data to the underlying output sink. The bytes are instead
+  * as one large block when the buffer is filled, or when the stream is
+  * closed or explicitly flushed. This mode operation can provide a more
+  * efficient mechanism for writing versus doing numerous small unbuffered
+  * writes.
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  */
+public class BufferedOutputStream extends FilterOutputStream
+{
+  /**
+   * This is the default buffer size
+   */
+  private static final int DEFAULT_BUFFER_SIZE = 512;
+
+  /**
+   * This is the internal byte array used for buffering output before
+   * writing it.
+   */
+  protected byte[] buf;
+
+  /**
+   * This is the number of bytes that are currently in the buffer and
+   * are waiting to be written to the underlying stream.  It always points to
+   * the index into the buffer where the next byte of data will be stored
+   */
+  protected int count;
+
+  /**
+   * This method initializes a new <code>BufferedOutputStream</code> instance
+   * that will write to the specified subordinate <code>OutputStream</code>
+   * and which will use a default buffer size of 512 bytes.
+   *
+   * @param out The underlying <code>OutputStream</code> to write data to
+   */
+  public BufferedOutputStream(OutputStream out)
+  {
+    this(out, DEFAULT_BUFFER_SIZE);
+  }
+
+  /**
+   * This method initializes a new <code>BufferedOutputStream</code> instance
+   * that will write to the specified subordinate <code>OutputStream</code>
+   * and which will use the specified buffer size
+   *
+   * @param out The underlying <code>OutputStream</code> to write data to
+   * @param size The size of the internal buffer
+   */
+  public BufferedOutputStream(OutputStream out, int size)
+  {
+    super(out);
+
+    buf = new byte[size];
+  }
+
+  /**
+   * This method causes any currently buffered bytes to be immediately
+   * written to the underlying output stream.
+   *
+   * @exception IOException If an error occurs
+   */
+  public synchronized void flush() throws IOException
+  {
+    if (count == 0)
+      return;
+
+    out.write(buf, 0, count);
+    count = 0;
+    out.flush();
+  }
+
+  /**
+   * This method flushes any remaining buffered bytes then closes the 
+   * underlying output stream.  Any further attempts to write to this stream
+   * may throw an exception
+   *
+  public synchronized void close() throws IOException
+  {
+    flush();
+    out.close();
+  }
+  */
+
+  /**
+   * This method runs when the object is garbage collected.  It is 
+   * responsible for ensuring that all buffered bytes are written and
+   * for closing the underlying stream.
+   *
+   * @exception IOException If an error occurs (ignored by the Java runtime)
+   *
+  protected void finalize() throws IOException
+  {
+    close();
+  }
+  */
+
+  /**
+   * This method writes a single byte of data.  This will be written to the
+   * buffer instead of the underlying data source.  However, if the buffer
+   * is filled as a result of this write request, it will be flushed to the
+   * underlying output stream.
+   *
+   * @param b The byte of data to be written, passed as an int
+   *
+   * @exception IOException If an error occurs
+   */
+  public synchronized void write(int b) throws IOException
+  {
+    if (count == buf.length)
+      flush();
+
+    buf[count] = (byte)(b & 0xFF);
+    ++count;
+  }
+
+  /**
+   * This method writes <code>len</code> bytes from the byte array 
+   * <code>buf</code> starting at position <code>offset</code> in the buffer. 
+   * These bytes will be written to the internal buffer.  However, if this
+   * write operation fills the buffer, the buffer will be flushed to the
+   * underlying output stream.
+   *
+   * @param buf The array of bytes to write.
+   * @param offset The index into the byte array to start writing from.
+   * @param len The number of bytes to write.
+   *
+   * @exception IOException If an error occurs
+   */
+  public synchronized void write(byte[] buf, int offset, int len) 
+    throws IOException
+  {
+    // Buffer can hold everything.  Note that the case where LEN < 0
+    // is automatically handled by the downstream write.
+    if (len < (this.buf.length - count))
+      {
+        System.arraycopy(buf, offset, this.buf, count, len);
+        count += len;
+      }
+    else
+      {
+        // The write was too big.  So flush the buffer and write the new
+        // bytes directly to the underlying stream, per the JDK 1.2
+        // docs.
+        flush();
+        out.write (buf, offset, len);
+      }
+  }
+
+} // class BufferedOutputStream 
+