java.io.SequenceInputStream Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of ocap Show documentation
There is a newer version: 1.3.1
/*
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;

import java.io.InputStream;
import java.util.Enumeration;
import java.util.Vector;

/** 
 * A SequenceInputStream represents
 * the logical concatenation of other input
 * streams. It starts out with an ordered
 * collection of input streams and reads from
 * the first one until end of file is reached,
 * whereupon it reads from the second one,
 * and so on, until end of file is reached
 * on the last of the contained input streams.
 *
 * @author  Author van Hoff
 * @version 1.23, 02/02/00
 * @since   JDK1.0
 */
public class SequenceInputStream extends java.io.InputStream
{

    /** 
     * Initializes a newly created SequenceInputStream
     * by remembering the argument, which must
     * be an Enumeration  that produces
     * objects whose run-time type is InputStream.
     * The input streams that are  produced by
     * the enumeration will be read, in order,
     * to provide the bytes to be read  from this
     * SequenceInputStream. After
     * each input stream from the enumeration
     * is exhausted, it is closed by calling its
     * close method.
     *
     * @param   e   an enumeration of input streams.
     * @see     java.util.Enumeration
     */
    public SequenceInputStream(Enumeration e) { }

    /** 
     * Initializes a newly
     * created SequenceInputStream
     * by remembering the two arguments, which
     * will be read in order, first s1
     * and then s2, to provide the
     * bytes to be read from this SequenceInputStream.
     *
     * @param   s1   the first input stream to read.
     * @param   s2   the second input stream to read.
     */
    public SequenceInputStream(java.io.InputStream s1, java.io.InputStream s2)
    { }

    /** 
     * Returns the number of bytes available on the current stream.
     *
     * @since   JDK1.1
     */
    public int available() throws IOException {
        return 0;
    }

    /** 
     * Reads the next byte of data from this input stream. The byte is
     * returned as an int in the range 0 to
     * 255. If no byte is available because the end of the
     * stream has been reached, the value -1 is returned.
     * This method blocks until input data is available, the end of the
     * stream is detected, or an exception is thrown.
     * 

     * This method
     * tries to read one character from the current substream. If it
     * reaches the end of the stream, it calls the close
     * method of the current substream and begins reading from the next
     * substream.
     *
     * @return     the next byte of data, or -1 if the end of the
     *             stream is reached.
     * @exception  IOException  if an I/O error occurs.
     */
    public int read() throws IOException {
        return 0;
    }

    /** 
     * Reads up to len bytes of data from this input stream
     * into an array of bytes. This method blocks until at least 1 byte
     * of input is available. If the first argument is null,
     * up to len bytes are read and discarded.
     * 

     * The read method of SequenceInputStream
     * tries to read the data from the current substream. If it fails to
     * read any characters because the substream has reached the end of
     * the stream, it calls the close method of the current
     * substream and begins reading from the next substream.
     *
     * @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     int   the number of bytes read.
     * @exception  IOException  if an I/O error occurs.
     */
    public int read(byte[] b, int off, int len) throws IOException {
        return 0;
    }

    /** 
     * Closes this input stream and releases any system resources
     * associated with the stream.
     * A closed SequenceInputStream
     * cannot  perform input operations and cannot
     * be reopened.
     * 
     * If this stream was created
     * from an enumeration, all remaining elements
     * are requested from the enumeration and closed
     * before the close method returns.
     * of InputStream .
     *
     * @exception  IOException  if an I/O error occurs.
     */
    public void close() throws IOException { }
}