Package org.xipki.apppackage.jacob

Class CborEncoder

  • public class CborEncoder
extends Object
    Provides an encoder capable of encoding data into CBOR format to a given OutputStream.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void writeArrayStart()
      Writes the start of an indefinite-length array.
      void writeArrayStart​(int length)
      Writes the start of a definite-length array.
      void writeBoolean​(boolean value)
      Writes a boolean value in canonical CBOR format.
      void writeBreak()
      Writes a "break" stop-value in canonical CBOR format.
      void writeByteString​(byte[] bytes)
      Writes a byte string in canonical CBOR-format.
      void writeByteStringStart()
      Writes the start of an indefinite-length byte string.
      void writeDouble​(double value)
      Writes a double-precision float value in canonical CBOR format.
      void writeFloat​(float value)
      Writes a single-precision float value in canonical CBOR format.
      void writeHalfPrecisionFloat​(float value)
      Writes a half-precision float value in canonical CBOR format.
      void writeInt​(long value)
      Writes a signed or unsigned integer value in canonical CBOR format, that is, tries to encode it in a little bytes as possible..
      void writeInt16​(int value)
      Writes a signed or unsigned 16-bit integer value in CBOR format.
      void writeInt32​(long value)
      Writes a signed or unsigned 32-bit integer value in CBOR format.
      void writeInt64​(long value)
      Writes a signed or unsigned 64-bit integer value in CBOR format.
      void writeInt8​(int value)
      Writes a signed or unsigned 8-bit integer value in CBOR format.
      void writeMapStart()
      Writes the start of an indefinite-length map.
      void writeMapStart​(int length)
      Writes the start of a finite-length map.
      void writeNull()
      Writes a null value in canonical CBOR format.
      protected void writeSimpleType​(int majorType, int value)
      Encodes and writes the major type and value as a simple type.
      void writeSimpleValue​(byte simpleValue)
      Writes a simple value, i.e., an "atom" or "constant" value in canonical CBOR format.
      void writeSmallInt​(int value)
      Writes a signed or unsigned small (<= 23) integer value in CBOR format.
      protected void writeString​(int majorType, byte[] bytes)
      Writes a byte string in canonical CBOR-format.
      void writeTag​(long tag)
      Writes a semantic tag in canonical CBOR format.
      void writeTextString​(String value)
      Writes an UTF-8 string in canonical CBOR-format.
      void writeTextStringStart()
      Writes the start of an indefinite-length UTF-8 string.
      protected void writeType​(int majorType, long value)
      Encodes and writes the major type indicator with a given payload (length).
      protected void writeUInt​(int mt, long value)
      Encodes and writes an unsigned integer value, that is, tries to encode it in a little bytes as possible.
      protected void writeUInt16​(int mt, int value)
      Encodes and writes an unsigned 16-bit integer value
      protected void writeUInt32​(int mt, int value)
      Encodes and writes an unsigned 32-bit integer value
      protected void writeUInt64​(int mt, long value)
      Encodes and writes an unsigned 64-bit integer value
      protected void writeUInt8​(int mt, int value)
      Encodes and writes an unsigned 8-bit integer value
      void writeUndefined()
      Writes an "undefined" value in canonical CBOR format.

    • Constructor Detail

      • CborEncoder

        public CborEncoder​(OutputStream os)
        Creates a new CborEncoder instance.
        Parameters:
        os - the actual output stream to write the CBOR-encoded data to, cannot be null.

    • Method Detail

      • writeArrayStart

        public void writeArrayStart()
                     throws IOException
        Writes the start of an indefinite-length array.

        After calling this method, one is expected to write the given number of array elements, which can be of any type. No length checks are performed.

        After all array elements are written, one should write a single break value to end the array, see writeBreak().

        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeArrayStart

        public void writeArrayStart​(int length)
                     throws IOException
        Writes the start of a definite-length array.

        After calling this method, one is expected to write the given number of array elements, which can be of any type. No length checks are performed.

        Parameters:
        length - the number of array elements to write, should >= 0.
        Throws:
        IllegalArgumentException - in case the given length was negative;
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeBoolean

        public void writeBoolean​(boolean value)
                  throws IOException
        Writes a boolean value in canonical CBOR format.
        Parameters:
        value - the boolean to write.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeBreak

        public void writeBreak()
                throws IOException
        Writes a "break" stop-value in canonical CBOR format.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeByteString

        public void writeByteString​(byte[] bytes)
                     throws IOException
        Writes a byte string in canonical CBOR-format.
        Parameters:
        bytes - the byte string to write, can be null in which case a byte-string of length 0 is written.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeByteStringStart

        public void writeByteStringStart()
                          throws IOException
        Writes the start of an indefinite-length byte string.

        After calling this method, one is expected to write the given number of string parts. No length checks are performed.

        After all string parts are written, one should write a single break value to end the string, see writeBreak().

        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeDouble

        public void writeDouble​(double value)
                 throws IOException
        Writes a double-precision float value in canonical CBOR format.
        Parameters:
        value - the value to write, values from Double.MIN_VALUE to Double.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeFloat

        public void writeFloat​(float value)
                throws IOException
        Writes a single-precision float value in canonical CBOR format.
        Parameters:
        value - the value to write, values from Float.MIN_VALUE to Float.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeHalfPrecisionFloat

        public void writeHalfPrecisionFloat​(float value)
                             throws IOException
        Writes a half-precision float value in canonical CBOR format.
        Parameters:
        value - the value to write, values from Float.MIN_VALUE to Float.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeInt

        public void writeInt​(long value)
              throws IOException
        Writes a signed or unsigned integer value in canonical CBOR format, that is, tries to encode it in a little bytes as possible..
        Parameters:
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeInt16

        public void writeInt16​(int value)
                throws IOException
        Writes a signed or unsigned 16-bit integer value in CBOR format.
        Parameters:
        value - the value to write, values from [-65536..65535] are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeInt32

        public void writeInt32​(long value)
                throws IOException
        Writes a signed or unsigned 32-bit integer value in CBOR format.
        Parameters:
        value - the value to write, values in the range [-4294967296..4294967295] are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeInt64

        public void writeInt64​(long value)
                throws IOException
        Writes a signed or unsigned 64-bit integer value in CBOR format.
        Parameters:
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeInt8

        public void writeInt8​(int value)
               throws IOException
        Writes a signed or unsigned 8-bit integer value in CBOR format.
        Parameters:
        value - the value to write, values in the range [-256..255] are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeMapStart

        public void writeMapStart()
                   throws IOException
        Writes the start of an indefinite-length map.

        After calling this method, one is expected to write any number of map entries, as separate key and value. Keys and values can both be of any type. No length checks are performed.

        After all map entries are written, one should write a single break value to end the map, see writeBreak().

        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeMapStart

        public void writeMapStart​(int length)
                   throws IOException
        Writes the start of a finite-length map.

        After calling this method, one is expected to write any number of map entries, as separate key and value. Keys and values can both be of any type. No length checks are performed.

        Parameters:
        length - the number of map entries to write, should >= 0.
        Throws:
        IllegalArgumentException - in case the given length was negative;
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeNull

        public void writeNull()
               throws IOException
        Writes a null value in canonical CBOR format.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeSimpleValue

        public void writeSimpleValue​(byte simpleValue)
                      throws IOException
        Writes a simple value, i.e., an "atom" or "constant" value in canonical CBOR format.
        Parameters:
        simpleValue - the (unsigned byte) value to write, values from 32 to 255 are supported (though not enforced).
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeSmallInt

        public void writeSmallInt​(int value)
                   throws IOException
        Writes a signed or unsigned small (<= 23) integer value in CBOR format.
        Parameters:
        value - the value to write, values in the range [-24..23] are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeTag

        public void writeTag​(long tag)
              throws IOException
        Writes a semantic tag in canonical CBOR format.
        Parameters:
        tag - the tag to write, should >= 0.
        Throws:
        IllegalArgumentException - in case the given tag was negative;
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeTextString

        public void writeTextString​(String value)
                     throws IOException
        Writes an UTF-8 string in canonical CBOR-format.

        Note that this method is platform specific, as the given string value will be encoded in a byte array using the platform encoding! This means that the encoding must be standardized and known.

        Parameters:
        value - the UTF-8 string to write, can be null in which case an UTF-8 string of length 0 is written.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeTextStringStart

        public void writeTextStringStart()
                          throws IOException
        Writes the start of an indefinite-length UTF-8 string.

        After calling this method, one is expected to write the given number of string parts. No length checks are performed.

        After all string parts are written, one should write a single break value to end the string, see writeBreak().

        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeUndefined

        public void writeUndefined()
                    throws IOException
        Writes an "undefined" value in canonical CBOR format.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeSimpleType

        protected void writeSimpleType​(int majorType,
                               int value)
                        throws IOException
        Encodes and writes the major type and value as a simple type.
        Parameters:
        majorType - the major type of the value to write, denotes what semantics the written value has;
        value - the value to write, values from [0..31] are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeString

        protected void writeString​(int majorType,
                           byte[] bytes)
                    throws IOException
        Writes a byte string in canonical CBOR-format.
        Parameters:
        majorType - the major type of the string, should be either 0x40 or 0x60;
        bytes - the byte string to write, can be null in which case a byte-string of length 0 is written.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeType

        protected void writeType​(int majorType,
                         long value)
                  throws IOException
        Encodes and writes the major type indicator with a given payload (length).
        Parameters:
        majorType - the major type of the value to write, denotes what semantics the written value has;
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeUInt

        protected void writeUInt​(int mt,
                         long value)
                  throws IOException
        Encodes and writes an unsigned integer value, that is, tries to encode it in a little bytes as possible.
        Parameters:
        mt - the major type of the value to write, denotes what semantics the written value has;
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeUInt16

        protected void writeUInt16​(int mt,
                           int value)
                    throws IOException
        Encodes and writes an unsigned 16-bit integer value
        Parameters:
        mt - the major type of the value to write, denotes what semantics the written value has;
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeUInt32

        protected void writeUInt32​(int mt,
                           int value)
                    throws IOException
        Encodes and writes an unsigned 32-bit integer value
        Parameters:
        mt - the major type of the value to write, denotes what semantics the written value has;
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeUInt64

        protected void writeUInt64​(int mt,
                           long value)
                    throws IOException
        Encodes and writes an unsigned 64-bit integer value
        Parameters:
        mt - the major type of the value to write, denotes what semantics the written value has;
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.

      • writeUInt8

        protected void writeUInt8​(int mt,
                          int value)
                   throws IOException
        Encodes and writes an unsigned 8-bit integer value
        Parameters:
        mt - the major type of the value to write, denotes what semantics the written value has;
        value - the value to write, values from Long.MIN_VALUE to Long.MAX_VALUE are supported.
        Throws:
        IOException - in case of I/O problems writing the CBOR-encoded value to the underlying output stream.