Skip to content

R
riscv-gcc-1
Commit f4f5d1d6 by Michael Koch Committed by Michael Koch
Options

BufferedReader.java, [...]: Merged from classpath. 

2003-03-18  Michael Koch  <konqueror@gmx.de>

	* java/io/BufferedReader.java,
	java/io/BufferedWriter.java,
	java/io/ByteArrayOutputStream.java,
	java/io/FileFilter.java,
	java/io/FilePermission.java,
	java/io/FileReader.java,
	java/io/FileWriter.java,
	java/io/FilenameFilter.java,
	java/io/FilterInputStream.java,
	java/io/FilterOutputStream.java,
	java/io/FilterReader.java,
	java/io/FilterWriter.java,
	java/io/ObjectInput.java,
	java/io/ObjectInputValidation.java,
	java/io/ObjectOutput.java,
	java/io/ObjectStreamField.java,
	java/io/PipedInputStream.java,
	java/io/PipedReader.java,
	java/io/PrintWriter.java,
	java/io/PushbackReader.java,
	java/io/Reader.java,
	java/io/SerializablePermission.java,
	java/io/StringReader.java,
	java/io/Writer.java:
	Merged from classpath.

From-SVN: r64525
parent 61f1ed59
Showing with 1273 additions and 1239 deletions
libjava/ChangeLog
2003-03-18 Michael Koch <konqueror@gmx.de>
* java/io/BufferedReader.java,
java/io/BufferedWriter.java,
java/io/ByteArrayOutputStream.java,
java/io/FileFilter.java,
java/io/FilePermission.java,
java/io/FileReader.java,
java/io/FileWriter.java,
java/io/FilenameFilter.java,
java/io/FilterInputStream.java,
java/io/FilterOutputStream.java,
java/io/FilterReader.java,
java/io/FilterWriter.java,
java/io/ObjectInput.java,
java/io/ObjectInputValidation.java,
java/io/ObjectOutput.java,
java/io/ObjectStreamField.java,
java/io/PipedInputStream.java,
java/io/PipedReader.java,
java/io/PrintWriter.java,
java/io/PushbackReader.java,
java/io/Reader.java,
java/io/SerializablePermission.java,
java/io/StringReader.java,
java/io/Writer.java:
Merged from classpath.
2003-03-17 Michael Koch <konqueror@gmx.de>
* java/awt/ScrollPaneAdjustable.java:
......
libjava/java/io/BufferedReader.java
......@@ -243,7 +243,8 @@ public class BufferedReader extends Reader
* This method returns <code>false</code> then this stream could (but is
* not guaranteed to) block on the next read attempt.
*
* @return <code>true</code> if this stream is ready to be read, <code>false</code> otherwise
* @return <code>true</code> if this stream is ready to be read,
* <code>false</code> otherwise
*
* @exception IOException If an error occurs
*/
......@@ -258,7 +259,8 @@ public class BufferedReader extends Reader
/**
* This method read chars from a stream and stores them into a caller
* supplied buffer. It starts storing the data at index <code>offset</code> into
* supplied buffer. It starts storing the data at index
* <code>offset</code> into
* the buffer and attempts to read <code>len</code> chars. This method can
* return before reading the number of chars requested. The actual number
* of chars read is returned as an int. A -1 is returned to indicate the
......@@ -473,7 +475,8 @@ public class BufferedReader extends Reader
* requested amount.
* <p>
* This method first discards chars in the buffer, then calls the
* <code>skip</code> method on the underlying stream to skip the remaining chars.
* <code>skip</code> method on the underlying stream to skip the
* remaining chars.
*
* @param num_chars The requested number of chars to skip
*
......
libjava/java/io/BufferedWriter.java
......@@ -51,8 +51,6 @@ package java.io;
* 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
......
libjava/java/io/ByteArrayOutputStream.java
......@@ -65,8 +65,6 @@ package java.io;
* application specified character encoding. Thus it can handle
* multibyte character encodings.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Tom Tromey <tromey@cygnus.com>
* @date September 24, 1998
......
libjava/java/io/FileFilter.java
......@@ -46,23 +46,21 @@ package java.io;
* The method in this interface determines if a particular pathname should
* or should not be included in the pathname listing.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface FileFilter
{
/**
* This method determines whether or not a given pathname should be included
* in a pathname listing.
*
* @param pathname The pathname to test
*
* @return <code>true</code> if the path should be included in the list, <code>false</code> otherwise.
*/
public abstract boolean
accept(File pathname);
/**
* This method determines whether or not a given pathname should be included
* in a pathname listing.
*
* @param pathname The pathname to test
*
* @return <code>true</code> if the path should be included in the list,
* <code>false</code> otherwise.
*/
public abstract boolean accept(File pathname);
} // interface FileFilter
libjava/java/io/FileReader.java
/* FileReader.java -- Convenience class for reading characters from a file
Copyright (C) 1998, 2000 Free Software Foundation, Inc.
Copyright (C) 1998, 2000, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -46,8 +46,6 @@ package java.io;
* to read from files using the default character encoding. Use
* <code>InputStreamReader</code> directly to use a non-default encoding.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class FileReader extends InputStreamReader
......@@ -90,4 +88,5 @@ public class FileReader extends InputStreamReader
{
super(new FileInputStream(name));
}
}
} // class FileReader
libjava/java/io/FileWriter.java
......@@ -54,84 +54,82 @@ package java.io;
public class FileWriter extends OutputStreamWriter
{
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes a new <code>FileWriter</code> object to write
* to the specified <code>File</code> object.
*
* @param file The <code>File</code> object to write to.
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
* @param IOException If any other error occurs
*/
public
FileWriter(File file) throws SecurityException, IOException
{
super(new FileOutputStream(file));
}
/*************************************************************************/
/**
* This method initializes a new <code>FileWriter</code> object to write
* to the specified <code>FileDescriptor</code> object.
*
* @param fd The <code>FileDescriptor</code> object to write to
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
*/
public
FileWriter(FileDescriptor fd) throws SecurityException
{
super(new FileOutputStream(fd));
}
/*************************************************************************/
/**
* This method intializes a new <code>FileWriter</code> object to write to the
* specified named file.
*
* @param name The name of the file to write to
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
* @param IOException If any other error occurs
*/
public
FileWriter(String name) throws IOException
{
super(new FileOutputStream(name));
}
/*************************************************************************/
/**
* This method intializes a new <code>FileWriter</code> object to write to the
* specified named file. This form of the constructor allows the caller
* to determin whether data should be written starting at the beginning or
* the end of the file.
*
* @param name The name of the file to write to
* @param append <code>true</code> to start adding data at the end of the
* file, <code>false</code> otherwise.
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
* @param IOException If any other error occurs
*/
public
FileWriter(String name, boolean append) throws IOException
{
super(new FileOutputStream(name, append));
}
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes a new <code>FileWriter</code> object to write
* to the specified <code>File</code> object.
*
* @param file The <code>File</code> object to write to.
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
* @param IOException If any other error occurs
*/
public FileWriter(File file) throws SecurityException, IOException
{
super(new FileOutputStream(file));
}
/*************************************************************************/
/**
* This method initializes a new <code>FileWriter</code> object to write
* to the specified <code>FileDescriptor</code> object.
*
* @param fd The <code>FileDescriptor</code> object to write to
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
*/
public FileWriter(FileDescriptor fd) throws SecurityException
{
super(new FileOutputStream(fd));
}
/*************************************************************************/
/**
* This method intializes a new <code>FileWriter</code> object to
* write to the
* specified named file.
*
* @param name The name of the file to write to
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
* @param IOException If any other error occurs
*/
public FileWriter(String name) throws IOException
{
super(new FileOutputStream(name));
}
/*************************************************************************/
/**
* This method intializes a new <code>FileWriter</code> object to
* write to the
* specified named file. This form of the constructor allows the caller
* to determin whether data should be written starting at the beginning or
* the end of the file.
*
* @param name The name of the file to write to
* @param append <code>true</code> to start adding data at the end of the
* file, <code>false</code> otherwise.
*
* @param SecurityException If writing to this file is forbidden by the
* <code>SecurityManager</code>.
* @param IOException If any other error occurs
*/
public FileWriter(String name, boolean append) throws IOException
{
super(new FileOutputStream(name, append));
}
} // class FileWriter
libjava/java/io/FilenameFilter.java
......@@ -57,17 +57,17 @@ package java.io;
public interface FilenameFilter
{
/**
* This method determines whether or not a given file should be included
* in a directory listing.
*
* @param dir The <code>File</code> instance for the directory being read
* @param name The name of the file to test
*
* @return <code>true</code> if the file should be included in the list,
* <code>false</code> otherwise.
*/
boolean
accept(File dir, String name);
/**
* This method determines whether or not a given file should be included
* in a directory listing.
*
* @param dir The <code>File</code> instance for the directory being read
* @param name The name of the file to test
*
* @return <code>true</code> if the file should be included in the list,
* <code>false</code> otherwise.
*/
boolean accept(File dir, String name);
} // interface FilenameFilter
libjava/java/io/FilterInputStream.java
......@@ -70,179 +70,171 @@ package java.io;
public class FilterInputStream extends InputStream
{
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the subordinate <code>InputStream</code> to which method calls
* are redirected
*/
protected InputStream in;
/*************************************************************************/
/*
* Constructors
*/
/**
* Create a <code>FilterInputStream</code> with the specified subordinate
* <code>InputStream</code>.
*
* @param in The subordinate <code>InputStream</code>
*/
protected
FilterInputStream(InputStream in)
{
this.in = in;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* Calls the <code>in.mark(int)</code> method.
*
* @param readlimit The parameter passed to <code>in.mark(int)</code>
*/
public void
mark(int readlimit)
{
in.mark(readlimit);
}
/*************************************************************************/
/**
* Calls the <code>in.markSupported()</code> method.
*
* @return <code>true</code> if mark/reset is supported, <code>false</code>
* otherwise
*/
public boolean
markSupported()
{
return(in.markSupported());
}
/*************************************************************************/
/**
* Calls the <code>in.reset()</code> method.
*
* @exception IOException If an error occurs
*/
public void
reset() throws IOException
{
in.reset();
}
/*************************************************************************/
/**
* Calls the <code>in.available()</code> method.
*
* @return The value returned from <code>in.available()</code>
*
* @exception IOException If an error occurs
*/
public int
available() throws IOException
{
return(in.available());
}
/*************************************************************************/
/**
* Calls the <code>in.skip(long)</code> method
*
* @param The requested number of bytes to skip.
*
* @return The value returned from <code>in.skip(long)</code>
*
* @exception IOException If an error occurs
*/
public long
skip(long num_bytes) throws IOException
{
return(in.skip(num_bytes));
}
/*************************************************************************/
/**
* Calls the <code>in.read()</code> method
*
* @return The value returned from <code>in.read()</code>
*
* @exception IOException If an error occurs
*/
public int
read() throws IOException
{
return(in.read());
}
/*************************************************************************/
/**
* Calls the <code>read(byte[], int, int)</code> overloaded method. Note that
* this method does not redirect its call directly to a corresponding
* method in <code>in</code>. This allows subclasses to override only the
* three argument version of <code>read</code>.
*
* @param buf The buffer to read bytes into
*
* @return The value retured from <code>in.read(byte[], int, int)</code>
*
* @exception IOException If an error occurs
*/
public int
read(byte[] buf) throws IOException
{
return(read(buf, 0, buf.length));
}
/*************************************************************************/
/**
* Calls the <code>in.read(byte[], int, int)</code> method.
*
* @param buf The buffer to read bytes into
* @param offset The index into the buffer to start storing bytes
* @param len The maximum number of bytes to read.
*
* @return The value retured from <code>in.read(byte[], int, int)</code>
*
* @exception IOException If an error occurs
*/
public int
read(byte[] buf, int offset, int len) throws IOException
{
return(in.read(buf, offset, len));
}
/*************************************************************************/
/**
* This method closes the input stream by closing the input stream that
* this object is filtering. Future attempts to access this stream may
* throw an exception.
*
* @exception IOException If an error occurs
*/
public void
close() throws IOException
{
in.close();
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the subordinate <code>InputStream</code> to which method calls
* are redirected
*/
protected InputStream in;
/*************************************************************************/
/*
* Constructors
*/
/**
* Create a <code>FilterInputStream</code> with the specified subordinate
* <code>InputStream</code>.
*
* @param in The subordinate <code>InputStream</code>
*/
protected FilterInputStream(InputStream in)
{
this.in = in;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* Calls the <code>in.mark(int)</code> method.
*
* @param readlimit The parameter passed to <code>in.mark(int)</code>
*/
public void mark(int readlimit)
{
in.mark(readlimit);
}
/*************************************************************************/
/**
* Calls the <code>in.markSupported()</code> method.
*
* @return <code>true</code> if mark/reset is supported, <code>false</code>
* otherwise
*/
public boolean markSupported()
{
return(in.markSupported());
}
/*************************************************************************/
/**
* Calls the <code>in.reset()</code> method.
*
* @exception IOException If an error occurs
*/
public void reset() throws IOException
{
in.reset();
}
/*************************************************************************/
/**
* Calls the <code>in.available()</code> method.
*
* @return The value returned from <code>in.available()</code>
*
* @exception IOException If an error occurs
*/
public int available() throws IOException
{
return(in.available());
}
/*************************************************************************/
/**
* Calls the <code>in.skip(long)</code> method
*
* @param numBytes The requested number of bytes to skip.
*
* @return The value returned from <code>in.skip(long)</code>
*
* @exception IOException If an error occurs
*/
public long skip(long num_bytes) throws IOException
{
return(in.skip(num_bytes));
}
/*************************************************************************/
/**
* Calls the <code>in.read()</code> method
*
* @return The value returned from <code>in.read()</code>
*
* @exception IOException If an error occurs
*/
public int read() throws IOException
{
return(in.read());
}
/*************************************************************************/
/**
* Calls the <code>read(byte[], int, int)</code> overloaded method.
* Note that
* this method does not redirect its call directly to a corresponding
* method in <code>in</code>. This allows subclasses to override only the
* three argument version of <code>read</code>.
*
* @param buf The buffer to read bytes into
*
* @return The value retured from <code>in.read(byte[], int, int)</code>
*
* @exception IOException If an error occurs
*/
public int read(byte[] buf) throws IOException
{
return(read(buf, 0, buf.length));
}
/*************************************************************************/
/**
* Calls the <code>in.read(byte[], int, int)</code> method.
*
* @param buf The buffer to read bytes into
* @param offset The index into the buffer to start storing bytes
* @param len The maximum number of bytes to read.
*
* @return The value retured from <code>in.read(byte[], int, int)</code>
*
* @exception IOException If an error occurs
*/
public int read(byte[] buf, int offset, int len) throws IOException
{
return(in.read(buf, offset, len));
}
/*************************************************************************/
/**
* This method closes the input stream by closing the input stream that
* this object is filtering. Future attempts to access this stream may
* throw an exception.
*
* @exception IOException If an error occurs
*/
public void close() throws IOException
{
in.close();
}
} // class FilterInputStream
libjava/java/io/FilterOutputStream.java
/* FilterOutputStream.java -- Parent class for output streams that filter
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2001, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -57,126 +57,121 @@ package java.io;
public class FilterOutputStream extends OutputStream
{
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the subordinate <code>OutputStream</code> that this class
* redirects its method calls to.
*/
protected OutputStream out;
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes an instance of <code>FilterOutputStream</code>
* to write to the specified subordinate <code>OutputStream</code>.
*
* @param out The <code>OutputStream</code> to write to
*/
public
FilterOutputStream(OutputStream out)
{
this.out = out;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method closes the underlying <code>OutputStream</code>. Any
* further attempts to write to this stream may throw an exception.
*
* @exception IOException If an error occurs
*/
public void
close() throws IOException
{
flush();
out.close();
}
/*************************************************************************/
/**
* This method attempt to flush all buffered output to be written to the
* underlying output sink.
*
* @exception IOException If an error occurs
*/
public void
flush() throws IOException
{
out.flush();
}
/*************************************************************************/
/**
* This method writes a single byte of output to the underlying
* <code>OutputStream</code>.
*
* @param b The byte to write, passed as an int.
*
* @exception IOException If an error occurs
*/
public void
write(int b) throws IOException
{
out.write(b);
}
/*************************************************************************/
/**
* This method writes all the bytes in the specified array to the underlying
* <code>OutputStream</code>. It does this by calling the three parameter
* version of this method - <code>write(byte[], int, int)</code> in this
* class instead of writing to the underlying <code>OutputStream</code>
* directly. This allows most subclasses to avoid overriding this method.
*
* @param buf The byte array to write bytes from
*
* @exception IOException If an error occurs
*/
public void
write(byte[] buf) throws IOException
{
// Don't do checking here, per Java Lang Spec.
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method calls the <code>write(int)</code> method <code>len</code>
* times for all bytes from the array <code>buf</code> starting at index
* <code>offset</code>. Subclasses should overwrite this method to get a
* more efficient implementation.
*
* @param buf The byte array to write bytes from
* @param offset The index into the array to start writing bytes from
* @param len The number of bytes to write
*
* @exception IOException If an error occurs
*/
public void
write(byte[] buf, int offset, int len) throws IOException
{
// Don't do checking here, per Java Lang Spec.
for (int i=0; i < len; i++)
write(buf[offset + i]);
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the subordinate <code>OutputStream</code> that this class
* redirects its method calls to.
*/
protected OutputStream out;
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes an instance of <code>FilterOutputStream</code>
* to write to the specified subordinate <code>OutputStream</code>.
*
* @param out The <code>OutputStream</code> to write to
*/
public FilterOutputStream(OutputStream out)
{
this.out = out;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method closes the underlying <code>OutputStream</code>. Any
* further attempts to write to this stream may throw an exception.
*
* @exception IOException If an error occurs
*/
public void close() throws IOException
{
flush();
out.close();
}
/*************************************************************************/
/**
* This method attempt to flush all buffered output to be written to the
* underlying output sink.
*
* @exception IOException If an error occurs
*/
public void flush() throws IOException
{
out.flush();
}
/*************************************************************************/
/**
* This method writes a single byte of output to the underlying
* <code>OutputStream</code>.
*
* @param b The byte to write, passed as an int.
*
* @exception IOException If an error occurs
*/
public void write(int b) throws IOException
{
out.write(b);
}
/*************************************************************************/
/**
* This method writes all the bytes in the specified array to the underlying
* <code>OutputStream</code>. It does this by calling the three parameter
* version of this method - <code>write(byte[], int, int)</code> in this
* class instead of writing to the underlying <code>OutputStream</code>
* directly. This allows most subclasses to avoid overriding this method.
*
* @param buf The byte array to write bytes from
*
* @exception IOException If an error occurs
*/
public void write(byte[] buf) throws IOException
{
// Don't do checking here, per Java Lang Spec.
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method calls the <code>write(int)</code> method <code>len</code>
* times for all bytes from the array <code>buf</code> starting at index
* <code>offset</code>. Subclasses should overwrite this method to get a
* more efficient implementation.
*
* @param buf The byte array to write bytes from
* @param offset The index into the array to start writing bytes from
* @param len The number of bytes to write
*
* @exception IOException If an error occurs
*/
public void write(byte[] buf, int offset, int len) throws IOException
{
// Don't do checking here, per Java Lang Spec.
for (int i=0; i < len; i++)
write(buf[offset + i]);
}
} // class FilterOutputStream
libjava/java/io/FilterReader.java
/* FilterReader.java -- Base class for char stream classes that filter input
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2001, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -63,163 +63,153 @@ package java.io;
*/
public abstract class FilterReader extends Reader
{
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the subordinate <code>Reader</code> to which method calls
* are redirected
*/
protected Reader in;
/*************************************************************************/
/*
* Constructors
*/
/**
* Create a <code>FilterReader</code> with the specified subordinate
* <code>Reader</code>.
* The <code>lock</code> of the new <code>FilterReader</code> will be set
* to <code>in.lock</code>.
*
* @param in The subordinate <code>Reader</code>
*/
protected
FilterReader(Reader in)
{
super(in.lock);
this.in = in;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* Calls the <code>in.mark(int)</code> method.
*
* @param readlimit The parameter passed to <code>in.mark(int)</code>
*
* @exception IOException If an error occurs
*/
public void
mark(int readlimit) throws IOException
{
in.mark(readlimit);
}
/*************************************************************************/
/**
* Calls the <code>in.markSupported()</code> method.
*
* @return <code>true</code> if mark/reset is supported, <code>false</code> otherwise
*/
public boolean
markSupported()
{
return(in.markSupported());
}
/*************************************************************************/
/**
* Calls the <code>in.reset()</code> method.
*
* @exception IOException If an error occurs
*/
public void
reset() throws IOException
{
in.reset();
}
/*************************************************************************/
/**
* Calls the <code>in.read()</code> method.
*
* @return The value returned from <code>in.available()</code>
*
* @exception IOException If an error occurs
*/
public boolean
ready() throws IOException
{
return(in.ready());
}
/*************************************************************************/
/**
* Calls the <code>in.skip(long)</code> method
*
* @param The requested number of chars to skip.
*
* @return The value returned from <code>in.skip(long)</code>
*
* @exception IOException If an error occurs
*/
public long
skip(long num_chars) throws IOException
{
return(in.skip(num_chars));
}
/*************************************************************************/
/**
* Calls the <code>in.read()</code> method
*
* @return The value returned from <code>in.read()</code>
*
* @exception IOException If an error occurs
*/
public int
read() throws IOException
{
return(in.read());
}
/*************************************************************************/
/**
* Calls the <code>in.read(char[], int, int)</code> method.
*
* @param buf The buffer to read chars into
* @param offset The index into the buffer to start storing chars
* @param len The maximum number of chars to read.
*
* @return The value retured from <code>in.read(char[], int, int)</code>
*
* @exception IOException If an error occurs
*/
public int
read(char[] buf, int offset, int len) throws IOException
{
return(in.read(buf, offset, len));
}
/*************************************************************************/
/**
* This method closes the stream by calling the <code>close()</code> method
* of the underlying stream.
*
* @exception IOException If an error occurs
*/
public void
close() throws IOException
{
in.close();
}
/*
* Instance Variables
*/
/**
* This is the subordinate <code>Reader</code> to which method calls
* are redirected
*/
protected Reader in;
/*************************************************************************/
/*
* Constructors
*/
/**
* Create a <code>FilterReader</code> with the specified subordinate
* <code>Reader</code>.
* The <code>lock</code> of the new <code>FilterReader</code> will be set
* to <code>in.lock</code>.
*
* @param in The subordinate <code>Reader</code>
*/
protected FilterReader(Reader in)
{
super(in.lock);
this.in = in;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* Calls the <code>in.mark(int)</code> method.
*
* @param readlimit The parameter passed to <code>in.mark(int)</code>
*
* @exception IOException If an error occurs
*/
public void mark(int readlimit) throws IOException
{
in.mark(readlimit);
}
/*************************************************************************/
/**
* Calls the <code>in.markSupported()</code> method.
*
* @return <code>true</code> if mark/reset is supported,
* <code>false</code> otherwise
*/
public boolean markSupported()
{
return(in.markSupported());
}
/*************************************************************************/
/**
* Calls the <code>in.reset()</code> method.
*
* @exception IOException If an error occurs
*/
public void reset() throws IOException
{
in.reset();
}
/*************************************************************************/
/**
* Calls the <code>in.read()</code> method.
*
* @return The value returned from <code>in.available()</code>
*
* @exception IOException If an error occurs
*/
public boolean ready() throws IOException
{
return(in.ready());
}
/*************************************************************************/
/**
* Calls the <code>in.skip(long)</code> method
*
* @param numBytes The requested number of chars to skip.
*
* @return The value returned from <code>in.skip(long)</code>
*
* @exception IOException If an error occurs
*/
public long skip(long num_chars) throws IOException
{
return(in.skip(num_chars));
}
/*************************************************************************/
/**
* Calls the <code>in.read()</code> method
*
* @return The value returned from <code>in.read()</code>
*
* @exception IOException If an error occurs
*/
public int read() throws IOException
{
return(in.read());
}
/*************************************************************************/
/**
* Calls the <code>in.read(char[], int, int)</code> method.
*
* @param buf The buffer to read chars into
* @param offset The index into the buffer to start storing chars
* @param len The maximum number of chars to read.
*
* @return The value retured from <code>in.read(char[], int, int)</code>
*
* @exception IOException If an error occurs
*/
public int read(char[] buf, int offset, int len) throws IOException
{
return(in.read(buf, offset, len));
}
/*************************************************************************/
/**
* This method closes the stream by calling the <code>close()</code> method
* of the underlying stream.
*
* @exception IOException If an error occurs
*/
public void close() throws IOException
{
in.close();
}
} // class FilterReader
libjava/java/io/FilterWriter.java
/* FilterWriter.java -- Parent class for output streams that filter
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2001, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -52,128 +52,120 @@ package java.io;
* underlying stream. Subclasses provide actual filtering.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Tom Tromey <tromey@cygnus.com>
* @author Tom Tromey <tromey@cygnus.com>
*/
public abstract class FilterWriter extends Writer
{
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the subordinate <code>Writer</code> that this class
* redirects its method calls to.
*/
protected Writer out;
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes an instance of <code>FilterWriter</code>
* to write to the specified subordinate <code>Writer</code>.
* The given <code>Writer</code> will be used as <code>lock</code> for
* the newly created <code>FilterWriter</code>.
*
* @param out The <code>Writer</code> to write to
*/
protected
FilterWriter(Writer out)
{
super(out);
this.out = out;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method closes the underlying <code>Writer</code>. Any
* further attempts to write to this stream may throw an exception.
*
* @exception IOException If an error occurs
*/
public void
close() throws IOException
{
out.close();
}
/*************************************************************************/
/**
* This method attempt to flush all buffered output to be written to the
* underlying output sink.
*
* @exception IOException If an error occurs
*/
public void
flush() throws IOException
{
out.flush();
}
/*************************************************************************/
/**
* This method writes a single char of output to the underlying
* <code>Writer</code>.
*
* @param b The char to write, passed as an int.
*
* @exception IOException If an error occurs
*/
public void
write(int b) throws IOException
{
out.write(b);
}
/*************************************************************************/
/**
* This method writes <code>len</code> chars from the array <code>buf</code>
* starting at index <code>offset</code> to the underlying
* <code>Writer</code>.
*
* @param buf The char array to write chars from
* @param offset The index into the array to start writing chars 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
{
out.write(buf, offset, len);
}
/*************************************************************************/
/**
* This method writes <code>len</code> chars from the <code>String</code>
* starting at position <code>offset</code>.
*
* @param str The <code>String</code> that is to be written
* @param offset The character offset into the <code>String</code> 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
{
out.write(str, offset, len);
}
/*
* Instance Variables
*/
/**
* This is the subordinate <code>Writer</code> that this class
* redirects its method calls to.
*/
protected Writer out;
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes an instance of <code>FilterWriter</code>
* to write to the specified subordinate <code>Writer</code>.
* The given <code>Writer</code> will be used as <code>lock</code> for
* the newly created <code>FilterWriter</code>.
*
* @param out The <code>Writer</code> to write to
*/
protected FilterWriter(Writer out)
{
super(out);
this.out = out;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method closes the underlying <code>Writer</code>. Any
* further attempts to write to this stream may throw an exception.
*
* @exception IOException If an error occurs
*/
public void close() throws IOException
{
out.close();
}
/*************************************************************************/
/**
* This method attempt to flush all buffered output to be written to the
* underlying output sink.
*
* @exception IOException If an error occurs
*/
public void flush() throws IOException
{
out.flush();
}
/*************************************************************************/
/**
* This method writes a single char of output to the underlying
* <code>Writer</code>.
*
* @param b The char to write, passed as an int.
*
* @exception IOException If an error occurs
*/
public void write(int b) throws IOException
{
out.write(b);
}
/*************************************************************************/
/**
* This method writes <code>len</code> chars from the array <code>buf</code>
* starting at index <code>offset</code> to the underlying
* <code>Writer</code>.
*
* @param buf The char array to write chars from
* @param offset The index into the array to start writing chars 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
{
out.write(buf, offset, len);
}
/*************************************************************************/
/**
* This method writes <code>len</code> chars from the <code>String</code>
* starting at position <code>offset</code>.
*
* @param str The <code>String</code> that is to be written
* @param offset The character offset into the <code>String</code>
* 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
{
out.write(str, offset, len);
}
} // class FilterWriter
libjava/java/io/ObjectInput.java
/* ObjectInput.java -- Read object data from a stream
Copyright (C) 1998 Free Software Foundation, Inc.
Copyright (C) 1998,2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -44,115 +44,108 @@ package java.io;
* also has methods that allow input to be done in a manner similar to
* <code>InputStream</code>
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface ObjectInput extends DataInput
{
/**
* This method returns the number of bytes that can be read without
* blocking.
*
* @return The number of bytes available before blocking
*
* @exception IOException If an error occurs
*/
public abstract int
available() throws IOException;
/*************************************************************************/
/**
* This method reading a byte of data from a stream. It returns that byte
* as an int. This method blocks if no data is available to be read.
*
* @return The byte of data read
*
* @exception IOException If an error occurs
*/
public abstract int
read() throws IOException;
/*************************************************************************/
/**
* This method reads raw bytes and stores them them a byte array buffer.
* Note that this method will block if no data is available. However,
* it will not necessarily block until it fills the entire buffer. That is,
* a "short count" is possible.
*
* @param buf The byte array to receive the data read
*
* @return The actual number fo bytes read or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public abstract int
read(byte[] buf) throws IOException;
/*************************************************************************/
/**
* This method reads raw bytes and stores them in a byte array buffer
* <code>buf</code> starting at position <code>offset</code> into the buffer. A
* maximum of <code>len</code> bytes will be read. Note that this method
* blocks if no data is available, but will not necessarily block until
* it can read <code>len</code> bytes of data. That is, a "short count" is
* possible.
*
* @param buf The byte array to receive the data read
* @param offset The offset into @code{buf} to start storing data
* @param len The maximum number of bytes to read
*
* @return The actual number fo bytes read or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public abstract int
read(byte[] buf, int offset, int len) throws IOException;
/*************************************************************************/
/**
* Reads an object instance and returns it. If the class for the object
* being read cannot be found, then a ClassNotFoundException will
* be thrown.
*
* @return The object instance that was read
*
* @exception ClassNotFoundException If a class for the object cannot be found
* @exception IOException If an error occurs
*/
public abstract Object
readObject() throws ClassNotFoundException, IOException;
/*************************************************************************/
/**
* This method causes the specified number of bytes to be read and
* discarded. It is possible that fewer than the requested number of bytes
* will actually be skipped.
*
* @param num_bytes The number of bytes to skip
*
* @return The actual number of bytes skipped
*
* @exception IOException If an error occurs
*/
public abstract long
skip(long num_bytes) throws IOException;
/*************************************************************************/
/**
* This method closes the input source
*
* @exception IOException If an error occurs
*/
public abstract void
close() throws IOException;
/**
* This method returns the number of bytes that can be read without
* blocking.
*
* @return The number of bytes available before blocking
*
* @exception IOException If an error occurs
*/
public abstract int available() throws IOException;
/*************************************************************************/
/**
* This method reading a byte of data from a stream. It returns that byte
* as an int. This method blocks if no data is available to be read.
*
* @return The byte of data read
*
* @exception IOException If an error occurs
*/
public abstract int read() throws IOException;
/*************************************************************************/
/**
* This method reads raw bytes and stores them them a byte array buffer.
* Note that this method will block if no data is available. However,
* it will not necessarily block until it fills the entire buffer. That is,
* a "short count" is possible.
*
* @param buf The byte array to receive the data read
*
* @return The actual number fo bytes read or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public abstract int read(byte[] buf) throws IOException;
/*************************************************************************/
/**
* This method reads raw bytes and stores them in a byte array buffer
* <code>buf</code> starting at position <code>offset</code> into the
* buffer. A
* maximum of <code>len</code> bytes will be read. Note that this method
* blocks if no data is available, but will not necessarily block until
* it can read <code>len</code> bytes of data. That is, a "short count" is
* possible.
*
* @param buf The byte array to receive the data read
* @param offset The offset into @code{buf} to start storing data
* @param len The maximum number of bytes to read
*
* @return The actual number fo bytes read or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public abstract int read(byte[] buf, int offset, int len) throws IOException;
/*************************************************************************/
/**
* Reads an object instance and returns it. If the class for the object
* being read cannot be found, then a ClassNotFoundException will
* be thrown.
*
* @return The object instance that was read
*
* @exception ClassNotFoundException If a class for the object cannot be
* found
* @exception IOException If an error occurs
*/
public abstract Object readObject()
throws ClassNotFoundException, IOException;
/*************************************************************************/
/**
* This method causes the specified number of bytes to be read and
* discarded. It is possible that fewer than the requested number of bytes
* will actually be skipped.
*
* @param numBytes The number of bytes to skip
*
* @return The actual number of bytes skipped
*
* @exception IOException If an error occurs
*/
public abstract long skip(long num_bytes) throws IOException;
/*************************************************************************/
/**
* This method closes the input source
*
* @exception IOException If an error occurs
*/
public abstract void close() throws IOException;
} // interface ObjectInput
libjava/java/io/ObjectInputValidation.java
/* ObjectInputValidation.java -- Validate an object
Copyright (C) 1998 Free Software Foundation, Inc.
Copyright (C) 1998, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -41,21 +41,18 @@ package java.io;
/**
* What does this interface really do?
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface ObjectInputValidation
{
/**
* This method is called to validate an object. If the object is invalid
* an exception is thrown.
*
* @exception InvalidObjectException If the object is invalid
*/
public abstract void
validateObject() throws InvalidObjectException;
/**
* This method is called to validate an object. If the object is invalid
* an exception is thrown.
*
* @exception InvalidObjectException If the object is invalid
*/
public abstract void validateObject() throws InvalidObjectException;
} // interface ObjectInputValidation
libjava/java/io/ObjectOutput.java
/* ObjectOutput.java -- Interface for writing objects to a stream
Copyright (C) 1998 Free Software Foundation, Inc.
Copyright (C) 1998, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -41,87 +41,80 @@ package java.io;
/**
* This interface extends <code>DataOutput</code> to provide the additional
* facility of writing object instances to a stream. It also adds some
* additional methods to make the interface more <code>OutputStream</code> like.
*
* @version 0.0
* additional methods to make the interface more
* <code>OutputStream</code> like.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface ObjectOutput extends DataOutput
{
/**
* This method writes the specified byte to the output stream.
*
* @param b The byte to write.
*
* @exception IOException If an error occurs.
*/
public abstract void
write(int b) throws IOException;
/*************************************************************************/
/**
* This method writes all the bytes in the specified byte array to the
* output stream.
*
* @param buf The array of bytes to write.
*
* @exception IOException If an error occurs.
*/
public abstract void
write(byte[] buf) throws IOException;
/*************************************************************************/
/**
* This method writes <code>len</code> bytes from the specified array
* starting at index <code>offset</code> into that array.
*
* @param buf The byte array to write from.
* @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 abstract void
write(byte[] buf, int offset, int len) throws IOException;
/*************************************************************************/
/**
* This method writes a object instance to a stream. The format of the
* data written is determined by the actual implementation of this method
*
* @param obj The object to write
*
* @exception IOException If an error occurs
*/
public abstract void
writeObject(Object obj) throws IOException;
/*************************************************************************/
/**
* This method causes any buffered data to be flushed out to the underlying
* stream
*
* @exception IOException If an error occurs
*/
public abstract void
flush() throws IOException;
/*************************************************************************/
/**
* This method closes the underlying stream.
*
* @exception IOException If an error occurs
*/
public abstract void
close() throws IOException;
/**
* This method writes the specified byte to the output stream.
*
* @param b The byte to write.
*
* @exception IOException If an error occurs.
*/
public abstract void write(int b) throws IOException;
/*************************************************************************/
/**
* This method writes all the bytes in the specified byte array to the
* output stream.
*
* @param buf The array of bytes to write.
*
* @exception IOException If an error occurs.
*/
public abstract void write(byte[] buf) throws IOException;
/*************************************************************************/
/**
* This method writes <code>len</code> bytes from the specified array
* starting at index <code>offset</code> into that array.
*
* @param buf The byte array to write from.
* @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 abstract void write(byte[] buf, int offset, int len)
throws IOException;
/*************************************************************************/
/**
* This method writes a object instance to a stream. The format of the
* data written is determined by the actual implementation of this method
*
* @param obj The object to write
*
* @exception IOException If an error occurs
*/
public abstract void writeObject(Object obj) throws IOException;
/*************************************************************************/
/**
* This method causes any buffered data to be flushed out to the underlying
* stream
*
* @exception IOException If an error occurs
*/
public abstract void flush() throws IOException;
/*************************************************************************/
/**
* This method closes the underlying stream.
*
* @exception IOException If an error occurs
*/
public abstract void close() throws IOException;
} // interface ObjectOutput
libjava/java/io/ObjectStreamField.java
/* ObjectStreamField.java -- Class used to store name and class of fields
Copyright (C) 1998, 1999 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -51,17 +51,21 @@ public class ObjectStreamField implements java.lang.Comparable
}
/**
* There're many cases you can't get java.lang.Class from typename if your context
* There're many cases you can't get java.lang.Class from typename
* if your context
* class loader can't load it, then use typename to construct the field
*/
ObjectStreamField (String name, String typename){
this.name = name;
this.typename = typename;
try{
type = TypeSignature.getClassForEncoding(typename);
}catch(ClassNotFoundException e){
type = Object.class; //??
}
try
{
type = TypeSignature.getClassForEncoding(typename);
}
catch(ClassNotFoundException e)
{
type = Object.class; //FIXME: ???
}
}
public String getName ()
......@@ -125,3 +129,4 @@ public class ObjectStreamField implements java.lang.Comparable
private String typename;
private int offset = -1; // XXX make sure this is correct
}
libjava/java/io/PipedInputStream.java
/* PipedInputStream.java -- Read portion of piped streams.
Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -46,7 +46,8 @@ package java.io;
* to which it is connected.
* <p>
* Data is read and written to an internal buffer. It is highly recommended
* that the <code>PipedInputStream</code> and connected <code>PipedOutputStream</code>
* that the <code>PipedInputStream</code> and connected
* <code>PipedOutputStream</code>
* be part of different threads. If they are not, the read and write
* operations could deadlock their thread.
*
......@@ -113,7 +114,8 @@ public class PipedInputStream extends InputStream
* it to the passed in <code>PipedOutputStream</code>. The stream is then
* ready for reading.
*
* @param source The <code>PipedOutputStream</code> to connect this stream to
* @param source The <code>PipedOutputStream</code> to connect this
* stream to
*
* @exception IOException If <code>source</code> is already connected.
*/
......@@ -123,7 +125,8 @@ public class PipedInputStream extends InputStream
}
/**
* This method connects this stream to the passed in <code>PipedOutputStream</code>.
* This method connects this stream to the passed in
* <code>PipedOutputStream</code>.
* This stream is then ready for reading. If this stream is already
* connected or has been previously closed, then an exception is thrown
*
......@@ -224,9 +227,12 @@ public class PipedInputStream extends InputStream
/**
* This method reads bytes from the stream into a caller supplied buffer.
* It starts storing bytes at position <code>offset</code> into the buffer and
* reads a maximum of <code>len</code> bytes. Note that this method can actually
* read fewer than <code>len</code> bytes. The actual number of bytes read is
* It starts storing bytes at position <code>offset</code> into the
* buffer and
* reads a maximum of <code>len</code> bytes. Note that this method
* can actually
* read fewer than <code>len</code> bytes. The actual number of bytes
* read is
* returned. A -1 is returned to indicated that no bytes can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
......@@ -255,9 +261,12 @@ public class PipedInputStream extends InputStream
/**
* This method reads bytes from the stream into a caller supplied buffer.
* It starts storing bytes at position <code>offset</code> into the buffer and
* reads a maximum of <code>len</code> bytes. Note that this method can actually
* read fewer than <code>len</code> bytes. The actual number of bytes read is
* It starts storing bytes at position <code>offset</code> into the
* buffer and
* reads a maximum of <code>len</code> bytes. Note that this method
* can actually
* read fewer than <code>len</code> bytes. The actual number of bytes
* read is
* returned. A -1 is returned to indicated that no bytes can be read
* because the end of the stream was reached - ie close() was called on the
* connected PipedOutputStream.
......@@ -371,3 +380,4 @@ public class PipedInputStream extends InputStream
notifyAll();
}
}
libjava/java/io/PipedReader.java
......@@ -118,7 +118,8 @@ public class PipedReader extends Reader
}
/**
* This method connects this stream to the passed in <code>PipedWriter</code>.
* This method connects this stream to the passed in
* <code>PipedWriter</code>.
* This stream is then ready for reading. If this stream is already
* connected or has been previously closed, then an exception is thrown
*
......@@ -207,9 +208,12 @@ public class PipedReader extends Reader
/**
* This method reads chars from the stream into a caller supplied buffer.
* It starts storing chars at position <code>offset</code> into the buffer and
* reads a maximum of <code>len</code> chars. Note that this method can actually
* read fewer than <code>len</code> chars. The actual number of chars read is
* It starts storing chars at position <code>offset</code> into the
* buffer and
* reads a maximum of <code>len</code> chars. Note that this method
* can actually
* read fewer than <code>len</code> chars. The actual number of chars
* read is
* returned. A -1 is returned to indicated that no chars can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
......@@ -237,10 +241,11 @@ public class PipedReader extends Reader
}
/**
* This method reads characters from the stream into a caller supplied buffer.
* It starts storing chars at position <code>offset</code> into the buffer and
* reads a maximum of <code>len</code> chars. Note that this method can actually
* read fewer than <code>len</code> chars. The actual number of chars read is
* This method reads characters from the stream into a caller supplied
* buffer. It starts storing chars at position <code>offset</code> into
* the buffer and reads a maximum of <code>len</code> chars. Note that
* this method can actually read fewer than <code>len</code> chars.
* The actual number of chars read is
* returned. A -1 is returned to indicated that no chars can be read
* because the end of the stream was reached - ie close() was called on the
* connected PipedWriter.
......@@ -361,3 +366,4 @@ public class PipedReader extends Reader
}
}
}
libjava/java/io/PrintWriter.java
......@@ -48,8 +48,6 @@ package java.io;
* class which also auto-flushes when it encounters a newline character
* in the chars written).
*
* @version 0.0
*
* @author Per Bothner <bothner@cygnus.com>
* @author Aaron M. Renn (arenn@urbanophile.com)
* @date April 17, 1998.
......@@ -99,7 +97,8 @@ public class PrintWriter extends Writer
* every line is terminated or newline character is written.
*
* @param wr The <code>Writer</code> to write to.
* @param autoflush <code>true</code> to flush the stream after every line, <code>false</code> otherwise
* @param autoflush <code>true</code> to flush the stream after every
* line, <code>false</code> otherwise
*/
public PrintWriter(Writer wr, boolean autoflush)
{
......@@ -130,7 +129,8 @@ public class PrintWriter extends Writer
* constructor allows auto-flush functionality to be enabled if desired
*
* @param out The <code>OutputStream</code> to write to
* @param autoflush <code>true</code> to flush the stream after every <code>println</code> call, <code>false</code> otherwise.
* @param autoflush <code>true</code> to flush the stream after every
* <code>println</code> call, <code>false</code> otherwise.
*/
public PrintWriter(OutputStream out, boolean autoflush)
{
......@@ -153,7 +153,8 @@ public class PrintWriter extends Writer
* <code>true</code> forever for this stream. Before checking for an
* error condition, this method flushes the stream.
*
* @return <code>true</code> if an error has occurred, <code>false</code> otherwise
* @return <code>true</code> if an error has occurred,
* <code>false</code> otherwise
*/
public boolean checkError()
{
......@@ -309,7 +310,7 @@ public class PrintWriter extends Writer
* This is the system dependent line separator
*/
private static final char[] line_separator
= System.getProperty("line.separator").toCharArray();
= System.getProperty("line.separator").toCharArray();
/**
* This method prints a line separator sequence to the stream. The value
......@@ -567,3 +568,4 @@ public class PrintWriter extends Writer
write(str, 0, str.length());
}
}
libjava/java/io/PushbackReader.java
/* PushbackReader.java -- An character stream that can unread chars
Copyright (C) 1998, 2000, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 2000, 2001, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -48,8 +48,6 @@ package java.io;
* The default pushback buffer size one char, but this can be overridden
* by the creator of the stream.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Warren Levy <warrenl@cygnus.com>
*/
......@@ -136,7 +134,8 @@ public class PushbackReader extends FilterReader
* This method returns <code>false</code> to indicate that it does not support
* mark/reset functionality.
*
* @return This method returns <code>false</code> to indicate that this class does not support mark/reset functionality
* @return This method returns <code>false</code> to indicate that this
* class does not support mark/reset functionality
*
*/
public boolean markSupported()
......@@ -165,7 +164,8 @@ public class PushbackReader extends FilterReader
* read in the pushback buffer or if the underlying stream is ready to
* be read.
*
* @return <code>true</code> if this stream is ready to be read, <code>false</code> otherwise
* @return <code>true</code> if this stream is ready to be read,
* <code>false</code> otherwise
*
* @exception IOException If an error occurs
*/
......@@ -252,7 +252,8 @@ public class PushbackReader extends FilterReader
/**
* This method read chars from a stream and stores them into a caller
* supplied buffer. It starts storing the data at index <code>offset</code> into
* supplied buffer. It starts storing the data at index <code>offset</code>
* into
* the buffer and attempts to read <code>len</code> chars. This method can
* return before reading the number of chars requested. The actual number
* of chars read is returned as an int. A -1 is returned to indicate the
......@@ -302,8 +303,8 @@ public class PushbackReader extends FilterReader
* <p>
* If the pushback buffer is full, this method throws an exception.
* <p>
* The argument to this method is an <code>int</code>. Only the low eight bits
* of this value are pushed back.
* The argument to this method is an <code>int</code>. Only the low eight
* bits of this value are pushed back.
*
* @param b The char to be pushed back, passed as an int
*
......@@ -343,7 +344,8 @@ public class PushbackReader extends FilterReader
/**
* This method pushed back chars from the passed in array into the pushback
* buffer. The chars from <code>buf[offset]</code> to <code>buf[offset + len]</code>
* buffer. The chars from <code>buf[offset]</code> to
* <code>buf[offset + len]</code>
* are pushed in reverse order so that the next char read from the stream
* after this operation will be <code>buf[offset]</code> followed by
* <code>buf[offset + 1]</code>, etc.
......@@ -378,3 +380,4 @@ public class PushbackReader extends FilterReader
}
}
}
libjava/java/io/Reader.java
/* Reader.java -- base class of classes that read input as a stream of chars
Copyright (C) 1998, 1999, 2000 Free Software Foundation
Copyright (C) 1998, 1999, 2000, 2003 Free Software Foundation
This file is part of GNU Classpath.
......@@ -222,7 +222,8 @@ public abstract class Reader
* <p>
* This method always returns <code>false</code> in this class
*
* @return <code>true</code> if the stream is ready to be read, <code>false</code> otherwise.
* @return <code>true</code> if the stream is ready to be read,
* <code>false</code> otherwise.
*
* @exception IOException If an error occurs
*/
......
libjava/java/io/SerializablePermission.java
/* SerializablePermission.java -- Basic permissions related to serialization.
Copyright (C) 1998, 2000 Free Software Foundation, Inc.
Copyright (C) 1998, 2000, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -55,64 +55,63 @@ import java.security.BasicPermission;
*
* @see java.security.BasicPermission
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public final class SerializablePermission extends BasicPermission
{
static final long serialVersionUID = 8537212141160296410L;
/*
* Class Variables
*/
private static final String[] legal_names = { "enableSubclassImplementation",
"enableSubstitution" };
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes a new instance of <code>SerializablePermission</code>
* that has the specified name.
*
* @param name The name of the permission.
*
* @exception IllegalArgumentException If the name is not valid for this class.
*/
public
SerializablePermission(String name)
{
this(name, null);
}
/*************************************************************************/
/**
* This method initializes a new instance of <code>SerializablePermission</code>
* that has the specified name and action list. Note that the action list
* is unused in this class.
*
* @param name The name of the permission.
* @param actions The action list (unused).
*
* @exception IllegalArgumentException If the name is not valid for this class.
*/
public
SerializablePermission(String name, String actions)
{
super(name, actions);
for (int i = 0; i < legal_names.length; i++)
if (legal_names[i].equals(name))
return;
throw new IllegalArgumentException("Bad permission name: " + name);
}
/*
* Class Variables
*/
private static final String[] legal_names = { "enableSubclassImplementation",
"enableSubstitution" };
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes a new instance of
* <code>SerializablePermission</code>
* that has the specified name.
*
* @param name The name of the permission.
*
* @exception IllegalArgumentException If the name is not valid for
* this class.
*/
public SerializablePermission(String name)
{
this(name, null);
}
/*************************************************************************/
/**
* This method initializes a new instance of
* <code>SerializablePermission</code>
* that has the specified name and action list. Note that the action list
* is unused in this class.
*
* @param name The name of the permission.
* @param actions The action list (unused).
*
* @exception IllegalArgumentException If the name is not valid for
* this class.
*/
public SerializablePermission(String name, String actions)
{
super(name, actions);
for (int i = 0; i < legal_names.length; i++)
if (legal_names[i].equals(name))
return;
throw new IllegalArgumentException("Bad permission name: " + name);
}
} // class SerializablePermission
libjava/java/io/StringReader.java
/* StringReader.java -- permits a String to be read as a character input stream
Copyright (C) 1998, 1999, 2000 Free Software Foundation
Copyright (C) 1998, 1999, 2000, 2003 Free Software Foundation
This file is part of GNU Classpath.
......@@ -51,8 +51,6 @@ package java.io;
* normal. If no mark has been set, then calling the <code>reset()</code>
* method rewinds the read pointer to the beginning of the <code>String</code>.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Warren Levy <warrenl@cygnus.com>
* @date October 19, 1998.
......@@ -73,8 +71,8 @@ public class StringReader extends Reader
/**
* Create a new <code>StringReader</code> that will read chars from the
* passed in <code>String</code>. This stream will read from the beginning to the
* end of the <code>String</code>.
* passed in <code>String</code>. This stream will read from the beginning
* to the end of the <code>String</code>.
*
* @param s The <code>String</code> this stream will read from.
*/
......@@ -208,3 +206,4 @@ public class StringReader extends Reader
}
}
}
libjava/java/io/Writer.java
/* Writer.java -- Base class for character output streams
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2001, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -55,168 +55,161 @@ package java.io;
*/
public abstract class Writer
{
/*************************************************************************/
/**
* This is the object used to synchronize criticial code sections for
* thread safety. Subclasses should use this field instead of using
* synchronized methods or explicity synchronizations on <code>this</code>
*/
protected Object lock;
/*************************************************************************/
/*
* Constructors
*/
/**
* This is the default no-argument constructor for this class. This method
* will set up the class to synchronize criticial sections on itself.
*/
protected
Writer()
{
lock = this;
}
/*************************************************************************/
/**
* This method initializes a <code>Writer</code> that will synchronize
* on the specified <code>Object</code>.
*
* @param obj The <code>Object</code> to use for synchronizing critical
* sections
*/
protected
Writer(Object lock)
{
this.lock = lock;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method forces any data that may have been buffered to be written
* to the underlying output device. Please note that the host environment
* might perform its own buffering unbeknowst to Java. In that case, a
* write made (for example, to a disk drive) might be cached in OS
* buffers instead of actually being written to disk.
*
* @exception IOException If an error occurs
*/
public abstract void
flush() throws IOException;
/*************************************************************************/
/**
* This method closes the stream. Any internal or native resources associated
* with this stream are freed. Any subsequent attempt to access the stream
* might throw an exception.
* <p>
* This method in this class does nothing.
*
* @exception IOException If an error occurs
*/
public abstract void
close() throws IOException;
/*************************************************************************/
/**
* This method writes a single char to the output stream.
*
* @param b The char to be written to the output stream, passed as an int
*
* @exception IOException If an error occurs
*/
public void
write(int b) throws IOException
{
char[] buf = new char[1];
buf[0] = (char)b;
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method all the writes char from the passed array to the output stream.
* This method is equivalent to <code>write(buf, 0, buf.length)</code> which
* is exactly how it is implemented in this class.
*
* @param buf The array of char to write
*
* @exception IOException If an error occurs
*/
public void
write(char[] buf) throws IOException
{
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method writes <code>len</code> char from the specified array
* <code>buf</code> starting at index <code>offset</code> into the array.
* <p>
* Subclasses must provide an implementation of this abstract method.
*
* @param buf The array of char to write from
* @param offset The index into the array to start writing from
* @param len The number of char to write
*
* @exception IOException If an error occurs
*/
public abstract void
write(char[] buf, int offset, int len) throws IOException;
/*************************************************************************/
/**
* This method writes all the characters in a <code>String</code> to the
* output.
*
* @param str The <code>String</code> whose chars are to be written.
*
* @param IOException If an error occurs
*/
public void
write(String str) throws IOException
{
write(str, 0, str.length());
}
/*************************************************************************/
/**
* This method writes <code>len</code> chars from the <code>String</code>
* starting at position <code>offset</code>.
*
* @param str The <code>String</code> that is to be written
* @param offset The character offset into the <code>String</code> 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
{
// FIXME - for libgcj re-write using native code to not require copied buffer.
char[] buf = new char[len];
str.getChars(offset, offset + len, buf, 0);
write(buf, 0, len);
}
/**
* This is the object used to synchronize criticial code sections for
* thread safety. Subclasses should use this field instead of using
* synchronized methods or explicity synchronizations on <code>this</code>
*/
protected Object lock;
/*************************************************************************/
/*
* Constructors
*/
/**
* This is the default no-argument constructor for this class. This method
* will set up the class to synchronize criticial sections on itself.
*/
protected Writer()
{
lock = this;
}
/*************************************************************************/
/**
* This method initializes a <code>Writer</code> that will synchronize
* on the specified <code>Object</code>.
*
* @param obj The <code>Object</code> to use for synchronizing critical
* sections
*/
protected Writer(Object lock)
{
this.lock = lock;
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method forces any data that may have been buffered to be written
* to the underlying output device. Please note that the host environment
* might perform its own buffering unbeknowst to Java. In that case, a
* write made (for example, to a disk drive) might be cached in OS
* buffers instead of actually being written to disk.
*
* @exception IOException If an error occurs
*/
public abstract void flush() throws IOException;
/*************************************************************************/
/**
* This method closes the stream. Any internal or native resources
* associated
* with this stream are freed. Any subsequent attempt to access the stream
* might throw an exception.
* <p>
* This method in this class does nothing.
*
* @exception IOException If an error occurs
*/
public abstract void close() throws IOException;
/*************************************************************************/
/**
* This method writes a single char to the output stream.
*
* @param b The char to be written to the output stream, passed as an int
*
* @exception IOException If an error occurs
*/
public void write(int b) throws IOException
{
char[] buf = new char[1];
buf[0] = (char)b;
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method all the writes char from the passed array to the output
* stream. This method is equivalent to
* <code>write(buf, 0, buf.length)</code> which
* is exactly how it is implemented in this class.
*
* @param buf The array of char to write
*
* @exception IOException If an error occurs
*/
public void write(char[] buf) throws IOException
{
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method writes <code>len</code> char from the specified array
* <code>buf</code> starting at index <code>offset</code> into the array.
* <p>
* Subclasses must provide an implementation of this abstract method.
*
* @param buf The array of char to write from
* @param offset The index into the array to start writing from
* @param len The number of char to write
*
* @exception IOException If an error occurs
*/
public abstract void write(char[] buf, int offset, int len)
throws IOException;
/*************************************************************************/
/**
* This method writes all the characters in a <code>String</code> to the
* output.
*
* @param str The <code>String</code> whose chars are to be written.
*
* @param IOException If an error occurs
*/
public void write(String str) throws IOException
{
write(str, 0, str.length());
}
/*************************************************************************/
/**
* This method writes <code>len</code> chars from the <code>String</code>
* starting at position <code>offset</code>.
*
* @param str The <code>String</code> that is to be written
* @param offset The character offset into the <code>String</code> 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
{
// FIXME - for libgcj re-write using native code to not require
// copied buffer.
char[] buf = new char[len];
str.getChars(offset, offset + len, buf, 0);
write(buf, 0, len);
}
} // class Writer
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment