@deftypemethod BufferedInputStream {public synchronized int} available () @*throws IOException

@end deftypemethod
@deftypemethod BufferedInputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod BufferedInputStream {public synchronized void} mark (int@w{ }@var{readlimit}) 

@end deftypemethod
@deftypemethod BufferedInputStream {public boolean} markSupported () 

@end deftypemethod
@deftypemethod BufferedInputStream {public synchronized int} read () @*throws IOException

@end deftypemethod
@deftypemethod BufferedInputStream {public synchronized int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod BufferedInputStream {public synchronized void} reset () @*throws IOException

@end deftypemethod
@deftypemethod BufferedInputStream {public synchronized long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod BufferedOutputStream {public synchronized void} flush () @*throws IOException
This method causes any currently buffered bytes to be immediately
 written to the underlying output stream.
@end deftypemethod
@deftypemethod BufferedOutputStream {public synchronized void} write (int@w{ }@var{b}) @*throws IOException
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.
@end deftypemethod
@deftypemethod BufferedOutputStream {public synchronized void} write (byte[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method writes @code{len} bytes from the byte array 
 @code{buf} starting at position @code{offset} in the buffer. 
 These bytes will be written to the internal buffer.  However, if this
 write operation fills the buffer, the buffer will be flushed to the
 underlying output stream.
@end deftypemethod
@deftypemethod BufferedReader {public void} close () @*throws IOException
This method closes the stream
@end deftypemethod
@deftypemethod BufferedReader {public boolean} markSupported () 
Returns @code{true} to indicate that this class supports mark/reset 
 functionality.
@end deftypemethod
@deftypemethod BufferedReader {public void} mark (int@w{ }@var{readLimit}) @*throws IOException
Mark a position in the input to which the stream can be
 "reset" by calling the @code{reset()} method.  The parameter
 @code{readlimit} is the number of chars that can be read from the 
 stream after setting the mark before the mark becomes invalid.  For
 example, if @code{mark()} is called with a read limit of 10, then 
 when 11 chars of data are read from the stream before the 
 @code{reset()} method is called, then the mark is invalid and the 
 stream object instance is not required to remember the mark.
 


 Note that the number of chars that can be remembered by this method
 can be greater than the size of the internal read buffer.  It is also
 not dependent on the subordinate stream supporting mark/reset
 functionality.
@end deftypemethod
@deftypemethod BufferedReader {public void} reset () @*throws IOException
Reset the stream to the point where the @code{mark()} method
 was called.  Any chars that were read after the mark point was set will
 be re-read during subsequent reads.
 


 This method will throw an IOException if the number of chars read from
 the stream since the call to @code{mark()} exceeds the mark limit
 passed when establishing the mark.
@end deftypemethod
@deftypemethod BufferedReader {public boolean} ready () @*throws IOException
This method determines whether or not a stream is ready to be read.  If
 This method returns @code{false} then this stream could (but is
 not guaranteed to) block on the next read attempt.
@end deftypemethod
@deftypemethod BufferedReader {public int} read (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException
This method read chars from a stream and stores them into a caller
 supplied buffer.  It starts storing the data at index @code{offset} into
 the buffer and attempts to read @code{len} 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
 end of the stream.
 


 This method will block until some data can be read.
@end deftypemethod
@deftypemethod BufferedReader {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod BufferedReader {public String} readLine () @*throws IOException
This method reads a single line of text from the input stream, returning
 it as a @code{String}.  A line is terminated by "\n", a "\r", or
 an "\r\n" sequence.  The system dependent line separator is not used.
 The line termination characters are not returned in the resulting
 @code{String}.
@end deftypemethod
@deftypemethod BufferedReader {public long} skip (long@w{ }@var{count}) @*throws IOException
This method skips the specified number of chars in the stream.  It
 returns the actual number of chars skipped, which may be less than the
 requested amount.
 


 This method first discards chars in the buffer, then calls the
 @code{skip} method on the underlying stream to skip the remaining chars.
@end deftypemethod
@deftypemethod BufferedWriter {public void} close () @*throws IOException
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
@end deftypemethod
@deftypemethod BufferedWriter {public void} flush () @*throws IOException
This method causes any currently buffered chars to be immediately
 written to the underlying output stream.
@end deftypemethod
@deftypemethod BufferedWriter {public void} newLine () @*throws IOException
This method writes out a system depedent line separator sequence.  The
 actual value written is detemined from the <xmp>line.separator</xmp>
 system property.
@end deftypemethod
@deftypemethod BufferedWriter {public void} write (int@w{ }@var{oneChar}) @*throws IOException
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.
@end deftypemethod
@deftypemethod BufferedWriter {public void} write (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method writes @code{len} chars from the char array 
 @code{buf} starting at position @code{offset} in the buffer. 
 These chars will be written to the internal buffer.  However, if this
 write operation fills the buffer, the buffer will be flushed to the
 underlying output stream.
@end deftypemethod
@deftypemethod BufferedWriter {public void} write (java.lang.String@w{ }@var{str}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method writes @code{len} chars from the @code{String}
 @code{str} starting at position @code{offset} in the string. 
 These chars will be written to the internal buffer.  However, if this
 write operation fills the buffer, the buffer will be flushed to the
 underlying output stream.
@end deftypemethod
@deftypemethod ByteArrayInputStream {public synchronized int} available () 

@end deftypemethod
@deftypemethod ByteArrayInputStream {public synchronized void} mark (int@w{ }@var{readAheadLimit}) 

@end deftypemethod
@deftypemethod ByteArrayInputStream {public boolean} markSupported () 

@end deftypemethod
@deftypemethod ByteArrayInputStream {public synchronized int} read () 

@end deftypemethod
@deftypemethod ByteArrayInputStream {public synchronized int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) 

@end deftypemethod
@deftypemethod ByteArrayInputStream {public synchronized void} reset () 

@end deftypemethod
@deftypemethod ByteArrayInputStream {public synchronized long} skip (long@w{ }@var{n}) 

@end deftypemethod
@deftypemethod ByteArrayOutputStream {public synchronized void} reset () 
This method discards all of the bytes that have been written to
 the internal buffer so far by setting the @code{count}
 variable to 0.  The internal buffer remains at its currently
 allocated size.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public int} size () 
This method returns the number of bytes that have been written to
 the buffer so far.  This is the same as the value of the protected
 @code{count} variable.  If the @code{reset} method is
 called, then this value is reset as well.  Note that this method does
 not return the length of the internal buffer, but only the number
 of bytes that have been written to it.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public synchronized byte} toByteArray () 
This method returns a byte array containing the bytes that have been
 written to this stream so far.  This array is a copy of the valid
 bytes in the internal buffer and its length is equal to the number of
 valid bytes, not necessarily to the the length of the current 
 internal buffer.  Note that since this method allocates a new array,
 it should be used with caution when the internal buffer is very large.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public String} toString () 
Returns the bytes in the internal array as a @code{String}.  The
 bytes in the buffer are converted to characters using the system default
 encoding.  There is an overloaded @code{toString()} method that
 allows an application specified character encoding to be used.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public String} toString (java.lang.String@w{ }@var{enc}) @*throws UnsupportedEncodingException
Returns the bytes in the internal array as a @code{String}.  The
 bytes in the buffer are converted to characters using the specified
 encoding.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public String} toString (int@w{ }@var{hibyte}) 
This method returns the bytes in the internal array as a
 @code{String}.  It uses each byte in the array as the low
 order eight bits of the Unicode character value and the passed in
 parameter as the high eight bits.
 


 This method does not convert bytes to characters in the proper way and
 so is deprecated in favor of the other overloaded @code{toString}
 methods which use a true character encoding.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public synchronized void} write (int@w{ }@var{oneByte}) 
This method writes the writes the specified byte into the internal
 buffer.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public synchronized void} write (byte[]@w{ }@var{buffer}, int@w{ }@var{offset}, int@w{ }@var{add}) 
This method writes @code{len} bytes from the passed in array 
 @code{buf} starting at index @code{offset} into the
 internal buffer.
@end deftypemethod
@deftypemethod ByteArrayOutputStream {public synchronized void} writeTo (java.io.OutputStream@w{ }@var{out}) @*throws IOException
This method writes all the bytes that have been written to this stream
 from the internal buffer to the specified @code{OutputStream}.
@end deftypemethod
@deftypemethod CharArrayReader {public void} close () 

@end deftypemethod
@deftypemethod CharArrayReader {public void} mark (int@w{ }@var{readAheadLimit}) 

@end deftypemethod
@deftypemethod CharArrayReader {public boolean} markSupported () 

@end deftypemethod
@deftypemethod CharArrayReader {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod CharArrayReader {public int} read (char[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod CharArrayReader {public boolean} ready () @*throws IOException

@end deftypemethod
@deftypemethod CharArrayReader {public void} reset () @*throws IOException

@end deftypemethod
@deftypemethod CharArrayReader {public long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod CharArrayWriter {public void} close () 

@end deftypemethod
@deftypemethod CharArrayWriter {public void} flush () 

@end deftypemethod
@deftypemethod CharArrayWriter {public synchronized void} reset () 

@end deftypemethod
@deftypemethod CharArrayWriter {public int} size () 

@end deftypemethod
@deftypemethod CharArrayWriter {public char} toCharArray () 

@end deftypemethod
@deftypemethod CharArrayWriter {public String} toString () 

@end deftypemethod
@deftypemethod CharArrayWriter {public void} write (int@w{ }@var{oneChar}) 

@end deftypemethod
@deftypemethod CharArrayWriter {public void} write (char[]@w{ }@var{buffer}, int@w{ }@var{offset}, int@w{ }@var{len}) 

@end deftypemethod
@deftypemethod CharArrayWriter {public void} write (java.lang.String@w{ }@var{str}, int@w{ }@var{offset}, int@w{ }@var{len}) 

@end deftypemethod
@deftypemethod CharArrayWriter {public void} writeTo (java.io.Writer@w{ }@var{out}) @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public boolean} readBoolean () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public byte} readByte () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public char} readChar () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public double} readDouble () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public float} readFloat () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public void} readFully (byte[]@w{ }@var{b}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod DataInput {public void} readFully (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException, NullPointerException, IndexOutOfBoundsException

@end deftypemethod
@deftypemethod DataInput {public int} readInt () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public String} readLine () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public long} readLong () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public short} readShort () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public int} readUnsignedByte () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public int} readUnsignedShort () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public String} readUTF () @*throws IOException

