Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| " 2013 FRC Java API "
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.sun.squawk.io.j2me.channel
Class ChannelInputStream

    java.lang.Object
      java.io.InputStream
          com.sun.squawk.io.j2me.channel.ChannelInputStream

All Implemented Interfaces:
  DataInput

    public class ChannelInputStream

extends InputStream
implements DataInput

ChannelInputStream

Constructor Summary
`ChannelInputStream(Protocol parent)`

Method Summary
`int` | `available()` Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream.
`void` | `close()` Closes this input stream and releases any system resources associated with the stream.
`void` | `mark(int readlimit)` Marks the current position in this input stream.
`boolean` | `markSupported()` Tests if this input stream supports the `mark` and `reset` methods.
`int` | `read()` Reads the next byte of data from the input stream.
`int` | `read(byte[] b, int off, int len)` Reads up to `len` bytes of data from the input stream into an array of bytes.
`boolean` | `readBoolean()` Reads one input byte and returns `true` if that byte is nonzero, `false` if that byte is zero.
`byte` | `readByte()` Reads and returns one input byte.
`char` | `readChar()` See the general contract of the `readChar` method of `DataInput`.
`double` | `readDouble()` Reads a 64 bit double.
`float` | `readFloat()` Reads a 32 bit float.
`void` | `readFully(byte[] b)` Reads some bytes from an input stream and stores them into the buffer array `b`.
`void` | `readFully(byte[] b, int off, int len)` See the general contract of the `readFully` method of `DataInput`.
`int` | `readInt()` Reads four input bytes and returns an `int` value.
`long` | `readLong()` Reads eight input bytes and returns a `long` value.
`short` | `readShort()` Reads two input bytes and returns a `short` value.
`int` | `readUnsignedByte()` Reads one input byte, zero-extends it to type `int`, and returns the result, which is therefore in the range `0` through `255`.
`int` | `readUnsignedShort()` Reads two input bytes, zero-extends it to type `int`, and returns an `int` value in the range `0` through `65535`.
`String` | `readUTF()` Reads in a string that has been encoded using a modified UTF-8 format.
`void` | `reset()` Repositions this stream to the position at the time the `mark` method was last called on this input stream.
`long` | `skip(long n)` Skips over and discards `n` bytes of data from this input stream.
`int` | `skipBytes(int n)` Makes an attempt to skip over `n` bytes of data from the input stream, discarding the skipped bytes.

Methods inherited from class java.io.InputStream
`read`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ChannelInputStream

    public ChannelInputStream(Protocol parent)
                       throws IOException

Throws:
  `IOException`

Method Detail

### close

    public void close()
               throws IOException

  Description copied from class: `InputStream`
  Closes this input stream and releases any system resources associated with the stream.

  The `close` method of `InputStream` does nothing.

  Overrides:
    `close` in class `InputStream`
  Throws:
    `IOException` - if an I/O error occurs.

### read

    public int read()
             throws IOException

  Description copied from class: `InputStream`
  Reads the next byte of data from the input stream. The value 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.

  A subclass must provide an implementation of this method.

  Specified by:
    `read` in class `InputStream`
  Returns:
    the next byte of data, or `-1` if the end of the stream is reached.
  Throws:
    `IOException` - if an I/O error occurs.

