BufferedWriter.java: Merged with Classpath.
* java/io/BufferedWriter.java: Merged with Classpath. * java/io/BufferedOutputStream.java: Merged with Classpath. From-SVN: r34041
This commit is contained in:
Tom Tromey
Tom Tromey
parent
a55583e909
commit
1dcc053603
@ -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
|
||||
|
||||
@ -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
|
||||
*/
|
||||
|
||||
/* 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 <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
|
||||
{
|
||||
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
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user