-// 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
// 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.
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);
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)
}
}
+ /**
+ * 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)
}
}
+ /**
+ * 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())
}
}
- // 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;
}
projects / gcc.git / commitdiff