### readUnsignedShort

    public int readUnsignedShort()
                          throws IOException

  Description copied from interface: `DataInput`
  Reads two input bytes, zero-extends it to type `int`, and returns an `int` value in the range `0` through `65535`. Let `a` be the first byte read and `b` be the second byte. The value returned is:

      (((a & 0xff) << 8) | (b & 0xff))

  This method is suitable for reading the bytes written by the `writeShort` method of interface `DataOutput` if the argument to `writeShort` was intended to be a value in the range `0` through `65535`.

  Specified by:
    `readUnsignedShort` in interface `DataInput`
  Returns:
    the unsigned 16-bit value read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readInt

    public int readInt()
                throws IOException

  Description copied from interface: `DataInput`
  Reads four input bytes and returns an `int` value. Let `a` be the first byte read, `b` be the second byte, `c` be the third byte, and `d` be the fourth byte. The value returned is:

       (((a & 0xff) << 24) | ((b & 0xff) << 16) |
        ((c & 0xff) << 8) | (d & 0xff))

  This method is suitable for reading bytes written by the `writeInt` method of interface `DataOutput`.

  Specified by:
    `readInt` in interface `DataInput`
  Returns:
    the `int` value read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readLong

    public long readLong()
                  throws IOException

  Description copied from interface: `DataInput`
  Reads eight input bytes and returns a `long` value. Let `a` be the first byte read, `b` be the second byte, `c` be the third byte, `d` be the fourth byte, `e` be the fifth byte, `f` be the sixth byte, `g` be the seventh byte, and `h` be the eighth byte. The value returned is:

       (((long)(a & 0xff) << 56) |
        ((long)(b & 0xff) << 48) |
        ((long)(c & 0xff) << 40) |
        ((long)(d & 0xff) << 32) |
        ((long)(e & 0xff) << 24) |
        ((long)(f & 0xff) << 16) |
        ((long)(g & 0xff) <<  8) |
        ((long)(h & 0xff)))

  This method is suitable for reading bytes written by the `writeLong` method of interface `DataOutput`.

  Specified by:
    `readLong` in interface `DataInput`
  Returns:
    the `long` value read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### read

    public int read(byte[] b,
                    int off,
                    int len)
             throws IOException

  Description copied from class: `InputStream`
  Reads up to `len` bytes of data from the 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.

  The `read(b,` `off,` `len)` method for class `InputStream` simply calls the method `read()` repeatedly. If the first such call results in an `IOException`, that exception is returned from the call to the `read(b,` `off,` `len)` method. If any subsequent call to `read()` results in a `IOException`, the exception is caught and treated as if it were end of file; the bytes read up to that point are stored into `b` and the number of bytes read before the exception occurred is returned. Subclasses are encouraged to provide a more efficient implementation of this method.

  Overrides:
    `read` in class `InputStream`
  Parameters:
    `b` - the buffer into which the data is read.
    `off` - the start offset in array `b` at which the data is written.
    `len` - the maximum number of bytes to read.
  Returns:
    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.
  Throws:
    `IOException` - if an I/O error occurs.
  See Also:
    `InputStream.read()`

### skip

    public long skip(long n)
              throws IOException

  Description copied from class: `InputStream`
  Skips over and discards `n` bytes of data from this input stream. The `skip` method may, for a variety of reasons, end up skipping over some smaller number of bytes, possibly `0`. This may result from any of a number of conditions; reaching end of file before `n` bytes have been skipped is only one possibility. The actual number of bytes skipped is returned. If `n` is negative, no bytes are skipped.

  The `skip` method of `InputStream` creates a byte array and then repeatedly reads into it until `n` bytes have been read or the end of the stream has been reached. Subclasses are encouraged to provide a more efficient implementation of this method.

  Overrides:
    `skip` in class `InputStream`
  Parameters:
    `n` - the number of bytes to be skipped.
  Returns:
    the actual number of bytes skipped.
  Throws:
    `IOException` - if an I/O error occurs.

### available

    public int available()
                  throws IOException

  Description copied from class: `InputStream`
  Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream. The next caller might be the same thread or another thread.

  The `available` method for class `InputStream` always returns `0`.

  This method should be overridden by subclasses.

  Overrides:
    `available` in class `InputStream`
  Returns:
    the number of bytes that can be read from this input stream without blocking.
  Throws:
    `IOException` - if an I/O error occurs.

### mark

    public void mark(int readlimit)

  Description copied from class: `InputStream`
  Marks the current position in this input stream. A subsequent call to the `reset` method repositions this stream at the last marked position so that subsequent reads re-read the same bytes.

  The `readlimit` arguments tells this input stream to allow that many bytes to be read before the mark position gets invalidated.

  The general contract of `mark` is that, if the method `markSupported` returns `true`, the stream somehow remembers all the bytes read after the call to `mark` and stands ready to supply those same bytes again if and whenever the method `reset` is called. However, the stream is not required to remember any data at all if more than `readlimit` bytes are read from the stream before `reset` is called.

  The `mark` method of `InputStream` does nothing.

  Overrides:
    `mark` in class `InputStream`
  Parameters:
    `readlimit` - the maximum limit of bytes that can be read before the mark position becomes invalid.
  See Also:
    `InputStream.reset()`

