diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 669ef7b933d..7ff63e227e8 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,8 @@ +2000-05-19 Tom Tromey + + * java/io/BufferedWriter.java: Merged with Classpath. + * java/io/BufferedOutputStream.java: Merged with Classpath. + 2000-05-16 Andrew Haley * 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 262c054e205..09e0db822d0 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 - * @date September 24, 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. - */ - + * 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 { - 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(); - } +/* + * Class Variables + */ - 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); - } - } +/** + * This is the default buffer size + */ +private static final int DEFAULT_BUFFER_SIZE = 512; - 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); - } - } +/* + * Instance Variables + */ - // The buffer. - protected byte[] buf; - // Number of valid bytes in BUF. - protected int count; +/** + * 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 BufferedOutputStream instance + * that will write to the specified subordinate OutputStream + * and which will use a default buffer size of 512 bytes. + * + * @param out The underlying OutputStream to write data to + */ +public +BufferedOutputStream(OutputStream out) +{ + this(out, DEFAULT_BUFFER_SIZE); } + +/*************************************************************************/ + +/** + * This method initializes a new BufferedOutputStream instance + * that will write to the specified subordinate OutputStream + * and which will use the specified buffer size + * + * @param out The underlying OutputStream 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 +{ + 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 len bytes from the byte array + * buf starting at position offset 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 3112a8adec9..f31dc28a0d2 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 - * @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 + * @date September 25, 1998 + */ + public class BufferedWriter extends Writer { + /** + * This method initializes a new BufferedWriter instance + * that will write to the specified subordinate Writer + * and which will use a default buffer size of 512 chars. + * + * @param out The underlying Writer to write data to + */ public BufferedWriter (Writer out) { - this (out, 8192); + this (out, DEFAULT_BUFFER_SIZE); } + /** + * This method initializes a new BufferedWriter instance + * that will write to the specified subordinate Writer + * and which will use the specified buffer size + * + * @param out The underlying Writer 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 line.separator + * 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 len chars from the char array + * buf starting at position offset 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 len chars from the String + * str starting at position offset 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 String 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 Writer 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; }