BufferedWriter.java: Merged with Classpath.

	* java/io/BufferedWriter.java: Merged with Classpath.
	* java/io/BufferedOutputStream.java: Merged with Classpath.

From-SVN: r34041

3 files changed, 320 insertions, 77 deletions

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 669ef7b..7ff63e2 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,8 @@
+2000-05-19  Tom Tromey  <tromey@cygnus.com>
+
+	* java/io/BufferedWriter.java: Merged with Classpath.
+	* java/io/BufferedOutputStream.java: Merged with Classpath.
+
 2000-05-16  Andrew Haley  <aph@cygnus.com>
 
 	* sysdep/ia64.c (ia64_backtrace_helper): Pass NULL pointer to
diff --git a/libjava/java/io/BufferedOutputStream.java b/libjava/java/io/BufferedOutputStream.java
index 262c054..09e0db8 100644
--- a/libjava/java/io/BufferedOutputStream.java
+++ b/libjava/java/io/BufferedOutputStream.java
@@ -1,79 +1,222 @@
-// BufferedOutputStream.java - A buffered stream
+/* BufferedOutputStream.java -- Buffer output into large blocks before writing
+   Copyright (C) 1998, 2000 Free Software Foundation, Inc.
 
-/* Copyright (C) 1998, 1999  Free Software Foundation
+This file is part of GNU Classpath.
 
-   This file is part of libgcj.
+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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
 
-This software is copyrighted work licensed under the terms of the
-Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
-details.  */
 
 package java.io;
 
 /**
- * @author Tom Tromey <tromey@cygnus.com>
- * @date September 24, 1998 
+  * 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.
+  *
+  * @version 0.0
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  */
+public class BufferedOutputStream extends FilterOutputStream
+{
+
+/*************************************************************************/
+
+/*
+ * Class Variables
  */
 
-/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
- * "The Java Language Specification", ISBN 0-201-63451-1
- * Status:  Complete to version 1.1.
+/**
+  * This is the default buffer size
+  */
+private static final int DEFAULT_BUFFER_SIZE = 512;
+
+/*************************************************************************/
+
+/*
+ * Instance Variables
  */
 
-public class BufferedOutputStream extends FilterOutputStream
+/**
+  * 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;
+
+/*************************************************************************/
+
+/*
+ * Constructors
+ */
+
+/**
+  * 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];
+}
+
+/*************************************************************************/
+
+/*
+ * Instance Methods
+ */
+
+/**
+  * 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;
+}
+
+/*************************************************************************/
+
+/*
+  * 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
 {
-  public BufferedOutputStream (OutputStream ox)
-  {
-    this (ox, 512);
-  }
-
-  public BufferedOutputStream (OutputStream ox, int size)
-  {
-    super (ox);
-    buf = new byte[size];
-  }
-
-  public synchronized void flush () throws IOException
-  {
-    out.write(buf, 0, count);
-    count = 0;
-    out.flush();
-  }
-
-  public synchronized void write (int b) throws IOException
-  {
-    // Flush output on overflow though JDK (1.2) doc may infer to flush on fill.
-    if (count < buf.length)
-      buf[count++] = (byte) b;
-    else
-      {
-	out.write(buf, 0, count);
-	count = 0;
-	out.write(b);
-      }
-  }
-
-  public synchronized void write (byte[] b, int off, int len)
-    throws IOException, NullPointerException, IndexOutOfBoundsException
-  {
-    // Flush output on overflow though JDK (1.2) doc may infer to flush on fill.
-
-    // If LEN < 0 then the downstream write will fail for us.
-    if (len >= 0 && count + len <= buf.length)
-      {
-	System.arraycopy(b, off, buf, count, len);
-	count += len;
-      }
-    else
-      {
-	out.write(buf, 0, count);
-	count = 0;
-	out.write(b, off, len);
-      }
-  }
-
-  // The buffer.
-  protected byte[] buf;
-  // Number of valid bytes in BUF.
-  protected int count;
+  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
+{
+  buf[count] = (byte)(b & 0xFF);
+
+  ++count;
+  if (count == buf.length)
+    flush();
 }
+
+/*************************************************************************/
+
+/**
+  * 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 
diff --git a/libjava/java/io/BufferedWriter.java b/libjava/java/io/BufferedWriter.java
index 3112a8a..f31dc28 100644
--- a/libjava/java/io/BufferedWriter.java
+++ b/libjava/java/io/BufferedWriter.java
@@ -1,6 +1,6 @@
 // BufferedWriter.java - Filtered character output stream.
 
-/* Copyright (C) 1998, 1999  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000  Free Software Foundation
 
    This file is part of libgcj.
 
@@ -10,24 +10,48 @@ details.  */
 
 package java.io;
 
-/**
- * @author Tom Tromey <tromey@cygnus.com>
- * @date September 25, 1998 
- */
-
 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
  * "The Java Language Specification", ISBN 0-201-63451-1
  * Status:  Complete to version 1.1.
  */
 
-// Why not extend FilterWriter?
+/**
+  * This class accumulates chars written in a buffer instead of immediately
+  * writing the data to the underlying output sink. The chars 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.
+  *
+  * @version 0.0
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  * @author Tom Tromey <tromey@cygnus.com>
+  * @date September 25, 1998 
+  */
+
 public class BufferedWriter extends Writer
 {
+  /**
+   * This method initializes a new <code>BufferedWriter</code> instance
+   * that will write to the specified subordinate <code>Writer</code>
+   * and which will use a default buffer size of 512 chars.
+   *
+   * @param out The underlying <code>Writer</code> to write data to
+   */
   public BufferedWriter (Writer out)
   {
-    this (out, 8192);
+    this (out, DEFAULT_BUFFER_SIZE);
   }
 
+  /**
+   * This method initializes a new <code>BufferedWriter</code> instance
+   * that will write to the specified subordinate <code>Writer</code>
+   * and which will use the specified buffer size
+   *
+   * @param out The underlying <code>Writer</code> to write data to
+   * @param size The size of the internal buffer
+   */
   public BufferedWriter (Writer ox, int size)
   {
     super (ox);
@@ -36,23 +60,51 @@ public class BufferedWriter extends Writer
     count = 0;
   }
 
+  /**
+   * This method flushes any remaining buffered chars then closes the 
+   * underlying output stream.  Any further attempts to write to this stream
+   * may throw an exception
+   */
   public void close () throws IOException
   {
     localFlush ();
     out.close();
   }
 
+  /**
+   * This method causes any currently buffered chars to be immediately
+   * written to the underlying output stream.
+   *
+   * @exception IOException If an error occurs
+   */
   public void flush () throws IOException
   {
     localFlush ();
     out.flush();
   }
 
+  /**
+   * This method writes out a system depedent line separator sequence.  The
+   * actual value written is detemined from the <xmp>line.separator</xmp>
+   * system property.
+   *
+   * @exception IOException If an error occurs
+   */
   public void newLine () throws IOException
   {
     write (System.getProperty("line.separator"));
   }
 
+  /**
+   * This method writes a single char 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 char of data to be written, passed as an int
+   *
+   * @exception IOException If an error occurs
+   */
   public void write (int oneChar) throws IOException
   {
     synchronized (lock)
@@ -63,6 +115,19 @@ public class BufferedWriter extends Writer
       }
   }
 
+  /**
+   * This method writes <code>len</code> chars from the char array 
+   * <code>buf</code> starting at position <code>offset</code> in the buffer. 
+   * These chars 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 chars to write.
+   * @param offset The index into the char array to start writing from.
+   * @param len The number of chars to write.
+   *
+   * @exception IOException If an error occurs
+   */
   public void write (char[] buf, int offset, int len) throws IOException
   {
     if (offset < 0 || len < 0 || offset + len > buf.length)
@@ -86,6 +151,19 @@ public class BufferedWriter extends Writer
       }
   }
 
+  /**
+   * This method writes <code>len</code> chars from the <code>String</code>
+   * <code>str</code> starting at position <code>offset</code> in the string. 
+   * These chars 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 str The <code>String</code> to write.
+   * @param offset The index into the string to start writing from.
+   * @param len The number of chars to write.
+   *
+   * @exception IOException If an error occurs
+   */
   public void write (String str, int offset, int len) throws IOException
   {
     if (offset < 0 || len < 0 || offset + len < str.length())
@@ -120,10 +198,27 @@ public class BufferedWriter extends Writer
       }
   }
 
-  // The downstream writer.
+  /**
+   * This is the underlying <code>Writer</code> to which this object
+   * sends its output.
+   */
   private Writer out;
-  // The character buffer.
+
+  /**
+   * This is the internal char array used for buffering output before
+   * writing it.
+   */
   char[] buffer;
-  // Number of valid chars in buffer.
+
+  /**
+   * This is the number of chars 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 char of data will be stored
+   */
   int count;
+
+  /**
+   * This is the default buffer size
+   */
+  private static final int DEFAULT_BUFFER_SIZE = 8192;
 }