### reset

    public void reset()
               throws IOException

  Description copied from class: `InputStream`
  Repositions this stream to the position at the time the `mark` method was last called on this input stream.

  The general contract of `reset` is:

  - If the method `markSupported` returns `true`, then:
    - If the method `mark` has not been called since the stream was created, or the number of bytes read from the stream since `mark` was last called is larger than the argument to `mark` at that last call, then an `IOException` might be thrown.
    - If such an `IOException` is not thrown, then the stream is reset to a state such that all the bytes read since the most recent call to `mark` (or since the start of the file, if `mark` has not been called) will be resupplied to subsequent callers of the `read` method, followed by any bytes that otherwise would have been the next input data as of the time of the call to `reset`.
  - If the method `markSupported` returns `false`, then:
    - The call to `reset` may throw an `IOException`.
    - If an `IOException` is not thrown, then the stream is reset to a fixed state that depends on the particular type of the input stream and how it was created. The bytes that will be supplied to subsequent callers of the `read` method depend on the particular type of the input stream.

  The method `reset` for class `InputStream` does nothing and always throws an `IOException`.

  Overrides:
    `reset` in class `InputStream`
  Throws:
    `IOException` - if this stream has not been marked or if the mark has been invalidated.
  See Also:
    `InputStream.mark(int)`, `IOException`

### markSupported

    public boolean markSupported()

  Description copied from class: `InputStream`
  Tests if this input stream supports the `mark` and `reset` methods. The `markSupported` method of `InputStream` returns `false`.

  Overrides:
    `markSupported` in class `InputStream`
  Returns:
    `true` if this true type supports the mark and reset method; `false` otherwise.
  See Also:
    `InputStream.mark(int)`, `InputStream.reset()`

### readFully

    public final void readFully(byte[] b)
                         throws IOException

  Description copied from interface: `DataInput`
  Reads some bytes from an input stream and stores them into the buffer array `b`. The number of bytes read is equal to the length of `b`.

  This method blocks until one of the following conditions occurs:

  - `b.length` bytes of input data are available, in which case a normal return is made.
  - End of file is detected, in which case an `EOFException` is thrown.
  - An I/O error occurs, in which case an `IOException` other than `EOFException` is thrown.

  If `b` is `null`, a `NullPointerException` is thrown. If `b.length` is zero, then no bytes are read. Otherwise, the first byte read is stored into element `b[0]`, the next one into `b[1]`, and so on. If an exception is thrown from this method, then it may be that some but not all bytes of `b` have been updated with data from the input stream.

  Specified by:
    `readFully` in interface `DataInput`
  Parameters:
    `b` - the buffer into which the data is read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readFully

    public final void readFully(byte[] b,
                                int off,
                                int len)
                         throws IOException

  See the general contract of the `readFully` method of `DataInput`.

  Bytes for this operation are read from the contained input stream.

  Specified by:
    `readFully` in interface `DataInput`
  Parameters:
    `b` - the buffer into which the data is read.
    `off` - the start offset of the data.
    `len` - the number of bytes to read.
  Throws:
    `EOFException` - if this input stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### skipBytes

    public int skipBytes(int n)
                  throws IOException

  Makes an attempt to skip over `n` bytes of data from the input stream, discarding the skipped bytes. However, it may skip over some smaller number of bytes, possibly zero. This may result from any of a number of conditions; reaching end of file before `n` bytes have been skipped is only one possibility. This method never throws an `EOFException`. The actual number of bytes skipped is returned.

  Specified by:
    `skipBytes` in interface `DataInput`
  Parameters:
    `n` - the number of bytes to be skipped.
  Returns:
    the number of bytes skipped, which is always `n`.
  Throws:
    `EOFException` - if this stream reaches the end before skipping all the bytes.
    `IOException` - if an I/O error occurs.

