diff options
Diffstat (limited to 'libjava/doc/java-io.texi')
| -rw-r--r-- | libjava/doc/java-io.texi | 2592 |
1 files changed, 2592 insertions, 0 deletions
diff --git a/libjava/doc/java-io.texi b/libjava/doc/java-io.texi new file mode 100644 index 00000000000..753bf96639e --- /dev/null +++ b/libjava/doc/java-io.texi @@ -0,0 +1,2592 @@ +@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{\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 |