* into <code>b</code> starting at index <code>off</code>.     * If the end of the stream is reached, an <code>EOFException</code>     * will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param b an array of bytes to be written to.     * @param off the starting position within <code>b</code> to write to.     * @param len the maximum number of <code>byte</code>s to read.     *     * @exception IndexOutOfBoundsException if <code>off</code> is     * negative, <code>len</code> is negative, or <code>off +     * len</code> is greater than <code>b.length</code>.     * @exception NullPointerException if <code>b</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(byte[] b, int off, int len) throws IOException;     /**     * Reads <code>b.length</code> bytes from the stream, and stores them     * into <code>b</code> starting at index <code>0</code>.     * If the end of the stream is reached, an <code>EOFException</code>     * will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param b an array of <code>byte</code>s.     *     * @exception NullPointerException if <code>b</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(byte[] b) throws IOException;     /**     * Reads <code>len</code> shorts (signed 16-bit integers) from the     * stream according to the current byte order, and     * stores them into <code>s</code> starting at index     * <code>off</code>.  If the end of the stream is reached, an     * <code>EOFException</code> will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param s an array of shorts to be written to.     * @param off the starting position withinb to write to.     * @param len the maximum number of <code>short</code>s to read.     *     * @exception IndexOutOfBoundsException if <code>off</code> is     * negative, <code>len</code> is negative, or <code>off +     * len</code> is greater than <code>s.length</code>.     * @exception NullPointerException if <code>s</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(short[] s, int off, int len) throws IOException;     /**     * Reads <code>len</code> chars (unsigned 16-bit integers) from the     * stream according to the current byte order, and     * stores them into <code>c</code> starting at index     * <code>off</code>.  If the end of the stream is reached, an     * <code>EOFException</code> will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param c an array of chars to be written to.     * @param off the starting position withinb to write to.     * @param len the maximum number of <code>char</code>s to read.     *     * @exception IndexOutOfBoundsException if <code>off</code> is     * negative, <code>len</code> is negative, or <code>off +     * len</code> is greater than <code>c.length</code>.     * @exception NullPointerException if <code>c</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(char[] c, int off, int len) throws IOException;     /**     * Reads <code>len</code> ints (signed 32-bit integers) from the     * stream according to the current byte order, and     * stores them into <code>i</code> starting at index     * <code>off</code>.  If the end of the stream is reached, an     * <code>EOFException</code> will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param i an array of ints to be written to.     * @param off the starting position withinb to write to.     * @param len the maximum number of <code>int</code>s to read.     *     * @exception IndexOutOfBoundsException if <code>off</code> is     * negative, <code>len</code> is negative, or <code>off +     * len</code> is greater than <code>i.length</code>.     * @exception NullPointerException if <code>i</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(int[] i, int off, int len) throws IOException;     /**     * Reads <code>len</code> longs (signed 64-bit integers) from the     * stream according to the current byte order, and     * stores them into <code>l</code> starting at index     * <code>off</code>.  If the end of the stream is reached, an     * <code>EOFException</code> will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param l an array of longs to be written to.     * @param off the starting position withinb to write to.     * @param len the maximum number of <code>long</code>s to read.     *     * @exception IndexOutOfBoundsException if <code>off</code> is     * negative, <code>len</code> is negative, or <code>off +     * len</code> is greater than <code>l.length</code>.     * @exception NullPointerException if <code>l</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(long[] l, int off, int len) throws IOException;     /**     * Reads <code>len</code> floats (32-bit IEEE single-precision     * floats) from the stream according to the current byte order,     * and stores them into <code>f</code> starting at     * index <code>off</code>.  If the end of the stream is reached,     * an <code>EOFException</code> will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param f an array of floats to be written to.     * @param off the starting position withinb to write to.     * @param len the maximum number of <code>float</code>s to read.     *     * @exception IndexOutOfBoundsException if <code>off</code> is     * negative, <code>len</code> is negative, or <code>off +     * len</code> is greater than <code>f.length</code>.     * @exception NullPointerException if <code>f</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(float[] f, int off, int len) throws IOException;     /**     * Reads <code>len</code> doubles (64-bit IEEE double-precision     * floats) from the stream according to the current byte order,     * and stores them into <code>d</code> starting at     * index <code>off</code>.  If the end of the stream is reached,     * an <code>EOFException</code> will be thrown.     *     * <p> The bit offset within the stream is reset to zero before     * the read occurs.     *     * @param d an array of doubles to be written to.     * @param off the starting position withinb to write to.     * @param len the maximum number of <code>double</code>s to read.     *     * @exception IndexOutOfBoundsException if <code>off</code> is     * negative, <code>len</code> is negative, or <code>off +     * len</code> is greater than <code>d.length</code>.     * @exception NullPointerException if <code>d</code> is     * <code>null</code>.     * @exception EOFException if the stream reaches the end before     * reading all the bytes.     * @exception IOException if an I/O error occurs.     */    void readFully(double[] d, int off, int len) throws IOException;     /**     * Returns the current byte position of the stream.  The next read     * will take place starting at this offset.     *     * @return a long containing the position of the stream.     *     * @exception IOException if an I/O error occurs.     */    long getStreamPosition() throws IOException;     /**     * Returns the current bit offset, as an integer between 0 and 7,     * inclusive.  The bit offset is updated implicitly by calls to     * the <code>readBits</code> method.  A value of 0 indicates the     * most-significant bit, and a value of 7 indicates the least     * significant bit, of the byte being read.     *     * <p> The bit offset is set to 0 when a stream is first     * opened, and is reset to 0 by calls to <code>seek</code>,     * <code>skipBytes</code>, or any <code>read</code> or     * <code>readFully</code> method.     *     * @return an <code>int</code> containing the bit offset between     * 0 and 7, inclusive.     *     * @exception IOException if an I/O error occurs.     *     * @see #setBitOffset     */    int getBitOffset() throws IOException;     /**     * Sets the bit offset to an integer between 0 and 7, inclusive.     * The byte offset within the stream, as returned by     * <code>getStreamPosition</code>, is left unchanged.     * A value of 0 indicates the     * most-significant bit, and a value of 7 indicates the least     * significant bit, of the byte being read.     *     * @param bitOffset the desired offset, as an <code>int</code>     * between 0 and 7, inclusive.     *     * @exception IllegalArgumentException if <code>bitOffset</code>     * is not between 0 and 7, inclusive.     * @exception IOException if an I/O error occurs.     *     * @see #getBitOffset     */    void setBitOffset(int bitOffset) throws IOException;     /**     * Reads a single bit from the stream and returns it as an     * <code>int</code> with the value <code>0</code> or     * <code>1</code>.  The bit offset is advanced by one and reduced     * modulo 8.     *     * @return an <code>int</code> containing the value <code>0</code>     * or <code>1</code>.     *     * @exception EOFException if the stream reaches the end before     * reading all the bits.     * @exception IOException if an I/O error occurs.     */    int readBit() throws IOException;     /**     * Reads a bitstring from the stream and returns it as a     * <code>long</code>, with the first bit read becoming the most     * significant bit of the output.  The read starts within the byte     * indicated by <code>getStreamPosition</code>, at the bit given     * by <code>getBitOffset</code>.  The bit offset is advanced by     * <code>numBits</code> and reduced modulo 8.     *     * <p> The byte order of the stream has no effect on this     * method.  The return value of this method is constructed as     * though the bits were read one at a time, and shifted into     * the right side of the return value, as shown by the following     * pseudo-code:     *     * <pre>     * long accum = 0L;     * for (int i = 0; i < numBits; i++) {     *   accum <<= 1; // Shift left one bit to make room     *   accum |= readBit();     * }     * </pre>     *     * Note that the result of <code>readBits(32)</code> may thus not     * be equal to that of <code>readInt()</code> if a reverse network     * byte order is being used (i.e., <code>getByteOrder() ==     * false</code>).     *     * <p> If the end of the stream is encountered before all the bits     * have been read, an <code>EOFException</code> is thrown.     *     * @param numBits the number of bits to read, as an <code>int</code>     * between 0 and 64, inclusive.     * @return the bitstring, as a <code>long</code> with the last bit     * read stored in the least significant bit.     *     * @exception IllegalArgumentException if <code>numBits</code>     * is not between 0 and 64, inclusive.     * @exception EOFException if the stream reaches the end before     * reading all the bits.     * @exception IOException if an I/O error occurs.     */    long readBits(int numBits) throws IOException;     /**     * Returns the total length of the stream, if known.  Otherwise,     * <code>-1</code> is returned.     *     * @return a <code>long</code> containing the length of the     * stream, if known, or else <code>-1</code>.     *     * @exception IOException if an I/O error occurs.     */    long length() throws IOException;     /**     * Moves the stream position forward by a given number of bytes.  It     * is possible that this method will only be able to skip forward     * by a smaller number of bytes than requested, for example if the     * end of the stream is reached.  In all cases, the actual number     * of bytes skipped is returned.  The bit offset is set to zero     * prior to advancing the position.     *     * @param n an <code>int</code> containing the number of bytes to     * be skipped.     *     * @return an <code>int</code> representing the number of bytes skipped.     *     * @exception IOException if an I/O error occurs.     */    int skipBytes(int n) throws IOException;     /**     * Moves the stream position forward by a given number of bytes.     * This method is identical to <code>skipBytes(int)</code> except     * that it allows for a larger skip distance.     *     * @param n a <code>long</code> containing the number of bytes to     * be skipped.     *     * @return a <code>long</code> representing the number of bytes     * skipped.     *     * @exception IOException if an I/O error occurs.     */    long skipBytes(long n) throws IOException;     /**     * Sets the current stream position to the desired location.  The     * next read will occur at this location.  The bit offset is set     * to 0.     *     * <p> An <code>IndexOutOfBoundsException</code> will be thrown if     * <code>pos</code> is smaller than the flushed position (as     * returned by <code>getflushedPosition</code>).     *     * <p> It is legal to seek past the end of the file; an     * <code>EOFException</code> will be thrown only if a read is     * performed.     *     * @param pos a <code>long</code> containing the desired file     * pointer position.     *     * @exception IndexOutOfBoundsException if <code>pos</code> is smaller     * than the flushed position.     * @exception IOException if any other I/O error occurs.     */    void seek(long pos) throws IOException;     /**     * Marks a position in the stream to be returned to by a     * subsequent call to <code>reset</code>.  Unlike a standard     * <code>InputStream</code>, all <code>ImageInputStream</code>s     * support marking.  Additionally, calls to <code>mark</code> and     * <code>reset</code> may be nested arbitrarily.     *     * <p> Unlike the <code>mark</code> methods declared by the     * <code>Reader</code> and <code>InputStream</code> interfaces, no     * <code>readLimit</code> parameter is used.  An arbitrary amount     * of data may be read following the call to <code>mark</code>.     *     * <p> The bit position used by the <code>readBits</code> method     * is saved and restored by each pair of calls to     * <code>mark</code> and <code>reset</code>.     *     * <p> Note that it is valid for an <code>ImageReader</code> to call     * <code>flushBefore</code> as part of a read operation.     * Therefore, if an application calls <code>mark</code> prior to     * passing that stream to an <code>ImageReader</code>, the application     * should not assume that the marked position will remain valid after     * the read operation has completed.     */    void mark();     /**     * Returns the stream pointer to its previous position, including     * the bit offset, at the time of the most recent unmatched call     * to <code>mark</code>.     *     * <p> Calls to <code>reset</code> without a corresponding call     * to <code>mark</code> have no effect.     *     * <p> An <code>IOException</code> will be thrown if the previous     * marked position lies in the discarded portion of the stream.     *     * @exception IOException if an I/O error occurs.     */    void reset() throws IOException;     /**     * Discards the initial portion of the stream prior to the     * indicated postion.  Attempting to seek to an offset within the     * flushed portion of the stream will result in an     * <code>IndexOutOfBoundsException</code>.     *     * <p> Calling <code>flushBefore</code> may allow classes     * implementing this interface to free up resources such as memory     * or disk space that are being used to store data from the     * stream.     *     * @param pos a <code>long</code> containing the length of the     * stream prefix that may be flushed.     *     * @exception IndexOutOfBoundsException if <code>pos</code> lies     * in the flushed portion of the stream or past the current stream     * position.     * @exception IOException if an I/O error occurs.     */    void flushBefore(long pos) throws IOException;     /**     * Discards the initial position of the stream prior to the current     * stream position.  Equivalent to     * <code>flushBefore(getStreamPosition())</code>.     *     * @exception IOException if an I/O error occurs.     */    void flush() throws IOException;     /**     * Returns the earliest position in the stream to which seeking     * may be performed.  The returned value will be the maximum of     * all values passed into previous calls to     * <code>flushBefore</code>.     *     * @return the earliest legal position for seeking, as a     * <code>long</code>.     */    long getFlushedPosition();     /**     * Returns <code>true</code> if this <code>ImageInputStream</code>     * caches data itself in order to allow seeking backwards.     * Applications may consult this in order to decide how frequently,     * or whether, to flush in order to conserve cache resources.     *     * @return <code>true</code> if this <code>ImageInputStream</code>     * caches data.     *     * @see #isCachedMemory     * @see #isCachedFile     */    boolean isCached();     /**     * Returns <code>true</code> if this <code>ImageInputStream</code>     * caches data itself in order to allow seeking backwards, and     * the cache is kept in main memory.  Applications may consult     * this in order to decide how frequently, or whether, to flush     * in order to conserve cache resources.     *     * @return <code>true</code> if this <code>ImageInputStream</code>     * caches data in main memory.     *     * @see #isCached     * @see #isCachedFile     */    boolean isCachedMemory();     /**     * Returns <code>true</code> if this <code>ImageInputStream</code>     * caches data itself in order to allow seeking backwards, and     * the cache is kept in a temporary file.  Applications may consult     * this in order to decide how frequently, or whether, to flush     * in order to conserve cache resources.     *     * @return <code>true</code> if this <code>ImageInputStream</code>     * caches data in a temporary file.     *     * @see #isCached     * @see #isCachedMemory     */    boolean isCachedFile();     /**     * Closes the stream.  Attempts to access a stream that has been     * closed may result in <code>IOException</code>s or incorrect     * behavior.  Calling this method may allow classes implementing     * this interface to release resources associated with the stream     * such as memory, disk space, or file descriptors.     *     * @exception IOException if an I/O error occurs.     */    void close() throws IOException;}

Lines 501–1000 of 1000. Previous lines