### readBoolean

    public boolean readBoolean()
                        throws IOException

  Reads one input byte and returns `true` if that byte is nonzero, `false` if that byte is zero. This method is suitable for reading the byte written by the `writeBoolean` method of interface `DataOutput`.

  Specified by:
    `readBoolean` in interface `DataInput`
  Returns:
    the `boolean` value read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readByte

    public byte readByte()
                  throws IOException

  Reads and returns one input byte. The byte is treated as a signed value in the range `-128` through `127`, inclusive. This method is suitable for reading the byte written by the `writeByte` method of interface `DataOutput`.

  Specified by:
    `readByte` in interface `DataInput`
  Returns:
    the 8-bit value read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readUnsignedByte

    public int readUnsignedByte()
                         throws IOException

  Reads one input byte, zero-extends it to type `int`, and returns the result, which is therefore in the range `0` through `255`. This method is suitable for reading the byte written by the `writeByte` method of interface `DataOutput` if the argument to `writeByte` was intended to be a value in the range `0` through `255`.

  Specified by:
    `readUnsignedByte` in interface `DataInput`
  Returns:
    the unsigned 8-bit value read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readShort

    public short readShort()
                    throws IOException

  Reads two input bytes and returns a `short` value. Let `a` be the first byte read and `b` be the second byte. The value returned is:

      (short)((a << 8) * | (b & 0xff))

  This method is suitable for reading the bytes written by the `writeShort` method of interface `DataOutput`.

  Specified by:
    `readShort` in interface `DataInput`
  Returns:
    the 16-bit value read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readChar

    public final char readChar()
                        throws IOException

  See the general contract of the `readChar` method of `DataInput`.

  Bytes for this operation are read from the contained input stream.

  Specified by:
    `readChar` in interface `DataInput`
  Returns:
    the next two bytes of this input stream as a Unicode character.
  Throws:
    `EOFException` - if this input stream reaches the end before reading two bytes.
    `IOException` - if an I/O error occurs.

### readFloat

    public final float readFloat()
                          throws IOException

  Reads a 32 bit float.

  Specified by:
    `readFloat` in interface `DataInput`
  Returns:
    the read 32 bit float.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readDouble

    public final double readDouble()
                            throws IOException

  Reads a 64 bit double.

  Specified by:
    `readDouble` in interface `DataInput`
  Returns:
    the 64 bit double read.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.

### readUTF

    public String readUTF()
                   throws IOException

  Reads in a string that has been encoded using a modified UTF-8 format. The general contract of `readUTF` is that it reads a representation of a Unicode character string encoded in Java modified UTF-8 format; this string of characters is then returned as a `String`.

  First, two bytes are read and used to construct an unsigned 16-bit integer in exactly the manner of the `readUnsignedShort` method . This integer value is called the UTF length and specifies the number of additional bytes to be read. These bytes are then converted to characters by considering them in groups. The length of each group is computed from the value of the first byte of the group. The byte following a group, if any, is the first byte of the next group.

  If the first byte of a group matches the bit pattern `0xxxxxxx` (where `x` means "may be `0` or `1`"), then the group consists of just that byte. The byte is zero-extended to form a character.

  If the first byte of a group matches the bit pattern `110xxxxx`, then the group consists of that byte `a` and a second byte `b`. If there is no byte `b` (because byte `a` was the last of the bytes to be read), or if byte `b` does not match the bit pattern `10xxxxxx`, then a `UTFDataFormatException` is thrown. Otherwise, the group is converted to the character:

      (char)(((a& 0x1F) << 6) | (b & 0x3F))

  If the first byte of a group matches the bit pattern `1110xxxx`, then the group consists of that byte `a` and two more bytes `b` and `c`. If there is no byte `c` (because byte `a` was one of the last two of the bytes to be read), or either byte `b` or byte `c` does not match the bit pattern `10xxxxxx`, then a `UTFDataFormatException` is thrown. Otherwise, the group is converted to the character:

       (char)(((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F))

  If the first byte of a group matches the pattern `1111xxxx` or the pattern `10xxxxxx`, then a `UTFDataFormatException` is thrown.

  If end of file is encountered at any time during this entire process, then an `EOFException` is thrown.

  After every group has been converted to a character by this process, the characters are gathered, in the same order in which their corresponding groups were read from the input stream, to form a `String`, which is returned.

  The `writeUTF` method of interface `DataOutput` may be used to write data that is suitable for reading by this method.

  Specified by:
    `readUTF` in interface `DataInput`
  Returns:
    a Unicode string.
  Throws:
    `EOFException` - if this stream reaches the end before reading all the bytes.
    `IOException` - if an I/O error occurs.
    `UTFDataFormatException` - if the bytes do not represent a valid UTF-8 encoding of a string.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| " 2013 FRC Java API "
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

"
For updated information see the Java FRC site
"