java.io.DataInputStream Maven / Gradle / Ivy
/*
This is not an official specification document, and usage is restricted.
NOTICE
(c) 2005-2007 Sun Microsystems, Inc. All Rights Reserved.
Neither this file nor any files generated from it describe a complete
specification, and they may only be used as described below. For
example, no permission is given for you to incorporate this file, in
whole or in part, in an implementation of a Java specification.
Sun Microsystems Inc. owns the copyright in this file and it is provided
to you for informative, as opposed to normative, use. The file and any
files generated from it may be used to generate other informative
documentation, such as a unified set of documents of API signatures for
a platform that includes technologies expressed as Java APIs. The file
may also be used to produce "compilation stubs," which allow
applications to be compiled and validated for such platforms.
Any work generated from this file, such as unified javadocs or compiled
stub files, must be accompanied by this notice in its entirety.
This work corresponds to the API signatures of JSR 219: Foundation
Profile 1.1. In the event of a discrepency between this work and the
JSR 219 specification, which is available at
http://www.jcp.org/en/jsr/detail?id=219, the latter takes precedence.
*/
package java.io;
/**
* A data input stream lets an application read primitive Java data
* types from an underlying input stream in a machine-independent
* way. An application uses a data output stream to write data that
* can later be read by a data input stream.
*
* Data input streams and data output streams represent Unicode
* strings in a format that is a slight modification of UTF-8. (For
* more information, see X/Open Company Ltd., "File System Safe
* UCS Transformation Format (FSS_UTF)", X/Open Preliminary
* Specification, Document Number: P316. This information also
* appears in ISO/IEC 10646, Annex P.) Note that in the
* following tables, the most significant bit appears in the
* far left-hand column.
*
* All characters in the range '\u0001' to
* '\u007F' are represented by a single byte:
*
*
*
*
* Bit Values
*
* Byte 1
* 0
* bits 6-0
*
*
*
*
*
* The null character '\u0000' and characters in the
* range '\u0080' to '\u07FF' are
* represented by a pair of bytes:
*
*
*
*
* Bit Values
*
* Byte 1
* 1
* 1
* 0
* bits 10-6
*
*
* Byte 2
* 1
* 0
* bits 5-0
*
*
*
*
*
* Characters in the range '\u0800' to
* '\uFFFF' are represented by three bytes:
*
*
*
*
* Bit Values
*
*
* Byte 1
* 1
* 1
* 1
* 0
* bits 15-12
*
*
* Byte 2
* 1
* 0
* bits 11-6
*
*
* Byte 3
* 1
* 0
* bits 5-0
*
*
*
*
* The two differences between this format and the
* "standard" UTF-8 format are the following:
*
* - The null byte
'\u0000' is encoded in 2-byte format
* rather than 1-byte, so that the encoded strings never have
* embedded nulls.
* - Only the 1-byte, 2-byte, and 3-byte formats are used.
*
*
* @author Arthur van Hoff
* @version 1.52 10/17/00
* @see java.io.DataOutputStream
* @since JDK1.0
*/
public class DataInputStream extends FilterInputStream implements DataInput
{
/**
* Creates a DataInputStream that uses the specified
* underlying InputStream.
*
* @param in the specified input stream
*/
public DataInputStream(InputStream in) {
super(in);
}
/**
* Reads some number of bytes from the contained input stream and
* stores them into the buffer array b. The number of
* bytes actually read is returned as an integer. This method blocks
* until input data is available, end of file is detected, or an
* exception is thrown.
*
* If b is null, a NullPointerException is
* thrown. If the length of b is zero, then no bytes are
* read and 0 is returned; otherwise, there is an attempt
* to read at least one byte. If no byte is available because the
* stream is at end of file, the value -1 is returned;
* otherwise, at least one byte is read and stored into b.
*
*
The first byte read is stored into element b[0], the
* next one into b[1], and so on. The number of bytes read
* is, at most, equal to the length of b. Let k
* be the number of bytes actually read; these bytes will be stored in
* elements b[0] through b[k-1], leaving
* elements b[k] through b[b.length-1]
* unaffected.
*
*
If the first byte cannot be read for any reason other than end of
* file, then an IOException is thrown. In particular, an
* IOException is thrown if the input stream has been closed.
*
*
The read(b) method has the same effect as:
*
* read(b, 0, b.length)
*
*
* @param b the buffer into which the data is read.
* @return the total number of bytes read into the buffer, or
* -1 if there is no more data because the end
* of the stream has been reached.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
* @see java.io.InputStream#read(byte[], int, int)
*/
public final int read(byte[] b) throws IOException {
return 0;
}
/**
* Reads up to len bytes of data from the contained
* input stream into an array of bytes. An attempt is made to read
* as many as len bytes, but a smaller number may be read,
* possibly zero. The number of bytes actually read is returned as an
* integer.
*
* This method blocks until input data is available, end of file is
* detected, or an exception is thrown.
*
*
If b is null, a
* NullPointerException is thrown.
*
*
If off is negative, or len is negative, or
* off+len is greater than the length of the array
* b, then an IndexOutOfBoundsException is
* thrown.
*
*
If len is zero, then no bytes are read and
* 0 is returned; otherwise, there is an attempt to read at
* least one byte. If no byte is available because the stream is at end of
* file, the value -1 is returned; otherwise, at least one
* byte is read and stored into b.
*
*
The first byte read is stored into element b[off], the
* next one into b[off+1], and so on. The number of bytes read
* is, at most, equal to len. Let k be the number of
* bytes actually read; these bytes will be stored in elements
* b[off] through b[off+k-1],
* leaving elements b[off+k] through
* b[off+len-1] unaffected.
*
*
In every case, elements b[0] through
* b[off] and elements b[off+len] through
* b[b.length-1] are unaffected.
*
*
If the first byte cannot be read for any reason other than end of
* file, then an IOException is thrown. In particular, an
* IOException is thrown if the input stream has been closed.
*
* @param b the buffer into which the data is read.
* @param off the start offset of the data.
* @param len the maximum number of bytes read.
* @return the total number of bytes read into the buffer, or
* -1 if there is no more data because the end
* of the stream has been reached.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
* @see java.io.InputStream#read(byte[], int, int)
*/
public final int read(byte[] b, int off, int len) throws IOException {
return 0;
}
/**
* See the general contract of the readFully
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @param b the buffer into which the data is read.
* @exception EOFException if this input stream reaches the end before
* reading all the bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final void readFully(byte[] b) throws IOException { }
/**
* See the general contract of the readFully
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @param b the buffer into which the data is read.
* @param off the start offset of the data.
* @param len the number of bytes to read.
* @exception EOFException if this input stream reaches the end before
* reading all the bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final void readFully(byte[] b, int off, int len) throws IOException
{ }
/**
* See the general contract of the skipBytes
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @param n the number of bytes to be skipped.
* @return the actual number of bytes skipped.
* @exception IOException if an I/O error occurs.
*/
public final int skipBytes(int n) throws IOException {
return 0;
}
/**
* See the general contract of the readBoolean
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the boolean value read.
* @exception EOFException if this input stream has reached the end.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final boolean readBoolean() throws IOException {
return false;
}
/**
* See the general contract of the readByte
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next byte of this input stream as a signed 8-bit
* byte.
* @exception EOFException if this input stream has reached the end.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final byte readByte() throws IOException {
return ' ';
}
/**
* See the general contract of the readUnsignedByte
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next byte of this input stream, interpreted as an
* unsigned 8-bit number.
* @exception EOFException if this input stream has reached the end.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final int readUnsignedByte() throws IOException {
return 0;
}
/**
* See the general contract of the readShort
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next two bytes of this input stream, interpreted as a
* signed 16-bit number.
* @exception EOFException if this input stream reaches the end before
* reading two bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final short readShort() throws IOException {
return -1;
}
/**
* See the general contract of the readUnsignedShort
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next two bytes of this input stream, interpreted as an
* unsigned 16-bit integer.
* @exception EOFException if this input stream reaches the end before
* reading two bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final int readUnsignedShort() throws IOException {
return 0;
}
/**
* See the general contract of the readChar
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next two bytes of this input stream as a Unicode
* character.
* @exception EOFException if this input stream reaches the end before
* reading two bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final char readChar() throws IOException {
return ' ';
}
/**
* See the general contract of the readInt
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next four bytes of this input stream, interpreted as an
* int.
* @exception EOFException if this input stream reaches the end before
* reading four bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final int readInt() throws IOException {
return 0;
}
/**
* See the general contract of the readLong
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next eight bytes of this input stream, interpreted as a
* long.
* @exception EOFException if this input stream reaches the end before
* reading eight bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
public final long readLong() throws IOException {
return -1;
}
/**
* See the general contract of the readFloat
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next four bytes of this input stream, interpreted as a
* float.
* @exception EOFException if this input stream reaches the end before
* reading four bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.DataInputStream#readInt()
* @see java.lang.Float#intBitsToFloat(int)
*/
public final float readFloat() throws IOException {
return 0.0f;
}
/**
* See the general contract of the readDouble
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next eight bytes of this input stream, interpreted as a
* double.
* @exception EOFException if this input stream reaches the end before
* reading eight bytes.
* @exception IOException if an I/O error occurs.
* @see java.io.DataInputStream#readLong()
* @see java.lang.Double#longBitsToDouble(long)
*/
public final double readDouble() throws IOException {
return 0.0d;
}
/**
* See the general contract of the readLine
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @deprecated This method does not properly convert bytes to characters.
* As of JDK 1.1, the preferred way to read lines of text is via the
* BufferedReader.readLine() method. Programs that use the
* DataInputStream class to read lines can be converted to use
* the BufferedReader class by replacing code of the form:
*
* DataInputStream d = new DataInputStream(in);
*
* with:
*
* BufferedReader d
* = new BufferedReader(new InputStreamReader(in));
*
*
* @return the next line of text from this input stream.
* @exception IOException if an I/O error occurs.
* @see java.io.BufferedReader#readLine()
* @see java.io.FilterInputStream#in
*/
public final String readLine() throws IOException {
return null;
}
/**
* See the general contract of the readUTF
* method of DataInput.
*
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return a Unicode string.
* @exception EOFException if this input stream reaches the end before
* reading all the bytes.
* @exception IOException if an I/O error occurs.
* @exception UTFDataFormatException if the bytes do not represent a valid UTF-8 encoding of a string.
* @see java.io.DataInputStream#readUTF(java.io.DataInput)
*/
public final String readUTF() throws IOException {
return null;
}
/**
* Reads from the
* stream in a representation
* of a Unicode character string encoded in
* Java modified UTF-8 format; this string
* of characters is then returned as a String.
* The details of the modified UTF-8 representation
* are exactly the same as for the readUTF
* method of DataInput.
*
* @param in a data input stream.
* @return a Unicode string.
* @exception EOFException if the input stream reaches the end
* before all the bytes.
* @exception IOException if an I/O error occurs.
* @exception UTFDataFormatException if the bytes do not represent a
* valid Java modified UTF-8 encoding of a Unicode string.
* @see java.io.DataInputStream#readUnsignedShort()
*/
public static final String readUTF(DataInput in) throws IOException {
return null;
}
}