OtpInputStream (Java-Erlang Interface Library)

Package com.ericsson.otp.erlang

## Class OtpInputStream

- java.lang.Object
- - java.io.InputStream
  - - java.io.ByteArrayInputStream
    - - com.ericsson.otp.erlang.OtpInputStream

- All Implemented Interfaces:
    `java.io.Closeable`, `java.lang.AutoCloseable`

      public class OtpInputStream
      extends java.io.ByteArrayInputStream

  Provides a stream for decoding Erlang terms from external format.

  Note that this class is not synchronized, if you need synchronization you must provide it yourself.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static int` | `DECODE_INT_LISTS_AS_STRINGS` |

    - ### Fields inherited from class java.io.ByteArrayInputStream

      `buf, count, mark, pos`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `OtpInputStream​(byte[] buf)` |
    `OtpInputStream​(byte[] buf, int flags)` | Create a stream from a buffer containing encoded Erlang terms.
    `OtpInputStream​(byte[] buf, int offset, int length, int flags)` | Create a stream from a buffer containing encoded Erlang terms at the given offset and length.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static long` | `byte_array_to_long​(byte[] b, boolean unsigned)` |
    `int` | `getPos()` | Get the current position in the stream.
    `int` | `peek()` | Alias for peek1()
    `int` | `peek1()` | Look ahead one position in the stream without consuming the byte found there.
    `int` | `peek1skip_version()` |
    `OtpErlangObject` | `read_any()` | Read an arbitrary Erlang term from the stream.
    `java.lang.String` | `read_atom()` | Read an Erlang atom from the stream.
    `byte[]` | `read_binary()` | Read an Erlang binary from the stream.
    `byte[]` | `read_bitstr​(int[] pad_bits)` | Read an Erlang bitstr from the stream.
    `boolean` | `read_boolean()` | Read an Erlang atom from the stream and interpret the value as a boolean.
    `byte` | `read_byte()` | Read one byte from the stream.
    `char` | `read_char()` | Read a character from the stream.
    `OtpErlangObject` | `read_compressed()` | Read a compressed term from the stream
    `double` | `read_double()` | Read an Erlang float from the stream.
    `OtpErlangExternalFun` | `read_external_fun()` |
    `float` | `read_float()` | Read an Erlang float from the stream.
    `OtpErlangFun` | `read_fun()` |
    `int` | `read_int()` | Read an integer from the stream.
    `byte[]` | `read_integer_byte_array()` | Read an integer from the stream.
    `int` | `read_list_head()` | Read a list header from the stream.
    `long` | `read_long()` | Read a long from the stream.
    `long` | `read_long​(boolean unsigned)` |
    `int` | `read_map_head()` |
    `int` | `read_nil()` | Read an empty list from the stream.
    `OtpErlangPid` | `read_pid()` | Read an Erlang PID from the stream.
    `OtpErlangPort` | `read_port()` | Read an Erlang port from the stream.
    `OtpErlangRef` | `read_ref()` | Read an Erlang reference from the stream.
    `short` | `read_short()` | Read a short from the stream.
    `java.lang.String` | `read_string()` | Read a string from the stream.
    `int` | `read_tuple_head()` | Read a tuple header from the stream.
    `int` | `read_uint()` | Read an unsigned integer from the stream.
    `long` | `read_ulong()` | Read an unsigned long from the stream.
    `short` | `read_ushort()` | Read an unsigned short from the stream.
    `int` | `read1()` | Read a one byte integer from the stream.
    `int` | `read1skip_version()` |
    `int` | `read2BE()` | Read a two byte big endian integer from the stream.
    `int` | `read2LE()` | Read a two byte little endian integer from the stream.
    `int` | `read4BE()` | Read a four byte big endian integer from the stream.
    `int` | `read4LE()` | Read a four byte little endian integer from the stream.
    `long` | `read8BE()` | Read a eight byte big endian integer from the stream.
    `long` | `readBE​(int n)` | Read a bigendian integer from the stream.
    `long` | `readLE​(int n)` | Read a little endian integer from the stream.
    `int` | `readN​(byte[] abuf)` | Read an array of bytes from the stream.
    `int` | `readN​(byte[] abuf, int off, int len)` | Read an array of bytes from the stream.
    `int` | `setPos​(int pos)` | Set the current position in the stream.

    - ### Methods inherited from class java.io.ByteArrayInputStream

      `available, close, mark, markSupported, read, read, readAllBytes, readNBytes, reset, skip, transferTo`

    - ### Methods inherited from class java.io.InputStream

      `nullInputStream, read, readNBytes`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### DECODE_INT_LISTS_AS_STRINGS

          public static int DECODE_INT_LISTS_AS_STRINGS

  - ### Constructor Detail

    - #### OtpInputStream

          public OtpInputStream​(byte[] buf)

      Parameters:
        `buf` -

    - #### OtpInputStream

          public OtpInputStream​(byte[] buf,
                                int flags)

      Create a stream from a buffer containing encoded Erlang terms.
      Parameters:
        `flags` -

    - #### OtpInputStream

          public OtpInputStream​(byte[] buf,
                                int offset,
                                int length,
                                int flags)

      Create a stream from a buffer containing encoded Erlang terms at the given offset and length.
      Parameters:
        `flags` -

  - ### Method Detail

    - #### getPos

          public int getPos()

      Get the current position in the stream.
      Returns:
        the current position in the stream.

    - #### setPos

          public int setPos​(int pos)

      Set the current position in the stream.
      Parameters:
        `pos` - the position to move to in the stream. If pos indicates a position beyond the end of the stream, the position is move to the end of the stream instead. If pos is negative, the position is moved to the beginning of the stream instead.
      Returns:
        the previous position in the stream.

    - #### readN

          public int readN​(byte[] abuf)
                    throws OtpErlangDecodeException

      Read an array of bytes from the stream. The method reads at most buf.length bytes from the input stream.
      Returns:
        the number of bytes read.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### readN

          public int readN​(byte[] abuf,
                           int off,
                           int len)
                    throws OtpErlangDecodeException

      Read an array of bytes from the stream. The method reads at most len bytes from the input stream into offset off of the buffer.
      Returns:
        the number of bytes read.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### peek

          public int peek()
                   throws OtpErlangDecodeException

      Alias for peek1()
      Throws:
        `OtpErlangDecodeException`

    - #### peek1

          public int peek1()
                    throws OtpErlangDecodeException

      Look ahead one position in the stream without consuming the byte found there.
      Returns:
        the next byte in the stream, as an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### peek1skip_version

          public int peek1skip_version()
                                throws OtpErlangDecodeException

      Throws:
        `OtpErlangDecodeException`

    - #### read1

          public int read1()
                    throws OtpErlangDecodeException

      Read a one byte integer from the stream.
      Returns:
        the byte read, as an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### read1skip_version

          public int read1skip_version()
                                throws OtpErlangDecodeException

      Throws:
        `OtpErlangDecodeException`

    - #### read2BE

          public int read2BE()
                      throws OtpErlangDecodeException

      Read a two byte big endian integer from the stream.
      Returns:
        the bytes read, converted from big endian to an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### read4BE

          public int read4BE()
                      throws OtpErlangDecodeException

      Read a four byte big endian integer from the stream.
      Returns:
        the bytes read, converted from big endian to an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### read8BE

          public long read8BE()
                       throws OtpErlangDecodeException

      Read a eight byte big endian integer from the stream.
      Returns:
        the bytes read, converted from big endian to a long integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### read2LE

          public int read2LE()
                      throws OtpErlangDecodeException

      Read a two byte little endian integer from the stream.
      Returns:
        the bytes read, converted from little endian to an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### read4LE

          public int read4LE()
                      throws OtpErlangDecodeException

      Read a four byte little endian integer from the stream.
      Returns:
        the bytes read, converted from little endian to an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### readLE

          public long readLE​(int n)
                      throws OtpErlangDecodeException

      Read a little endian integer from the stream.
      Parameters:
        `n` - the number of bytes to read
      Returns:
        the bytes read, converted from little endian to an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### readBE

          public long readBE​(int n)
                      throws OtpErlangDecodeException

      Read a bigendian integer from the stream.
      Parameters:
        `n` - the number of bytes to read
      Returns:
        the bytes read, converted from big endian to an integer.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### read_boolean

          public boolean read_boolean()
                               throws OtpErlangDecodeException

      Read an Erlang atom from the stream and interpret the value as a boolean.
      Returns:
        true if the atom at the current position in the stream contains the value 'true' (ignoring case), false otherwise.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an atom.

    - #### read_atom

          public java.lang.String read_atom()
                                     throws OtpErlangDecodeException

      Read an Erlang atom from the stream.
      Returns:
        a String containing the value of the atom.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an atom.

    - #### read_binary

          public byte[] read_binary()
                             throws OtpErlangDecodeException

      Read an Erlang binary from the stream.
      Returns:
        a byte array containing the value of the binary.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a binary.

    - #### read_bitstr

          public byte[] read_bitstr​(int[] pad_bits)
                             throws OtpErlangDecodeException

      Read an Erlang bitstr from the stream.
      Parameters:
        `pad_bits` - an int array whose first element will be set to the number of pad bits in the last byte.
      Returns:
        a byte array containing the value of the bitstr.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a bitstr.

    - #### read_float

          public float read_float()
                           throws OtpErlangDecodeException

      Read an Erlang float from the stream.
      Returns:
        the float value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a float.

    - #### read_double

          public double read_double()
                             throws OtpErlangDecodeException

      Read an Erlang float from the stream.
      Returns:
        the float value, as a double.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a float.

    - #### read_byte

          public byte read_byte()
                         throws OtpErlangDecodeException

      Read one byte from the stream.
      Returns:
        the byte read.
      Throws:
        `OtpErlangDecodeException` - if the next byte cannot be read.

    - #### read_char

          public char read_char()
                         throws OtpErlangDecodeException

      Read a character from the stream.
      Returns:
        the character value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an integer that can be represented as a char.

    - #### read_uint

          public int read_uint()
                        throws OtpErlangDecodeException

      Read an unsigned integer from the stream.
      Returns:
        the integer value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream cannot be represented as a positive integer.

    - #### read_int

          public int read_int()
                       throws OtpErlangDecodeException

      Read an integer from the stream.
      Returns:
        the integer value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream cannot be represented as an integer.

    - #### read_ushort

          public short read_ushort()
                            throws OtpErlangDecodeException

      Read an unsigned short from the stream.
      Returns:
        the short value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream cannot be represented as a positive short.

    - #### read_short

          public short read_short()
                           throws OtpErlangDecodeException

      Read a short from the stream.
      Returns:
        the short value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream cannot be represented as a short.

    - #### read_ulong

          public long read_ulong()
                          throws OtpErlangDecodeException

      Read an unsigned long from the stream.
      Returns:
        the long value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream cannot be represented as a positive long.

    - #### read_long

          public long read_long()
                         throws OtpErlangDecodeException

      Read a long from the stream.
      Returns:
        the long value.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream cannot be represented as a long.

    - #### read_long

          public long read_long​(boolean unsigned)
                         throws OtpErlangDecodeException

      Throws:
        `OtpErlangDecodeException`

    - #### read_integer_byte_array

          public byte[] read_integer_byte_array()
                                         throws OtpErlangDecodeException

      Read an integer from the stream.
      Returns:
        the value as a big endian 2's complement byte array.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an integer.

    - #### byte_array_to_long

          public static long byte_array_to_long​(byte[] b,
                                                boolean unsigned)
                                         throws OtpErlangDecodeException

      Throws:
        `OtpErlangDecodeException`

    - #### read_list_head

          public int read_list_head()
                             throws OtpErlangDecodeException

      Read a list header from the stream.
      Returns:
        the arity of the list.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a list.

    - #### read_tuple_head

          public int read_tuple_head()
                              throws OtpErlangDecodeException

      Read a tuple header from the stream.
      Returns:
        the arity of the tuple.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a tuple.

    - #### read_nil

          public int read_nil()
                       throws OtpErlangDecodeException

      Read an empty list from the stream.
      Returns:
        zero (the arity of the list).
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an empty list.

    - #### read_pid

          public OtpErlangPid read_pid()
                                throws OtpErlangDecodeException

      Read an Erlang PID from the stream.
      Returns:
        the value of the PID.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an Erlang PID.

    - #### read_port

          public OtpErlangPort read_port()
                                  throws OtpErlangDecodeException

      Read an Erlang port from the stream.
      Returns:
        the value of the port.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an Erlang port.

    - #### read_ref

          public OtpErlangRef read_ref()
                                throws OtpErlangDecodeException

      Read an Erlang reference from the stream.
      Returns:
        the value of the reference
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not an Erlang reference.

    - #### read_fun

          public OtpErlangFun read_fun()
                                throws OtpErlangDecodeException

      Throws:
        `OtpErlangDecodeException`

    - #### read_external_fun

          public OtpErlangExternalFun read_external_fun()
                                                 throws OtpErlangDecodeException

      Throws:
        `OtpErlangDecodeException`

    - #### read_string

          public java.lang.String read_string()
                                       throws OtpErlangDecodeException

      Read a string from the stream.
      Returns:
        the value of the string.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a string.

    - #### read_compressed

          public OtpErlangObject read_compressed()
                                          throws OtpErlangDecodeException

      Read a compressed term from the stream
      Returns:
        the resulting uncompressed term.
      Throws:
        `OtpErlangDecodeException` - if the next term in the stream is not a compressed term.

    - #### read_any

          public OtpErlangObject read_any()
                                   throws OtpErlangDecodeException

      Read an arbitrary Erlang term from the stream.
      Returns:
        the Erlang term.
      Throws:
        `OtpErlangDecodeException` - if the stream does not contain a known Erlang type at the next position.

    - #### read_map_head

          public int read_map_head()
                            throws OtpErlangDecodeException

      Throws:
        `OtpErlangDecodeException`