@end deftypemethod
@deftypemethod DataInput {public int} skipBytes (int@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod DataInputStream {public final int} read (byte[]@w{ }@var{b}) @*throws IOException
This method reads bytes from the underlying stream into the specified
 byte array buffer.  It will attempt to fill the buffer completely, but
 may return a short count if there is insufficient data remaining to be
 read to fill the buffer.
@end deftypemethod
@deftypemethod DataInputStream {public final int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException
This method reads bytes from the underlying stream into the specified
 byte array buffer.  It will attempt to read @code{len} bytes and
 will start storing them at position @code{off} into the buffer.
 This method can return a short count if there is insufficient data
 remaining to be read to complete the desired read length.
@end deftypemethod
@deftypemethod DataInputStream {public final boolean} readBoolean () @*throws IOException
This method reads a Java boolean value from an input stream.  It does
 so by reading a single byte of data.  If that byte is zero, then the
 value returned is @code{false}.  If the byte is non-zero, then
 the value returned is @code{true}.
 


 This method can read a @code{boolean} written by an object
 implementing the @code{writeBoolean()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final byte} readByte () @*throws IOException
This method reads a Java byte value from an input stream.  The value
 is in the range of -128 to 127.
 


 This method can read a @code{byte} written by an object
 implementing the @code{writeByte()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final char} readChar () @*throws IOException
This method reads a Java @code{char} value from an input stream.  
 It operates by reading two bytes from the stream and converting them to 
 a single 16-bit Java @code{char}.  The two bytes are stored most
 significant byte first (i.e., "big endian") regardless of the native
 host byte ordering. 
 


 As an example, if @code{byte1} and @code{byte2}
 represent the first and second byte read from the stream
 respectively, they will be transformed to a @code{char} in
 the following manner: 
 


 @code{(char)(((byte1 & 0xFF) << 8) | (byte2 & 0xFF)}
 


 This method can read a @code{char} written by an object
 implementing the @code{writeChar()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final double} readDouble () @*throws IOException
This method reads a Java double value from an input stream.  It operates
 by first reading a @code{long} value from the stream by calling the
 @code{readLong()} method in this interface, then converts
 that @code{long} to a @code{double} using the
 @code{longBitsToDouble} method in the class
 @code{java.lang.Double} 
 


 This method can read a @code{double} written by an object
 implementing the @code{writeDouble()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final float} readFloat () @*throws IOException
This method reads a Java float value from an input stream.  It
 operates by first reading an @code{int} value from the
 stream by calling the @code{readInt()} method in this
 interface, then converts that @code{int} to a
 @code{float} using the @code{intBitsToFloat} method
 in the class @code{java.lang.Float}
 


 This method can read a @code{float} written by an object
 implementing the * @code{writeFloat()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final void} readFully (byte[]@w{ }@var{b}) @*throws IOException
This method reads raw bytes into the passed array until the array is
 full.  Note that this method blocks until the data is available and
 throws an exception if there is not enough data left in the stream to
 fill the buffer
@end deftypemethod
@deftypemethod DataInputStream {public final void} readFully (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException
This method reads raw bytes into the passed array
 @code{buf} starting @code{offset} bytes into the
 buffer.  The number of bytes read will be exactly
 @code{len} Note that this method blocks until the data is
 available and * throws an exception if there is not enough data
 left in the stream to read @code{len} bytes.
@end deftypemethod
@deftypemethod DataInputStream {public final int} readInt () @*throws IOException
This method reads a Java @code{int} value from an input
 stream It operates by reading four bytes from the stream and
 converting them to a single Java @code{int} The bytes are
 stored most significant byte first (i.e., "big endian")
 regardless of the native host byte ordering.
 


 As an example, if @code{byte1} through @code{byte4}
 represent the first four bytes read from the stream, they will be
 transformed to an @code{int} in the following manner:
 


 @code{(int)(((byte1 & 0xFF) << 24) + ((byte2 & 0xFF) << 16) + 
 ((byte3 & 0xFF) << 8) + (byte4 & 0xFF)))}
 


 The value returned is in the range of 0 to 65535.
 


 This method can read an @code{int} written by an object
 implementing the @code{writeInt()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final String} readLine () @*throws IOException
This method reads the next line of text data from an input
 stream.  It operates by reading bytes and converting those bytes
 to @code{char} values by treating the byte read as the low
 eight bits of the @code{char} and using 0 as the high eight
 bits.  Because of this, it does not support the full 16-bit
 Unicode character set.
 


 The reading of bytes ends when either the end of file or a line
 terminator is encountered.  The bytes read are then returned as a
 @code{String} A line terminator is a byte sequence
 consisting of either @code{\r}, @code{\n} or
 @code{\r\n}.  These termination charaters are discarded and
 are not returned as part of the string.
 


 This method can read data that was written by an object implementing the
 @code{writeLine()} method in @code{DataOutput}.
@end deftypemethod
@deftypemethod DataInputStream {public final long} readLong () @*throws IOException
This method reads a Java long value from an input stream
 It operates by reading eight bytes from the stream and converting them to 
 a single Java @code{long}  The bytes are stored most
 significant byte first (i.e., "big endian") regardless of the native
 host byte ordering. 
 


 As an example, if @code{byte1} through @code{byte8}
 represent the first eight bytes read from the stream, they will
 be transformed to an @code{long} in the following manner:
 


 @code{(long)((((long)byte1 & 0xFF) << 56) + (((long)byte2 & 0xFF) << 48) + 
 (((long)byte3 & 0xFF) << 40) + (((long)byte4 & 0xFF) << 32) + 
 (((long)byte5 & 0xFF) << 24) + (((long)byte6 & 0xFF) << 16) + 
 (((long)byte7 & 0xFF) << 8) + ((long)byte9 & 0xFF)))}
 


 The value returned is in the range of 0 to 65535.
 


 This method can read an @code{long} written by an object
 implementing the @code{writeLong()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final short} readShort () @*throws IOException
This method reads a signed 16-bit value into a Java in from the
 stream.  It operates by reading two bytes from the stream and
 converting them to a single 16-bit Java @code{short}.  The
 two bytes are stored most significant byte first (i.e., "big
 endian") regardless of the native host byte ordering.
 


 As an example, if @code{byte1} and @code{byte2}
 represent the first and second byte read from the stream
 respectively, they will be transformed to a @code{short}. in
 the following manner:
 


 @code{(short)(((byte1 & 0xFF) << 8) | (byte2 & 0xFF)}
 


 The value returned is in the range of -32768 to 32767.
 


 This method can read a @code{short} written by an object
 implementing the @code{writeShort()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final int} readUnsignedByte () @*throws IOException
This method reads 8 unsigned bits into a Java @code{int}
 value from the stream. The value returned is in the range of 0 to
 255.
 


 This method can read an unsigned byte written by an object
 implementing the @code{writeUnsignedByte()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final int} readUnsignedShort () @*throws IOException
This method reads 16 unsigned bits into a Java int value from the stream.
 It operates by reading two bytes from the stream and converting them to 
 a single Java @code{int}  The two bytes are stored most
 significant byte first (i.e., "big endian") regardless of the native
 host byte ordering. 
 


 As an example, if @code{byte1} and @code{byte2}
 represent the first and second byte read from the stream
 respectively, they will be transformed to an @code{int} in
 the following manner:
 


 @code{(int)(((byte1 & 0xFF) << 8) + (byte2 & 0xFF))}
 


 The value returned is in the range of 0 to 65535.
 


 This method can read an unsigned short written by an object
 implementing the @code{writeUnsignedShort()} method in the
 @code{DataOutput} interface.
@end deftypemethod
@deftypemethod DataInputStream {public final String} readUTF () @*throws IOException
This method reads a @code{String} from an input stream that
 is encoded in a modified UTF-8 format.  This format has a leading
 two byte sequence that contains the remaining number of bytes to
 read.  This two byte sequence is read using the
 @code{readUnsignedShort()} method of this interface.
 


 After the number of remaining bytes have been determined, these
 bytes are read an transformed into @code{char} values.
 These @code{char} values are encoded in the stream using
 either a one, two, or three byte format.  The particular format
 in use can be determined by examining the first byte read.
 


 If the first byte has a high order bit of 0, then that character
 consists on only one byte.  This character value consists of
 seven bits that are at positions 0 through 6 of the byte.  As an
 example, if @code{byte1} is the byte read from the stream,
 it would be converted to a @code{char} like so:
 


 @code{(char)byte1}
 


 If the first byte has 110 as its high order bits, then the 
 character consists of two bytes.  The bits that make up the character
 value are in positions 0 through 4 of the first byte and bit positions
 0 through 5 of the second byte.  (The second byte should have 
 10 as its high order bits).  These values are in most significant
 byte first (i.e., "big endian") order.
 


 As an example, if @code{byte1} and @code{byte2} are
 the first two bytes read respectively, and the high order bits of
 them match the patterns which indicate a two byte character
 encoding, then they would be converted to a Java
 @code{char} like so:
 


 @code{(char)(((byte1 & 0x1F) << 6) | (byte2 & 0x3F))}
 


 If the first byte has a 1110 as its high order bits, then the
 character consists of three bytes.  The bits that make up the character
 value are in positions 0 through 3 of the first byte and bit positions
 0 through 5 of the other two bytes.  (The second and third bytes should
 have 10 as their high order bits).  These values are in most
 significant byte first (i.e., "big endian") order.
 


 As an example, if @code{byte1} @code{byte2} and
 @code{byte3} are the three bytes read, and the high order
 bits of them match the patterns which indicate a three byte
 character encoding, then they would be converted to a Java
 @code{char} like so:
 


 @code{(char)(((byte1 & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F))}
 


 Note that all characters are encoded in the method that requires
 the fewest number of bytes with the exception of the character
 with the value of @code{&#92;u0000} which is encoded as two
 bytes.  This is a modification of the UTF standard used to
 prevent C language style @code{NUL} values from appearing
 in the byte stream.
 


 This method can read data that was written by an object implementing the
 @code{writeUTF()} method in @code{DataOutput}
@end deftypemethod
@deftypemethod DataInputStream {public static final String} readUTF (java.io.DataInput@w{ }@var{in}) @*throws IOException
This method reads a String encoded in UTF-8 format from the 
 specified @code{DataInput} source.
@end deftypemethod
@deftypemethod DataInputStream {public final int} skipBytes (int@w{ }@var{n}) @*throws IOException
This method attempts to skip and discard the specified number of bytes 
 in the input stream.  It may actually skip fewer bytes than requested. 
 This method will not skip any bytes if passed a negative number of bytes 
 to skip.
@end deftypemethod
@deftypemethod DataOutput {public void} write (int@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} write (byte[]@w{ }@var{b}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod DataOutput {public void} write (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException, NullPointerException, IndexOutOfBoundsException

@end deftypemethod
@deftypemethod DataOutput {public void} writeBoolean (boolean@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeByte (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeShort (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeChar (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeInt (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeLong (long@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeFloat (float@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeDouble (double@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutput {public void} writeBytes (java.lang.String@w{ }@var{s}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod DataOutput {public void} writeChars (java.lang.String@w{ }@var{s}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod DataOutput {public void} writeUTF (java.lang.String@w{ }@var{s}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod DataOutputStream {public void} flush () @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final int} size () 

@end deftypemethod
@deftypemethod DataOutputStream {public synchronized void} write (int@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public synchronized void} write (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException, NullPointerException, IndexOutOfBoundsException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeBoolean (boolean@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeByte (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeShort (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeChar (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeInt (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeLong (long@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeFloat (float@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeDouble (double@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeBytes (java.lang.String@w{ }@var{s}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeChars (java.lang.String@w{ }@var{s}) @*throws IOException

@end deftypemethod
@deftypemethod DataOutputStream {public final void} writeUTF (java.lang.String@w{ }@var{s}) @*throws IOException

@end deftypemethod
@deftypemethod Externalizable {public void} readExternal (java.io.ObjectInput@w{ }@var{in}) @*throws ClassNotFoundException, IOException
This method restores an object's state by reading in the instance data
 for the object from the passed in stream.  Note that this stream is not
 a subclass of @code{InputStream}, but rather is a class that implements
 the @code{ObjectInput} interface.  That interface provides a mechanism for
 reading in Java data types from a stream.
 


 Note that this method must be compatible with @code{writeExternal}.
 It must read back the exact same types that were written by that
 method in the exact order they were written.
 


 If this method needs to read back an object instance, then the class
 for that object must be found and loaded.  If that operation fails,
 then this method throws a @code{ClassNotFoundException}
@end deftypemethod
@deftypemethod Externalizable {public void} writeExternal (java.io.ObjectOutput@w{ }@var{out}) @*throws IOException
This method is responsible for writing the instance data of an object
 to the passed in stream.  Note that this stream is not a subclass of
 @code{OutputStream}, but rather is a class that implements the
 @code{ObjectOutput} interface.  That interface provides a number of methods
 for writing Java data values to a stream.
 


 Not that the implementation of this method must be coordinated with
 the implementation of @code{readExternal}.
@end deftypemethod
@deftypemethod FileDescriptor {public native void} sync () @*throws SyncFailedException

@end deftypemethod
@deftypemethod FileDescriptor {public native boolean} valid () 

@end deftypemethod
@deftypemethod FileDescriptor {protected void} finalize () @*throws IOException

@end deftypemethod
@deftypemethod FileFilter {public boolean} accept (java.io.File@w{ }@var{pathname}) 
This method determines whether or not a given pathname should be included
 in a pathname listing.
@end deftypemethod
@deftypemethod FileInputStream {public int} available () @*throws IOException

@end deftypemethod
@deftypemethod FileInputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod FileInputStream {protected void} finalize () @*throws IOException

@end deftypemethod
@deftypemethod FileInputStream {public final FileDescriptor} getFD () @*throws IOException

@end deftypemethod
@deftypemethod FileInputStream {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod FileInputStream {public int} read (byte[]@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod FileInputStream {public int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod FileInputStream {public long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod File {public boolean} canRead () 

@end deftypemethod
@deftypemethod File {public boolean} canWrite () 

@end deftypemethod
@deftypemethod File {public boolean} delete () 

@end deftypemethod
@deftypemethod File {public boolean} equals (java.lang.Object@w{ }@var{obj}) 

@end deftypemethod
@deftypemethod File {public boolean} exists () 

@end deftypemethod
@deftypemethod File {public String} getAbsolutePath () 

@end deftypemethod
@deftypemethod File {public native String} getCanonicalPath () @*throws IOException

@end deftypemethod
@deftypemethod File {public String} getName () 

@end deftypemethod
@deftypemethod File {public String} getParent () 

@end deftypemethod
@deftypemethod File {public File} getParentFile () 

@end deftypemethod
@deftypemethod File {public String} getPath () 

@end deftypemethod
@deftypemethod File {public int} hashCode () 

@end deftypemethod
@deftypemethod File {public native boolean} isAbsolute () 

@end deftypemethod
@deftypemethod File {public boolean} isDirectory () 

@end deftypemethod
@deftypemethod File {public boolean} isFile () 

@end deftypemethod
@deftypemethod File {public long} lastModified () 

@end deftypemethod
@deftypemethod File {public long} length () 

@end deftypemethod
@deftypemethod File {public String} list (java.io.FilenameFilter@w{ }@var{filter}) 

@end deftypemethod
@deftypemethod File {public String} list () 

@end deftypemethod
@deftypemethod File {public String} toString () 

@end deftypemethod
@deftypemethod File {public boolean} mkdir () 

@end deftypemethod
@deftypemethod File {public boolean} mkdirs () 

@end deftypemethod
@deftypemethod File {public static File} createTempFile (java.lang.String@w{ }@var{prefix}, java.lang.String@w{ }@var{suffix}, java.io.File@w{ }@var{directory}) @*throws IOException

@end deftypemethod
@deftypemethod File {public static File} createTempFile (java.lang.String@w{ }@var{prefix}, java.lang.String@w{ }@var{suffix}) @*throws IOException

@end deftypemethod
@deftypemethod File {public boolean} renameTo (java.io.File@w{ }@var{dest}) 

@end deftypemethod
@deftypemethod File {public void} deleteOnExit () 

@end deftypemethod
@deftypemethod FilenameFilter {public boolean} accept (java.io.File@w{ }@var{dir}, java.lang.String@w{ }@var{name}) 

@end deftypemethod
@deftypemethod FileOutputStream {protected void} finalize () @*throws IOException

@end deftypemethod
@deftypemethod FileOutputStream {public final FileDescriptor} getFD () @*throws IOException

@end deftypemethod
@deftypemethod FileOutputStream {public void} write (int@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod FileOutputStream {public void} write (byte[]@w{ }@var{b}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod FileOutputStream {public void} write (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException, NullPointerException, IndexOutOfBoundsException

@end deftypemethod
@deftypemethod FileOutputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod FilePermission {public String} getActions () 
Get the actions this FilePermission supports.
@end deftypemethod
@deftypemethod FilePermission {public int} hashCode () 
Get the hash code for this Object.


 FilePermission's hash code is calculated as the exclusive or of the target
 String's hash code and the action String's hash code.
@end deftypemethod
@deftypemethod FilePermission {public boolean} equals (java.lang.Object@w{ }@var{o}) 
Check two FilePermissions for semantic equality.
 Two FilePermissions are exactly equivalent if they have identical path
 expressions and have exactly the same access permissions.
@end deftypemethod
@deftypemethod FilePermission {public boolean} implies (java.security.Permission@w{ }@var{p}) 
Check to see if this permission implies another.
 Permission A implies permission B if these things are all true:
 
@itemize @bullet

 
@item
A and B are both FilePermissions.

 
@item
All possible files in B are included in A (possibly more are in A).

 
@item
All actions B supports, A also supports.

 
@end itemize

@end deftypemethod
@deftypemethod FilterInputStream {public int} available () @*throws IOException

@end deftypemethod
@deftypemethod FilterInputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod FilterInputStream {public synchronized void} mark (int@w{ }@var{readlimit}) 

@end deftypemethod
@deftypemethod FilterInputStream {public boolean} markSupported () 

@end deftypemethod
@deftypemethod FilterInputStream {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod FilterInputStream {public int} read (byte[]@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod FilterInputStream {public int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod FilterInputStream {public synchronized void} reset () @*throws IOException

@end deftypemethod
@deftypemethod FilterInputStream {public long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod FilterOutputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod FilterOutputStream {public void} flush () @*throws IOException

@end deftypemethod
@deftypemethod FilterOutputStream {public void} write (int@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod FilterOutputStream {public void} write (byte[]@w{ }@var{b}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod FilterOutputStream {public void} write (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException, NullPointerException, IndexOutOfBoundsException

@end deftypemethod
@deftypemethod FilterReader {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod FilterReader {public synchronized void} mark (int@w{ }@var{readlimit}) @*throws IOException

@end deftypemethod
@deftypemethod FilterReader {public boolean} markSupported () 

@end deftypemethod
@deftypemethod FilterReader {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod FilterReader {public int} read (char[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod FilterReader {public boolean} ready () @*throws IOException

@end deftypemethod
@deftypemethod FilterReader {public synchronized void} reset () @*throws IOException

@end deftypemethod
@deftypemethod FilterReader {public long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod FilterWriter {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod FilterWriter {public void} flush () @*throws IOException

@end deftypemethod
@deftypemethod FilterWriter {public void} write (int@w{ }@var{oneChar}) @*throws IOException

@end deftypemethod
@deftypemethod FilterWriter {public void} write (char[]@w{ }@var{buffer}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod FilterWriter {public void} write (java.lang.String@w{ }@var{str}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod InputStream {public int} available () @*throws IOException

@end deftypemethod
@deftypemethod InputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod InputStream {public void} mark (int@w{ }@var{readlimit}) 

@end deftypemethod
@deftypemethod InputStream {public boolean} markSupported () 

@end deftypemethod
@deftypemethod InputStream {public abstract int} read () @*throws IOException

@end deftypemethod
@deftypemethod InputStream {public int} read (byte[]@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod InputStream {public int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod InputStream {public void} reset () @*throws IOException

@end deftypemethod
@deftypemethod InputStream {public long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod InputStreamReader {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod InputStreamReader {public String} getEncoding () 

@end deftypemethod
@deftypemethod InputStreamReader {public boolean} ready () @*throws IOException

@end deftypemethod
@deftypemethod InputStreamReader {public int} read (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{length}) @*throws IOException

@end deftypemethod
@deftypemethod InputStreamReader {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod InvalidClassException {public String} getMessage () 
Returns the descriptive error message for this exception.  It will
 include the class name that caused the problem if known.  This method
 overrides Throwable.getMessage()
@end deftypemethod
@deftypemethod LineNumberInputStream {public int} available () @*throws IOException

@end deftypemethod
@deftypemethod LineNumberInputStream {public int} getLineNumber () 

@end deftypemethod
@deftypemethod LineNumberInputStream {public void} mark (int@w{ }@var{readlimit}) 

@end deftypemethod
@deftypemethod LineNumberInputStream {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod LineNumberInputStream {public int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod LineNumberInputStream {public void} reset () @*throws IOException

@end deftypemethod
@deftypemethod LineNumberInputStream {public void} setLineNumber (int@w{ }@var{lineNumber}) 

@end deftypemethod
@deftypemethod LineNumberInputStream {public long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod LineNumberReader {public int} getLineNumber () 

@end deftypemethod
@deftypemethod LineNumberReader {public void} setLineNumber (int@w{ }@var{lineNumber}) 

@end deftypemethod
@deftypemethod LineNumberReader {public void} mark (int@w{ }@var{readLimit}) @*throws IOException

@end deftypemethod
@deftypemethod LineNumberReader {public void} reset () @*throws IOException

@end deftypemethod
@deftypemethod LineNumberReader {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod LineNumberReader {public int} read (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod LineNumberReader {public String} readLine () @*throws IOException

@end deftypemethod
@deftypemethod LineNumberReader {public long} skip (long@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectInput {public int} available () @*throws IOException
This method returns the number of bytes that can be read without
 blocking.
@end deftypemethod
@deftypemethod ObjectInput {public int} read () @*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.
@end deftypemethod
@deftypemethod ObjectInput {public int} read (byte[]@w{ }@var{buf}) @*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.
@end deftypemethod
@deftypemethod ObjectInput {public int} read (byte[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method reads raw bytes and stores them in a byte array buffer
 @code{buf} starting at position @code{offset} into the buffer.  A 
 maximum of @code{len} 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} bytes of data.  That is, a "short count" is
 possible.
@end deftypemethod
@deftypemethod ObjectInput {public Object} readObject () @*throws ClassNotFoundException, 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.
@end deftypemethod
@deftypemethod ObjectInput {public long} skip (long@w{ }@var{num_bytes}) @*throws 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.
@end deftypemethod
@deftypemethod ObjectInput {public void} close () @*throws IOException
This method closes the input source
@end deftypemethod
@deftypemethod ObjectInputStream {public final Object} readObject () @*throws ClassNotFoundException, IOException
Returns the next deserialized object read from the underlying stream.

This method can be overriden by a class by implementing
@code{private void readObject (ObjectInputStream)}.

If an exception is thrown from this method, the stream is left in
an undefined state.
@end deftypemethod
@deftypemethod ObjectInputStream {public void} defaultReadObject () @*throws ClassNotFoundException, IOException, NotActiveException
Reads the current objects non-transient, non-static fields from
the current class from the underlying output stream.

This method is intended to be called from within a object's
@code{private void readObject (ObjectInputStream)}
method.
@end deftypemethod
@deftypemethod ObjectInputStream {public void} registerValidation (java.io.ObjectInputValidation@w{ }@var{validator}, int@w{ }@var{priority}) @*throws InvalidObjectException, NotActiveException
Registers a @code{ObjectInputValidation} to be carried out
on the object graph currently being deserialized before it is
returned to the original caller of @code{readObject ()}.
The order of validation for multiple
@code{ObjectInputValidation}s can be controled using
@code{priority}.  Validators with higher priorities are
called first.
@end deftypemethod
@deftypemethod ObjectInputStream {protected Class} resolveClass (java.io.ObjectStreamClass@w{ }@var{osc}) @*throws ClassNotFoundException, IOException
Called when a class is being deserialized.  This is a hook to
allow subclasses to read in information written by the
@code{annotateClass (Class)} method of an
@code{ObjectOutputStream}.

This implementation looks up the active call stack for a
@code{ClassLoader}; if a @code{ClassLoader} is found,
it is used to load the class associated with @code{osc},
otherwise, the default system @code{ClassLoader} is used.
@end deftypemethod
@deftypemethod ObjectInputStream {protected Object} resolveObject (java.lang.Object@w{ }@var{obj}) @*throws IOException
Allows subclasses to resolve objects that are read from the
stream with other objects to be returned in their place.  This
method is called the first time each object is encountered.

This method must be enabled before it will be called in the
serialization process.
@end deftypemethod
@deftypemethod ObjectInputStream {protected boolean} enableResolveObject (boolean@w{ }@var{enable}) @*throws SecurityException
If @code{enable} is @code{true} and this object is
trusted, then @code{resolveObject (Object)} will be called
in subsequent calls to @code{readObject (Object)}.
Otherwise, @code{resolveObject (Object)} will not be called.
@end deftypemethod
@deftypemethod ObjectInputStream {protected void} readStreamHeader () @*throws IOException, StreamCorruptedException
Reads stream magic and stream version information from the
underlying stream.
@end deftypemethod
@deftypemethod ObjectInputStream {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public int} read (byte[]@w{ }@var{data}, int@w{ }@var{offset}, int@w{ }@var{length}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public int} available () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public boolean} readBoolean () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public byte} readByte () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public int} readUnsignedByte () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public short} readShort () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public int} readUnsignedShort () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public char} readChar () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public int} readInt () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public long} readLong () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public float} readFloat () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public double} readDouble () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public void} readFully (byte[]@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public void} readFully (byte[]@w{ }@var{data}, int@w{ }@var{offset}, int@w{ }@var{size}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public int} skipBytes (int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public String} readLine () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public String} readUTF () @*throws IOException

@end deftypemethod
@deftypemethod ObjectInputStream {public ObjectInputStream.GetField} readFields () @*throws IOException, ClassNotFoundException, NotActiveException

@end deftypemethod
@deftypemethod ObjectInputStream {protected Object} readObjectOverride () @*throws ClassNotFoundException, IOException, OptionalDataException
This method allows subclasses to override the default
de serialization mechanism provided by
@code{ObjectInputStream}.  To make this method be used for
writing objects, subclasses must invoke the 0-argument
constructor on this class from there constructor.
@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract ObjectStreamClass} getObjectStreamClass () 

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract boolean} defaulted (java.lang.String@w{ }@var{name}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract boolean} get (java.lang.String@w{ }@var{name}, boolean@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract char} get (java.lang.String@w{ }@var{name}, char@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract byte} get (java.lang.String@w{ }@var{name}, byte@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract short} get (java.lang.String@w{ }@var{name}, short@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract int} get (java.lang.String@w{ }@var{name}, int@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract long} get (java.lang.String@w{ }@var{name}, long@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract float} get (java.lang.String@w{ }@var{name}, float@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract double} get (java.lang.String@w{ }@var{name}, double@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputStream.GetField {public abstract Object} get (java.lang.String@w{ }@var{name}, java.lang.Object@w{ }@var{defvalue}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectInputValidation {public void} validateObject () @*throws InvalidObjectException
This method is called to validate an object.  If the object is invalid
 an exception is thrown.
@end deftypemethod
@deftypemethod ObjectOutput {public void} write (int@w{ }@var{b}) @*throws IOException
This method writes the specified byte to the output stream.
@end deftypemethod
@deftypemethod ObjectOutput {public void} write (byte[]@w{ }@var{buf}) @*throws IOException
This method writes all the bytes in the specified byte array to the
 output stream.
@end deftypemethod
@deftypemethod ObjectOutput {public void} write (byte[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method writes @code{len} bytes from the specified array
 starting at index @code{offset} into that array.
@end deftypemethod
@deftypemethod ObjectOutput {public void} writeObject (java.lang.Object@w{ }@var{obj}) @*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
@end deftypemethod
@deftypemethod ObjectOutput {public void} flush () @*throws IOException
This method causes any buffered data to be flushed out to the underlying
 stream
@end deftypemethod
@deftypemethod ObjectOutput {public void} close () @*throws IOException
This method closes the underlying stream.
@end deftypemethod
@deftypemethod ObjectOutputStream {public final void} writeObject (java.lang.Object@w{ }@var{obj}) @*throws IOException
Writes a representation of @code{obj} to the underlying
output stream by writing out information about its class, then
writing out each of the objects non-transient, non-static
fields.  If any of these fields are other objects,
they are written out in the same manner.

This method can be overriden by a class by implementing
@code{private void writeObject (ObjectOutputStream)}.

If an exception is thrown from this method, the stream is left in
an undefined state.
@end deftypemethod
@deftypemethod ObjectOutputStream {public void} defaultWriteObject () @*throws IOException, NotActiveException
Writes the current objects non-transient, non-static fields from
the current class to the underlying output stream.

This method is intended to be called from within a object's
@code{private void writeObject (ObjectOutputStream)}
method.
@end deftypemethod
@deftypemethod ObjectOutputStream {public void} reset () @*throws IOException
Resets stream to state equivalent to the state just after it was
constructed.

Causes all objects previously written to the stream to be
forgotten.  A notification of this reset is also written to the
underlying stream.
@end deftypemethod
@deftypemethod ObjectOutputStream {public void} useProtocolVersion (int@w{ }@var{version}) @*throws IOException
Informs this @code{ObjectOutputStream} to write data
according to the specified protocol.  There are currently two
different protocols, specified by @code{PROTOCOL_VERSION_1}
and @code{PROTOCOL_VERSION_2}.  This implementation writes
data using @code{PROTOCOL_VERSION_1} by default, as is done
by the JDK 1.1.

A non-portable method, @code{setDefaultProtocolVersion (int
version)} is provided to change the default protocol
version.

For an explination of the differences beween the two protocols
see XXX: the Java ObjectSerialization Specification.
@end deftypemethod
@deftypemethod ObjectOutputStream {public static void} setDefaultProtocolVersion (int@w{ }@var{version}) @*throws IOException
<em>GNU $classpath specific</em>

Changes the default stream protocol used by all
@code{ObjectOutputStream}s.  There are currently two
different protocols, specified by @code{PROTOCOL_VERSION_1}
and @code{PROTOCOL_VERSION_2}.  The default default is
@code{PROTOCOL_VERSION_1}.
@end deftypemethod
@deftypemethod ObjectOutputStream {protected void} annotateClass (java.lang.Class@w{ }@var{cl}) @*throws IOException
An empty hook that allows subclasses to write extra information
about classes to the stream.  This method is called the first
time each class is seen, and after all of the standard
information about the class has been written.
@end deftypemethod
@deftypemethod ObjectOutputStream {protected Object} replaceObject (java.lang.Object@w{ }@var{obj}) @*throws IOException
Allows subclasses to replace objects that are written to the
stream with other objects to be written in their place.  This
method is called the first time each object is encountered
(modulo reseting of the stream).

This method must be enabled before it will be called in the
serialization process.
@end deftypemethod
@deftypemethod ObjectOutputStream {protected boolean} enableReplaceObject (boolean@w{ }@var{enable}) @*throws SecurityException
If @code{enable} is @code{true} and this object is
trusted, then @code{replaceObject (Object)} will be called
in subsequent calls to @code{writeObject (Object)}.
Otherwise, @code{replaceObject (Object)} will not be called.
@end deftypemethod
@deftypemethod ObjectOutputStream {protected void} writeStreamHeader () @*throws IOException
Writes stream magic and stream version information to the
underlying stream.
@end deftypemethod
@deftypemethod ObjectOutputStream {protected void} writeObjectOverride (java.lang.Object@w{ }@var{obj}) @*throws NotActiveException, IOException
This method allows subclasses to override the default
serialization mechanism provided by
@code{ObjectOutputStream}.  To make this method be used for
writing objects, subclasses must invoke the 0-argument
constructor on this class from there constructor.
@end deftypemethod
@deftypemethod ObjectOutputStream {public void} write (int@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} write (byte[]@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} write (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} flush () @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {protected void} drain () @*throws IOException
Causes the block-data buffer to be written to the underlying
stream, but does not flush underlying stream.
@end deftypemethod
@deftypemethod ObjectOutputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeBoolean (boolean@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeByte (int@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeShort (int@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeChar (int@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeInt (int@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeLong (long@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeFloat (float@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeDouble (double@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeBytes (java.lang.String@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeChars (java.lang.String@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeUTF (java.lang.String@w{ }@var{data}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public ObjectOutputStream.PutField} putFields () @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream {public void} writeFields () @*throws IOException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, boolean@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, byte@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, char@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, double@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, float@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, int@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, long@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, short@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} put (java.lang.String@w{ }@var{name}, java.lang.Object@w{ }@var{value}) @*throws IOException, IllegalArgumentException

@end deftypemethod
@deftypemethod ObjectOutputStream.PutField {public abstract void} write (java.io.ObjectOutput@w{ }@var{out}) @*throws IOException

@end deftypemethod
@deftypemethod ObjectStreamClass {public static ObjectStreamClass} lookup (java.lang.Class@w{ }@var{cl}) 
Returns the @code{ObjectStreamClass} for @code{cl}.
If @code{cl} is null, or is not @code{Serializable},
null is returned.  @code{ObjectStreamClass}'s are memorized;
later calls to this method with the same class will return the
same @code{ObjectStreamClass} object and no recalculation
will be done.
@end deftypemethod
@deftypemethod ObjectStreamClass {public String} getName () 
Returns the name of the class that this
@code{ObjectStreamClass} represents.
@end deftypemethod
@deftypemethod ObjectStreamClass {public Class} forClass () 
Returns the class that this @code{ObjectStreamClass}
represents.  Null could be returned if this
@code{ObjectStreamClass} was read from an
@code{ObjectInputStream} and the class it represents cannot
be found or loaded.
@end deftypemethod
@deftypemethod ObjectStreamClass {public long} getSerialVersionUID () 
Returns the serial version stream-unique identifier for the class
represented by this @code{ObjectStreamClass}.  This SUID is
either defined by the class as @code{static final long
serialVersionUID} or is calculated as specified in
Javasoft's "Object Serialization Specification" XXX: add reference
@end deftypemethod
@deftypemethod ObjectStreamClass {public ObjectStreamField} getFields () 

@end deftypemethod
@deftypemethod ObjectStreamClass {public ObjectStreamField} getField (java.lang.String@w{ }@var{name}) 

@end deftypemethod
@deftypemethod ObjectStreamClass {public String} toString () 
Returns a textual representation of this
@code{ObjectStreamClass} object including the name of the
class it represents as well as that class's serial version
stream-unique identifier.
@end deftypemethod
@deftypemethod ObjectStreamField {public String} getName () 

@end deftypemethod
@deftypemethod ObjectStreamField {public Class} getType () 

@end deftypemethod
@deftypemethod ObjectStreamField {public char} getTypeCode () 

@end deftypemethod
@deftypemethod ObjectStreamField {public String} getTypeString () 

@end deftypemethod
@deftypemethod ObjectStreamField {public int} getOffset () 

@end deftypemethod
@deftypemethod ObjectStreamField {protected void} setOffset (int@w{ }@var{off}) 

@end deftypemethod
@deftypemethod ObjectStreamField {public boolean} isPrimitive () 

@end deftypemethod
@deftypemethod ObjectStreamField {public int} compareTo (java.lang.Object@w{ }@var{o}) 

@end deftypemethod
@deftypemethod ObjectStreamField {public String} toString () 

@end deftypemethod
@deftypemethod OutputStream {public abstract void} write (int@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod OutputStream {public void} write (byte[]@w{ }@var{b}) @*throws IOException, NullPointerException

@end deftypemethod
@deftypemethod OutputStream {public void} write (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException, NullPointerException, IndexOutOfBoundsException

@end deftypemethod
@deftypemethod OutputStream {public void} flush () @*throws IOException

@end deftypemethod
@deftypemethod OutputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod OutputStreamWriter {public String} getEncoding () 

@end deftypemethod
@deftypemethod OutputStreamWriter {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod OutputStreamWriter {public void} flush () @*throws IOException

@end deftypemethod
@deftypemethod OutputStreamWriter {public void} write (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod OutputStreamWriter {public void} write (java.lang.String@w{ }@var{str}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod OutputStreamWriter {public void} write (int@w{ }@var{ch}) @*throws IOException

@end deftypemethod
@deftypemethod PipedInputStream {public void} connect (java.io.PipedOutputStream@w{ }@var{source}) @*throws IOException
This method connects this stream to the passed in @code{PipedOutputStream}.
 This stream is then ready for reading.  If this stream is already
 connected or has been previously closed, then an exception is thrown
@end deftypemethod
@deftypemethod PipedInputStream {protected synchronized void} receive (int@w{ }@var{b}) @*throws IOException
This method receives a byte of input from the source PipedOutputStream.
 If the internal circular buffer is full, this method blocks.
@end deftypemethod
@deftypemethod PipedInputStream {public int} read () @*throws IOException
This method reads bytes from the stream into a caller supplied buffer.
 It starts storing bytes at position @code{offset} into the buffer and
 reads a maximum of @code{len} bytes.  Note that this method can actually
 read fewer than @code{len} 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.
 


 This method will block if no bytes are available to be read.
@end deftypemethod
@deftypemethod PipedInputStream {public synchronized int} read (byte[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method reads bytes from the stream into a caller supplied buffer.
 It starts storing bytes at position @code{offset} into the buffer and
 reads a maximum of @code{len} bytes.  Note that this method can actually
 read fewer than @code{len} 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.
 


 This method will block if no bytes are available to be read.
@end deftypemethod
@deftypemethod PipedInputStream {public synchronized int} available () @*throws IOException
This method returns the number of bytes that can be read from this stream
 before blocking could occur.  This is the number of bytes that are
 currently unread in the internal circular buffer.  Note that once this
 many additional bytes are read, the stream may block on a subsequent
 read, but it not guaranteed to block.
@end deftypemethod
@deftypemethod PipedInputStream {public synchronized void} close () @*throws IOException
This methods closes the stream so that no more data can be read
 from it.
@end deftypemethod
@deftypemethod PipedOutputStream {public void} connect (java.io.PipedInputStream@w{ }@var{sink}) @*throws IOException
Connects this object to the specified @code{PipedInputStream} 
 object.  This stream will then be ready for writing.
@end deftypemethod
@deftypemethod PipedOutputStream {public void} write (int@w{ }@var{b}) @*throws IOException
Write a single byte of date to the stream.  Note that this method will 
 block if the @code{PipedInputStream} to which this object is 
 connected has a full buffer.
@end deftypemethod
@deftypemethod PipedOutputStream {public void} write (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException
This method writes @code{len} bytes of data from the byte array
 @code{buf} starting at index @code{offset} in the array
 to the stream.  Note that this method will block if the  
 @code{PipedInputStream} to which this object is connected has
 a buffer that cannot hold all of the bytes to be written.
@end deftypemethod
@deftypemethod PipedOutputStream {public void} flush () 
This method does nothing.
@end deftypemethod
@deftypemethod PipedOutputStream {public void} close () 
This method closes this stream so that no more data can be written
 to it. Any further attempts to write to this stream may throw an
 exception
@end deftypemethod
@deftypemethod PipedReader {public void} connect (java.io.PipedWriter@w{ }@var{source}) @*throws IOException
This method connects this stream to the passed in @code{PipedWriter}.
 This stream is then ready for reading.  If this stream is already
 connected or has been previously closed, then an exception is thrown
@end deftypemethod
@deftypemethod PipedReader {public int} read () @*throws IOException
This method reads chars from the stream into a caller supplied buffer.
 It starts storing chars at position @code{offset} into the buffer and
 reads a maximum of @code{len} chars.  Note that this method can actually
 read fewer than @code{len} 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.
 


 This method will block if no chars are available to be read.
@end deftypemethod
@deftypemethod PipedReader {public int} read (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method reads characters from the stream into a caller supplied buffer.
 It starts storing chars at position @code{offset} into the buffer and
 reads a maximum of @code{len} chars.  Note that this method can actually
 read fewer than @code{len} 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.
 


 This method will block if no chars are available to be read.
@end deftypemethod
@deftypemethod PipedReader {public boolean} ready () @*throws IOException

@end deftypemethod
@deftypemethod PipedReader {public void} close () @*throws IOException
This methods closes the stream so that no more data can be read
 from it.
@end deftypemethod
@deftypemethod PipedWriter {public void} connect (java.io.PipedReader@w{ }@var{sink}) @*throws IOException
Connects this object to the specified @code{PipedReader} 
 object.  This stream will then be ready for writing.
@end deftypemethod
@deftypemethod PipedWriter {public void} write (char@w{ }@var{b}) @*throws IOException
Write a single char of date to the stream.  Note that this method will 
 block if the @code{PipedReader} to which this object is 
 connected has a full buffer.
@end deftypemethod
@deftypemethod PipedWriter {public void} write (char[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException
This method writes @code{len} chars of data from the char array
 @code{buf} starting at index @code{offset} in the array
 to the stream.  Note that this method will block if the  
 @code{PipedReader} to which this object is connected has
 a buffer that cannot hold all of the chars to be written.
@end deftypemethod
@deftypemethod PipedWriter {public void} flush () 
This method does nothing.
@end deftypemethod
@deftypemethod PipedWriter {public void} close () 
This method closes this stream so that no more data can be written
 to it. Any further attempts to write to this stream may throw an
 exception
@end deftypemethod
@deftypemethod PrintStream {public boolean} checkError () 

@end deftypemethod
@deftypemethod PrintStream {public void} close () 

@end deftypemethod
@deftypemethod PrintStream {public void} flush () 

@end deftypemethod
@deftypemethod PrintStream {public void} print (boolean@w{ }@var{bool}) 

@end deftypemethod
@deftypemethod PrintStream {public void} print (int@w{ }@var{inum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} print (long@w{ }@var{lnum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} print (float@w{ }@var{fnum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} print (double@w{ }@var{dnum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} print (java.lang.Object@w{ }@var{obj}) 

@end deftypemethod
@deftypemethod PrintStream {public void} print (java.lang.String@w{ }@var{str}) 

@end deftypemethod
@deftypemethod PrintStream {public synchronized void} print (char@w{ }@var{ch}) 

@end deftypemethod
@deftypemethod PrintStream {public void} print (char[]@w{ }@var{charArray}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println () 

@end deftypemethod
@deftypemethod PrintStream {public void} println (boolean@w{ }@var{bool}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println (int@w{ }@var{inum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println (long@w{ }@var{lnum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println (float@w{ }@var{fnum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println (double@w{ }@var{dnum}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println (java.lang.Object@w{ }@var{obj}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println (java.lang.String@w{ }@var{str}) 

@end deftypemethod
@deftypemethod PrintStream {public synchronized void} println (char@w{ }@var{ch}) 

@end deftypemethod
@deftypemethod PrintStream {public void} println (char[]@w{ }@var{charArray}) 

@end deftypemethod
@deftypemethod PrintStream {protected void} setError () 

@end deftypemethod
@deftypemethod PrintStream {public void} write (int@w{ }@var{oneByte}) 

@end deftypemethod
@deftypemethod PrintStream {public void} write (byte[]@w{ }@var{buffer}, int@w{ }@var{offset}, int@w{ }@var{count}) 

@end deftypemethod
@deftypemethod PrintWriter {protected void} setError () 
This method can be called by subclasses to indicate that an error
 has occurred and should be reported by @code{checkError}.
@end deftypemethod
@deftypemethod PrintWriter {public boolean} checkError () 
This method checks to see if an error has occurred on this stream.  Note
 that once an error has occurred, this method will continue to report
 @code{true} forever for this stream.  Before checking for an
 error condition, this method flushes the stream.
@end deftypemethod
@deftypemethod PrintWriter {public void} flush () 
This method flushes any buffered chars to the underlying stream and
 then flushes that stream as well.
@end deftypemethod
@deftypemethod PrintWriter {public void} close () 
This method closes this stream and all underlying streams.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (java.lang.String@w{ }@var{str}) 
This method prints a @code{String} to the stream.  The actual
 value printed depends on the system default encoding.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (char@w{ }@var{ch}) 
This method prints a char to the stream.  The actual value printed is
 determined by the character encoding in use.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (char[]@w{ }@var{charArray}) 
This method prints an array of characters to the stream.  The actual
 value printed depends on the system default encoding.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (boolean@w{ }@var{bool}) 
This methods prints a boolean value to the stream.  @code{true}
 values are printed as "true" and @code{false} values are printed
 as "false".
@end deftypemethod
@deftypemethod PrintWriter {public void} print (int@w{ }@var{inum}) 
This method prints an integer to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (long@w{ }@var{lnum}) 
This method prints a long to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (float@w{ }@var{fnum}) 
This method prints a float to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (double@w{ }@var{dnum}) 
This method prints a double to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.
@end deftypemethod
@deftypemethod PrintWriter {public void} print (java.lang.Object@w{ }@var{obj}) 
This method prints an @code{Object} to the stream.  The actual
 value printed is determined by calling the @code{String.valueOf()}
 method.
@end deftypemethod
@deftypemethod PrintWriter {public void} println () 
This method prints a line separator sequence to the stream.  The value
 printed is determined by the system property <xmp>line.separator</xmp>
 and is not necessarily the Unix '\n' newline character.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (boolean@w{ }@var{bool}) 
This methods prints a boolean value to the stream.  @code{true}
 values are printed as "true" and @code{false} values are printed
 as "false".

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (int@w{ }@var{inum}) 
This method prints an integer to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (long@w{ }@var{lnum}) 
This method prints a long to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (float@w{ }@var{fnum}) 
This method prints a float to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (double@w{ }@var{dnum}) 
This method prints a double to the stream.  The value printed is
 determined using the @code{String.valueOf()} method.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (java.lang.Object@w{ }@var{obj}) 
This method prints an @code{Object} to the stream.  The actual
 value printed is determined by calling the @code{String.valueOf()}
 method.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (java.lang.String@w{ }@var{str}) 
This method prints a @code{String} to the stream.  The actual
 value printed depends on the system default encoding.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (char@w{ }@var{ch}) 
This method prints a char to the stream.  The actual value printed is
 determined by the character encoding in use.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} println (char[]@w{ }@var{charArray}) 
This method prints an array of characters to the stream.  The actual
 value printed depends on the system default encoding.

 This method prints a line termination sequence after printing the value.
@end deftypemethod
@deftypemethod PrintWriter {public void} write (int@w{ }@var{ch}) 
This method writes a single char to the stream.
@end deftypemethod
@deftypemethod PrintWriter {public void} write (char[]@w{ }@var{charArray}, int@w{ }@var{offset}, int@w{ }@var{count}) 
This method writes @code{count} chars from the specified array 
 starting at index @code{offset} into the array.
@end deftypemethod
@deftypemethod PrintWriter {public void} write (java.lang.String@w{ }@var{str}, int@w{ }@var{offset}, int@w{ }@var{count}) 
This method writes @code{count} chars from the specified
 @code{String} to the output starting at character position
 @code{offset} into the @code{String}
@end deftypemethod
@deftypemethod PrintWriter {public void} write (char[]@w{ }@var{charArray}) 
This method write all the chars in the specified array to the output.
@end deftypemethod
@deftypemethod PrintWriter {public void} write (java.lang.String@w{ }@var{str}) 
This method writes the contents of the specified @code{String}
 to the underlying stream.
@end deftypemethod
@deftypemethod PushbackInputStream {public int} available () @*throws IOException

@end deftypemethod
@deftypemethod PushbackInputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod PushbackInputStream {public boolean} markSupported () 

@end deftypemethod
@deftypemethod PushbackInputStream {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod PushbackInputStream {public int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod PushbackInputStream {public void} unread (int@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod PushbackInputStream {public void} unread (byte[]@w{ }@var{b}) @*throws IOException

@end deftypemethod
@deftypemethod PushbackInputStream {public void} unread (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod PushbackInputStream {public long} skip (long@w{ }@var{n}) @*throws IOException

@end deftypemethod
@deftypemethod PushbackReader {public void} close () @*throws IOException
This method closes the stream and frees any associated resources.
@end deftypemethod
@deftypemethod PushbackReader {public void} mark (int@w{ }@var{read_limit}) @*throws IOException
This method throws an exception when called since this class does
 not support mark/reset.
@end deftypemethod
@deftypemethod PushbackReader {public boolean} markSupported () 
This method returns @code{false} to indicate that it does not support
 mark/reset functionality.
@end deftypemethod
@deftypemethod PushbackReader {public void} reset () @*throws IOException
This method always throws an IOException in this class because
 mark/reset functionality is not supported.
@end deftypemethod
@deftypemethod PushbackReader {public boolean} ready () @*throws IOException
This method determines whether or not this stream is ready to be read.
 If it returns @code{false} to indicate that the stream is not
 ready, any attempt to read from the stream could (but is not
 guaranteed to) block.
 


 This stream is ready to read if there are either chars waiting to be
 read in the pushback buffer or if the underlying stream is ready to
 be read.
@end deftypemethod
@deftypemethod PushbackReader {public long} skip (long@w{ }@var{num_chars}) @*throws IOException
This method skips the specified number of chars in the stream.  It
 returns the actual number of chars skipped, which may be less than the
 requested amount.
 


 This method first discards chars from the buffer, then calls the
 @code{skip} method on the underlying @code{Reader} to 
 skip additional chars if necessary.
@end deftypemethod
@deftypemethod PushbackReader {public int} read () @*throws IOException
This method reads an unsigned char from the input stream and returns it
 as an int in the range of 0-65535.  This method also will return -1 if
 the end of the stream has been reached.  The char returned will be read
 from the pushback buffer, unless the buffer is empty, in which case
 the char will be read from the underlying stream.
 


 This method will block until the char can be read.
@end deftypemethod
@deftypemethod PushbackReader {public synchronized int} read (char[]@w{ }@var{b}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method read chars from a stream and stores them into a caller
 supplied buffer.  It starts storing the data at index @code{offset} into
 the buffer and attempts to read @code{len} 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
 end of the stream.
  


 This method will block until some data can be read.
 


 This method first reads chars from the pushback buffer in order to 
 satisfy the read request.  If the pushback buffer cannot provide all
 of the chars requested, the remaining chars are read from the 
 underlying stream.
@end deftypemethod
@deftypemethod PushbackReader {public void} unread (int@w{ }@var{b}) @*throws IOException
This method pushes a single char of data into the pushback buffer.
 The char pushed back is the one that will be returned as the first char
 of the next read.
 


 If the pushback buffer is full, this method throws an exception.
 


 The argument to this method is an @code{int}.  Only the low eight bits
 of this value are pushed back.
@end deftypemethod
@deftypemethod PushbackReader {public synchronized void} unread (char[]@w{ }@var{buf}) @*throws IOException
This method pushes all of the chars in the passed char array into 
 the pushback buffer.  These chars are pushed in reverse order so that
 the next char read from the stream after this operation will be
 @code{buf[0]} followed by @code{buf[1]}, etc.
 


 If the pushback buffer cannot hold all of the requested chars, an
 exception is thrown.
@end deftypemethod
@deftypemethod PushbackReader {public synchronized void} unread (char[]@w{ }@var{b}, int@w{ }@var{offset}, int@w{ }@var{len}) @*throws IOException
This method pushed back chars from the passed in array into the pushback
 buffer.  The chars from @code{buf[offset]} to @code{buf[offset + len]}
 are pushed in reverse order so that the next char read from the stream
 after this operation will be @code{buf[offset]} followed by
 @code{buf[offset + 1]}, etc.
 


 If the pushback buffer cannot hold all of the requested chars, an
 exception is thrown.
@end deftypemethod
@deftypemethod RandomAccessFile {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final FileDescriptor} getFD () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public long} getFilePointer () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public long} length () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public int} read (byte[]@w{ }@var{buffer}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public int} read (byte[]@w{ }@var{buffer}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final boolean} readBoolean () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final byte} readByte () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final char} readChar () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final double} readDouble () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final float} readFloat () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} readFully (byte[]@w{ }@var{buffer}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} readFully (byte[]@w{ }@var{buffer}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final int} readInt () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final String} readLine () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final long} readLong () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final short} readShort () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final int} readUnsignedByte () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final int} readUnsignedShort () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final String} readUTF () @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public void} seek (long@w{ }@var{pos}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public int} skipBytes (int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public void} write (int@w{ }@var{oneByte}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public void} write (byte[]@w{ }@var{buffer}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public void} write (byte[]@w{ }@var{buffer}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeBoolean (boolean@w{ }@var{val}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeByte (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeShort (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeChar (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeInt (int@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeLong (long@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeFloat (float@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeDouble (double@w{ }@var{v}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeBytes (java.lang.String@w{ }@var{s}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeChars (java.lang.String@w{ }@var{s}) @*throws IOException

@end deftypemethod
@deftypemethod RandomAccessFile {public final void} writeUTF (java.lang.String@w{ }@var{s}) @*throws IOException

@end deftypemethod
@deftypemethod Reader {public abstract int} read (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException
Read chars from a stream and stores them into a caller
 supplied buffer.  It starts storing the data at index @code{offset} 
 into the buffer and attempts to read @code{len} 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 end of the stream.
 


 This method will block until some data can be read.
 


 This method operates by calling the single char @code{read()} method
 in a loop until the desired number of chars are read.  The read loop
 stops short if the end of the stream is encountered or if an IOException
 is encountered on any read operation except the first.  If the first
 attempt to read a chars fails, the IOException is allowed to propagate
 upward.  And subsequent IOException is caught and treated identically
 to an end of stream condition.  Subclasses can (and should if possible)
 override this method to provide a more efficient implementation.
@end deftypemethod
@deftypemethod Reader {public int} read (char[]@w{ }@var{buf}) @*throws IOException
Reads chars from a stream and stores them into a caller
 supplied buffer.  This method attempts to completely fill the buffer,
 but can return before doing so.  The actual number of chars read is
 returned as an int.  A -1 is returned to indicate the end of the stream.
 


 This method will block until some data can be read.
 


 This method operates by calling an overloaded read method like so:
 @code{read(buf, 0, buf.length)}
@end deftypemethod
@deftypemethod Reader {public int} read () @*throws IOException
Reads an char from the input stream and returns it
 as an int in the range of 0-65535.  This method also will return -1 if
 the end of the stream has been reached.
 


 This method will block until the char can be read.
@end deftypemethod
@deftypemethod Reader {public abstract void} close () @*throws IOException
Closes the stream.  Any futher attempts to read from the
 stream may generate an @code{IOException}.
@end deftypemethod
@deftypemethod Reader {public boolean} markSupported () 
Returns a boolean that indicates whether the mark/reset
 methods are supported in this class.  Those methods can be used to
 remember a specific point in the stream and reset the stream to that
 point.
 


 This method always returns @code{false} in this class, but
 subclasses can override this method to return @code{true} if they 
 support mark/reset functionality.
@end deftypemethod
@deftypemethod Reader {public void} mark (int@w{ }@var{readLimit}) @*throws IOException
Marks a position in the input to which the stream can be
 "reset" by calling the @code{reset()} method.  The parameter
 @code{readlimit} is the number of chars that can be read from the 
 stream after setting the mark before the mark becomes invalid.  For
 example, if @code{mark()} is called with a read limit of 10, then 
 when 11 chars of data are read from the stream before the 
 @code{reset()} method is called, then the mark is invalid and the 
 stream object instance is not required to remember the mark.
@end deftypemethod
@deftypemethod Reader {public void} reset () @*throws IOException
Resets a stream to the point where the @code{mark()} 
 method was called.  Any chars that were read after the mark point was 
 set will be re-read during subsequent reads.
 


 This method always throws an IOException in this class, but subclasses
 can override this method if they provide mark/reset functionality.
@end deftypemethod
@deftypemethod Reader {public boolean} ready () @*throws IOException
Determines whether or not this stream is ready to be
 read.  If it returns @code{false} the stream may block if a
 read is attempted, but it is not guaranteed to do so.
 


 This method always returns @code{false} in this class
@end deftypemethod
@deftypemethod Reader {public long} skip (long@w{ }@var{count}) @*throws IOException
Skips the specified number of chars in the stream.  It
 returns the actual number of chars skipped, which may be less than the
 requested amount.
 


 This method reads and discards chars into a 256 char array until the
 specified number of chars were skipped or until either the end of stream
 is reached or a read attempt returns a short count.  Subclasses can
 override this method to provide a more efficient implementation where
 one exists.
@end deftypemethod
@deftypemethod SequenceInputStream {public int} available () @*throws IOException

@end deftypemethod
@deftypemethod SequenceInputStream {public void} close () @*throws IOException

@end deftypemethod
@deftypemethod SequenceInputStream {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod SequenceInputStream {public int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod StreamTokenizer {public void} commentChar (int@w{ }@var{ch}) 
This method sets the comment attribute on the specified character.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} eolIsSignificant (boolean@w{ }@var{flag}) 
This method sets a flag that indicates whether or not the end of line
 sequence terminates and is a token.  The defaults to @code{false}
@end deftypemethod
@deftypemethod StreamTokenizer {public int} lineno () 
This method returns the current line number.  Note that if the 
 @code{pushBack()} method is called, it has no effect on the
 line number returned by this method.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} lowerCaseMode (boolean@w{ }@var{flag}) 
This method sets a flag that indicates whether or not alphabetic
 tokens that are returned should be converted to lower case.
@end deftypemethod
@deftypemethod StreamTokenizer {public int} nextToken () @*throws IOException
This method reads the next token from the stream.  It sets the 
 @code{ttype} variable to the appropriate token type and 
 returns it.  It also can set @code{sval} or @code{nval}
 as described below.  The parsing strategy is as follows:
 
@itemize @bullet

 
@item
Skip any whitespace characters.
 
@item
If a numeric character is encountered, attempt to parse a numeric
 value.  Leading '-' characters indicate a numeric only if followed by
 another non-'-' numeric.  The value of the numeric token is terminated
 by either the first non-numeric encountered, or the second occurrence of
 '-' or '.'.  The token type returned is TT_NUMBER and @code{nval}
 is set to the value parsed.
 
@item
If an alphabetic character is parsed, all subsequent characters
 are read until the first non-alphabetic or non-numeric character is
 encountered.  The token type returned is TT_WORD and the value parsed
 is stored in @code{sval}.  If lower case mode is set, the token
 stored in @code{sval} is converted to lower case.  The end of line
 sequence terminates a word only if EOL signficance has been turned on.
 The start of a comment also terminates a word.  Any character with a 
 non-alphabetic and non-numeric attribute (such as white space, a quote,
 or a commet) are treated as non-alphabetic and terminate the word.
 
@item
If a comment charcters is parsed, then all remaining characters on
 the current line are skipped and another token is parsed.  Any EOL or
 EOF's encountered are not discarded, but rather terminate the comment.
 
@item
If a quote character is parsed, then all characters up to the 
 second occurrence of the same quote character are parsed into a
 @code{String}.  This @code{String} is stored as
 @code{sval}, but is not converted to lower case, even if lower case
 mode is enabled.  The token type returned is the value of the quote
 character encountered.  Any escape sequences
 (\b (backspace), \t (HTAB), \n (linefeed), \f (form feed), \r
 (carriage return), \" (double quote), \' (single quote), \\
 (backslash), \XXX (octal esacpe)) are converted to the appropriate
 char values.  Invalid esacape sequences are left in untranslated.  
 Unicode characters like ('\ u0000') are not recognized. 
 
@item
If the C++ comment sequence "//" is encountered, and the parser
 is configured to handle that sequence, then the remainder of the line
 is skipped and another token is read exactly as if a character with
 the comment attribute was encountered.
 
@item
If the C comment sequence "/*" is encountered, and the parser
 is configured to handle that sequence, then all characters up to and
 including the comment terminator sequence are discarded and another
 token is parsed.
 
@item
If all cases above are not met, then the character is an ordinary
 character that is parsed as a token by itself.  The char encountered
 is returned as the token type.
 
@end itemize

@end deftypemethod
@deftypemethod StreamTokenizer {public void} ordinaryChar (int@w{ }@var{ch}) 
This method makes the specified character an ordinary character.  This
 means that none of the attributes (whitespace, alphabetic, numeric,
 quote, or comment) will be set on this character.  This character will
 parse as its own token.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} ordinaryChars (int@w{ }@var{low}, int@w{ }@var{hi}) 
This method makes all the characters in the specified range, range
 terminators included, ordinary.  This means the none of the attributes
 (whitespace, alphabetic, numeric, quote, or comment) will be set on
 any of the characters in the range.  This makes each character in this
 range parse as its own token.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} parseNumbers () 
This method sets the numeric attribute on the characters '0' - '9' and
 the characters '.' and '-'.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} pushBack () 
This method returns the current line number.  Note that if the 
 @code{pushBack()} method is called, it has no effect on the
 line number returned by this method.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} quoteChar (int@w{ }@var{ch}) 
This method sets the quote attribute on the specified character.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} resetSyntax () 
This method removes all attributes (whitespace, alphabetic, numeric,
 quote, and comment) from all characters.  It is equivalent to calling
 @code{ordinaryChars(0x00, 0xFF)}.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} slashSlashComments (boolean@w{ }@var{flag}) 
This method sets a flag that indicates whether or not "C++" language style
 comments ("//" comments through EOL ) are handled by the parser.
 If this is @code{true} commented out sequences are skipped and
 ignored by the parser.  This defaults to @code{false}.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} slashStarComments (boolean@w{ }@var{flag}) 
This method sets a flag that indicates whether or not "C" language style
 comments (with nesting not allowed) are handled by the parser.
 If this is @code{true} commented out sequences are skipped and
 ignored by the parser.  This defaults to @code{false}.
@end deftypemethod
@deftypemethod StreamTokenizer {public String} toString () 
This method returns the current token value as a @code{String} in
 the form "Token[x], line n", where 'n' is the current line numbers and
 'x' is determined as follows.
 


 
@itemize @bullet

 
@item
If no token has been read, then 'x' is "NOTHING" and 'n' is 0
 
@item
If @code{ttype} is TT_EOF, then 'x' is "EOF"
 
@item
If @code{ttype} is TT_EOL, then 'x' is "EOL"
 
@item
If @code{ttype} is TT_WORD, then 'x' is @code{sval}
 
@item
If @code{ttype} is TT_NUMBER, then 'x' is "n=strnval" where
 'strnval' is @code{String.valueOf(nval)}.
 
@item
If @code{ttype} is a quote character, then 'x' is
 @code{sval}
 
@item
For all other cases, 'x' is @code{ttype}
 
@end itemize

@end deftypemethod
@deftypemethod StreamTokenizer {public void} whitespaceChars (int@w{ }@var{low}, int@w{ }@var{hi}) 
This method sets the whitespace attribute for all charcters in the
 specified range, range terminators included.
@end deftypemethod
@deftypemethod StreamTokenizer {public void} wordChars (int@w{ }@var{low}, int@w{ }@var{hi}) 
This method sets the alphabetic attribute for all charcters in the
 specified range, range terminators included.
@end deftypemethod
@deftypemethod StringBufferInputStream {public int} available () 

@end deftypemethod
@deftypemethod StringBufferInputStream {public int} read () 

@end deftypemethod
@deftypemethod StringBufferInputStream {public int} read (byte[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) 

@end deftypemethod
@deftypemethod StringBufferInputStream {public void} reset () 

@end deftypemethod
@deftypemethod StringBufferInputStream {public long} skip (long@w{ }@var{n}) 

@end deftypemethod
@deftypemethod StringReader {public void} close () 

@end deftypemethod
@deftypemethod StringReader {public void} mark (int@w{ }@var{readAheadLimit}) @*throws IOException

@end deftypemethod
@deftypemethod StringReader {public boolean} markSupported () 

@end deftypemethod
@deftypemethod StringReader {public int} read () @*throws IOException

@end deftypemethod
@deftypemethod StringReader {public int} read (char[]@w{ }@var{b}, int@w{ }@var{off}, int@w{ }@var{len}) @*throws IOException

@end deftypemethod
@deftypemethod StringReader {public boolean} ready () @*throws IOException
This method determines if the stream is ready to be read.  This class
 is always ready to read and so always returns @code{true}, unless
 close() has previously been called in which case an IOException is
 thrown.
@end deftypemethod
@deftypemethod StringReader {public void} reset () @*throws IOException
Sets the read position in the stream to the previously
 marked position or to 0 (i.e., the beginning of the stream) if the mark
 has not already been set.
@end deftypemethod
@deftypemethod StringReader {public long} skip (long@w{ }@var{n}) @*throws IOException
This method attempts to skip the requested number of chars in the
 input stream.  It does this by advancing the @code{pos} value by 
 the specified number of chars.  It this would exceed the length of the
 buffer, then only enough chars are skipped to position the stream at
 the end of the buffer.  The actual number of chars skipped is returned.
@end deftypemethod
@deftypemethod StringWriter {public void} close () 

@end deftypemethod
@deftypemethod StringWriter {public void} flush () 

@end deftypemethod
@deftypemethod StringWriter {public StringBuffer} getBuffer () 

@end deftypemethod
@deftypemethod StringWriter {public String} toString () 

@end deftypemethod
@deftypemethod StringWriter {public void} write (int@w{ }@var{oneChar}) 

@end deftypemethod
@deftypemethod StringWriter {public void} write (char[]@w{ }@var{chars}, int@w{ }@var{offset}, int@w{ }@var{len}) 

@end deftypemethod
@deftypemethod StringWriter {public void} write (java.lang.String@w{ }@var{str}) 

@end deftypemethod
@deftypemethod StringWriter {public void} write (java.lang.String@w{ }@var{str}, int@w{ }@var{offset}, int@w{ }@var{len}) 

@end deftypemethod
@deftypemethod WriteAbortedException {public String} getMessage () 
This method returns a message indicating what went wrong, including 
 the message text from the initial exception that caused this one to
 be thrown
@end deftypemethod
@deftypemethod Writer {public abstract void} close () @*throws IOException

@end deftypemethod
@deftypemethod Writer {public abstract void} flush () @*throws IOException

@end deftypemethod
@deftypemethod Writer {public abstract void} write (char[]@w{ }@var{buf}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod Writer {public void} write (char[]@w{ }@var{buf}) @*throws IOException

@end deftypemethod
@deftypemethod Writer {public void} write (int@w{ }@var{ch}) @*throws IOException

@end deftypemethod
@deftypemethod Writer {public void} write (java.lang.String@w{ }@var{str}, int@w{ }@var{offset}, int@w{ }@var{count}) @*throws IOException

@end deftypemethod
@deftypemethod Writer {public void} write (java.lang.String@w{ }@var{str}) @*throws IOException

@end deftypemethod
