org.firebirdsql.gds.ng

## Class DefaultDatatypeCoder

- java.lang.Object
- - org.firebirdsql.gds.ng.DefaultDatatypeCoder

- All Implemented Interfaces:
    DatatypeCoder
  Direct Known Subclasses:
    BigEndianDatatypeCoder, LittleEndianDatatypeCoder

      public class DefaultDatatypeCoder
      extends java.lang.Object
      implements DatatypeCoder

  The default datatype coder.

  Implements the encoding and decoding for the wire protocol.

  As a lot of the implementation also applies to the big endian and little endian decoders for the JNA implementation, this class is not placed in package `org.firebirdsql.gds.ng.wire`

  Since:
    3.0
  Author:
    Mark Rotteveel

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.firebirdsql.gds.ng.DatatypeCoder

      `DatatypeCoder.RawDateTimeStruct`

  - ### Field Summary

    - ### Fields inherited from interface org.firebirdsql.gds.ng.DatatypeCoder

      `FRACTIONS_PER_HOUR, FRACTIONS_PER_MILLISECOND, FRACTIONS_PER_MINUTE, FRACTIONS_PER_SECOND, NANOSECONDS_PER_FRACTION`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DefaultDatatypeCoder(IEncodingFactory encodingFactory)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `decodeBoolean(byte[] data)` Decode boolean from supplied data.
    `java.sql.Date` | `decodeDate(byte[] byte_int)` Decode a `byte` array into a `Date` value.
    `java.sql.Date` | `decodeDate(java.sql.Date d, java.util.Calendar cal)` Decode a `Date` value using a given `Calendar`.
    `java.sql.Date` | `decodeDateCalendar(byte[] byte_int, java.util.Calendar c)`
    `DatatypeCoder.RawDateTimeStruct` | `decodeDateRaw(byte[] byte_int)` Decode a `byte` array into a raw date time struct.
    `double` | `decodeDouble(byte[] byte_int)` Decode a `byte` array into a `double` value.
    `float` | `decodeFloat(byte[] byte_int)` Decode a `byte` array into a `float` value.
    `int` | `decodeInt(byte[] byte_int)` Decode a `byte` array into an `int` value.
    `long` | `decodeLong(byte[] byte_int)` Decode a `byte` array into a `long` value.
    `short` | `decodeShort(byte[] byte_int)` Decode a `byte` array into a `short` value.
    `java.lang.String` | `decodeString(byte[] value, Encoding encoding, java.lang.String mappingPath)`
    `java.lang.String` | `decodeString(byte[] value, java.lang.String javaEncoding, java.lang.String mappingPath)` Decode an encoded `byte` array into a `String` using a given encoding.
    `java.sql.Time` | `decodeTime(byte[] int_byte)` Decode a `byte` array into a `Time` value.
    `java.sql.Time` | `decodeTime(java.sql.Time d, java.util.Calendar cal, boolean invertTimeZone)` Decode a `Time` value using a given `Calendar`.
    `java.sql.Time` | `decodeTimeCalendar(byte[] int_byte, java.util.Calendar c)`
    `DatatypeCoder.RawDateTimeStruct` | `decodeTimeRaw(byte[] int_byte)` Decode a `byte` array into a raw date time struct.
    `java.sql.Timestamp` | `decodeTimestamp(byte[] byte_long)` Decode a 8-byte `byte` array into a `Timestamp`.
    `java.sql.Timestamp` | `decodeTimestamp(java.sql.Timestamp value, java.util.Calendar cal)` Decode a `Timestamp` value using a given `Calendar`.
    `java.sql.Timestamp` | `decodeTimestamp(java.sql.Timestamp value, java.util.Calendar cal, boolean invertTimeZone)` Decode a `Timestamp` value using a given `Calendar`.
    `java.sql.Timestamp` | `decodeTimestampCalendar(byte[] byte_long, java.util.Calendar c)`
    `DatatypeCoder.RawDateTimeStruct` | `decodeTimestampRaw(byte[] byte_long)` Decode a 8-byte `byte` array into a raw date time struct.
    `byte[]` | `encodeBoolean(boolean value)` Encodes boolean to 1 byte data.
    `byte[]` | `encodeDate(java.sql.Date d)` Encode a `Date` value into a `byte` array.
    `java.sql.Date` | `encodeDate(java.sql.Date d, java.util.Calendar cal)` Encode a given `Date` value using a given `Calendar`.
    `byte[]` | `encodeDateCalendar(java.sql.Date d, java.util.Calendar c)`
    `byte[]` | `encodeDateRaw(DatatypeCoder.RawDateTimeStruct raw)` Encode the date portion of a raw date time struct into a `byte` array.
    `byte[]` | `encodeDouble(double value)` Encode a `double` value as a `byte` array.
    `byte[]` | `encodeFloat(float value)` Encode a `float` value as a `byte` array.
    `byte[]` | `encodeInt(int value)` Encode an `int` value as a `byte` array.
    `byte[]` | `encodeLocalDate(int year, int month, int day)` Encodes a java.time.LocalDate equivalent to date bytes.
    `byte[]` | `encodeLocalDateTime(int year, int month, int day, int hour, int minute, int second, int nanos)` Encodes a java.time.LocalDateTime equivalent to timestamp bytes.
    `byte[]` | `encodeLocalTime(int hour, int minute, int second, int nanos)` Encodes a java.time.LocalTime equivalent to time bytes.
    `byte[]` | `encodeLong(long value)` Encode a `long` value as a `byte` array.
    `byte[]` | `encodeShort(int value)` Encode a `short` value as a `byte` array.
    `byte[]` | `encodeShort(short value)` Encode a `short` value as a `byte` array.
    `byte[]` | `encodeString(java.lang.String value, Encoding encoding, java.lang.String mappingPath)`
    `byte[]` | `encodeString(java.lang.String value, java.lang.String javaEncoding, java.lang.String mappingPath)` Encode a `String` value into a `byte` array using a given encoding.
    `byte[]` | `encodeTime(java.sql.Time d)` Encode a `Time` value into a `byte` array.
    `java.sql.Time` | `encodeTime(java.sql.Time d, java.util.Calendar cal, boolean invertTimeZone)` Encode a given `Time` value using a given `Calendar`.
    `byte[]` | `encodeTimeCalendar(java.sql.Time d, java.util.Calendar c)`
    `byte[]` | `encodeTimeRaw(DatatypeCoder.RawDateTimeStruct raw)` Encode the time portion of a raw date time struct into a `byte` array.
    `byte[]` | `encodeTimestamp(java.sql.Timestamp value)` Encode a `Timestamp` as a `byte` array.
    `java.sql.Timestamp` | `encodeTimestamp(java.sql.Timestamp value, java.util.Calendar cal)` Encode a `Timestamp` using a given `Calendar`.
    `java.sql.Timestamp` | `encodeTimestamp(java.sql.Timestamp value, java.util.Calendar cal, boolean invertTimeZone)` Encode a `Timestamp` using a given `Calendar`.
    `byte[]` | `encodeTimestampCalendar(java.sql.Timestamp value, java.util.Calendar c)`
    `byte[]` | `encodeTimestampRaw(DatatypeCoder.RawDateTimeStruct raw)` Encode the date and time portions of a raw date time struct into a `byte` array.
    `IEncodingFactory` | `getEncodingFactory()`
    `protected byte[]` | `intToBytes(int value)` Encode an `int` value as a `byte` array in network-order(big-endian) representation.

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

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

- - ### Constructor Detail

    - #### DefaultDatatypeCoder

          public DefaultDatatypeCoder(IEncodingFactory encodingFactory)

  - ### Method Detail

    - #### encodeShort

          public byte[] encodeShort(short value)

      Description copied from interface: `DatatypeCoder`
      Encode a `short` value as a `byte` array.
      Specified by:
        `encodeShort` in interface `DatatypeCoder`
      Parameters:
        `value` - The value to be encoded
      Returns:
        The value of `value` encoded as a `byte` array
      See Also:
        `DatatypeCoder.encodeShort(int)`

    - #### encodeShort

          public byte[] encodeShort(int value)

      Description copied from interface: `DatatypeCoder`
      Encode a `short` value as a `byte` array.
      Specified by:
        `encodeShort` in interface `DatatypeCoder`
      Parameters:
        `value` - The value to be encoded
      Returns:
        The value of `value` encoded as a `byte` array

    - #### decodeShort

          public short decodeShort(byte[] byte_int)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a `short` value.
      Specified by:
        `decodeShort` in interface `DatatypeCoder`
      Parameters:
        `byte_int` - The `byte` array to be decoded
      Returns:
        The `short` value of the decoded `byte` array

    - #### encodeInt

          public byte[] encodeInt(int value)

      Description copied from interface: `DatatypeCoder`
      Encode an `int` value as a `byte` array.
      Specified by:
        `encodeInt` in interface `DatatypeCoder`
      Parameters:
        `value` - The value to be encoded
      Returns:
        The value of `value` encoded as a `byte` array

    - #### intToBytes

          protected byte[] intToBytes(int value)

      Encode an `int` value as a `byte` array in network-order(big-endian) representation.
      Parameters:
        `value` - The value to be encoded
      Returns:
        The value of `value` encoded as a `byte` array

    - #### decodeInt

          public int decodeInt(byte[] byte_int)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into an `int` value.
      Specified by:
        `decodeInt` in interface `DatatypeCoder`
      Parameters:
        `byte_int` - The `byte` array to be decoded
      Returns:
        The `int` value of the decoded `byte` array

    - #### encodeLong

          public byte[] encodeLong(long value)

      Description copied from interface: `DatatypeCoder`
      Encode a `long` value as a `byte` array.
      Specified by:
        `encodeLong` in interface `DatatypeCoder`
      Parameters:
        `value` - The value to be encoded
      Returns:
        The value of `value` encoded as a `byte` array

    - #### decodeLong

          public long decodeLong(byte[] byte_int)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a `long` value.
      Specified by:
        `decodeLong` in interface `DatatypeCoder`
      Parameters:
        `byte_int` - The `byte` array to be decoded
      Returns:
        The `long` value of the decoded `byte` array

    - #### encodeFloat

          public byte[] encodeFloat(float value)

      Description copied from interface: `DatatypeCoder`
      Encode a `float` value as a `byte` array.
      Specified by:
        `encodeFloat` in interface `DatatypeCoder`
      Parameters:
        `value` - The value to be encoded
      Returns:
        The value of `value` encoded as a `byte` array

    - #### decodeFloat

          public float decodeFloat(byte[] byte_int)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a `float` value.
      Specified by:
        `decodeFloat` in interface `DatatypeCoder`
      Parameters:
        `byte_int` - The `byte` array to be decoded
      Returns:
        The `float` value of the decoded `byte` array

    - #### encodeDouble

          public byte[] encodeDouble(double value)

      Description copied from interface: `DatatypeCoder`
      Encode a `double` value as a `byte` array.
      Specified by:
        `encodeDouble` in interface `DatatypeCoder`
      Parameters:
        `value` - The value to be encoded
      Returns:
        The value of `value` encoded as a `byte` array

    - #### decodeDouble

          public double decodeDouble(byte[] byte_int)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a `double` value.
      Specified by:
        `decodeDouble` in interface `DatatypeCoder`
      Parameters:
        `byte_int` - The `byte` array to be decoded
      Returns:
        The `double` value of the decoded `byte` array

    - #### encodeString

          public byte[] encodeString(java.lang.String value,
                                     java.lang.String javaEncoding,
                                     java.lang.String mappingPath)
                              throws java.sql.SQLException

      Description copied from interface: `DatatypeCoder`
      Encode a `String` value into a `byte` array using a given encoding.
      Specified by:
        `encodeString` in interface `DatatypeCoder`
      Parameters:
        `value` - The `String` to be encoded
        `javaEncoding` - The java encoding to use in the encoding process
        `mappingPath` - The character mapping path to be used in the encoding
      Returns:
        The value of `value` as a `byte` array
      Throws:
        `java.sql.SQLException` - if the given encoding cannot be found, or an error occurs during the encoding

    - #### encodeString

          public byte[] encodeString(java.lang.String value,
                                     Encoding encoding,
                                     java.lang.String mappingPath)
                              throws java.sql.SQLException

      Specified by:
        `encodeString` in interface `DatatypeCoder`
      Throws:
        `java.sql.SQLException`

    - #### decodeString

          public java.lang.String decodeString(byte[] value,
                                               java.lang.String javaEncoding,
                                               java.lang.String mappingPath)
                                        throws java.sql.SQLException

      Description copied from interface: `DatatypeCoder`
      Decode an encoded `byte` array into a `String` using a given encoding.
      Specified by:
        `decodeString` in interface `DatatypeCoder`
      Parameters:
        `value` - The value to be decoded
        `javaEncoding` - The java encoding to be used in the decoding process
        `mappingPath` - The character mapping path to be used in the decoding
      Returns:
        The decoded `String`
      Throws:
        `java.sql.SQLException` - if the given encoding cannot be found, or an error occurs during the decoding

    - #### decodeString

          public java.lang.String decodeString(byte[] value,
                                               Encoding encoding,
                                               java.lang.String mappingPath)
                                        throws java.sql.SQLException

      Specified by:
        `decodeString` in interface `DatatypeCoder`
      Throws:
        `java.sql.SQLException`

    - #### encodeTimestamp

          public java.sql.Timestamp encodeTimestamp(java.sql.Timestamp value,
                                                    java.util.Calendar cal)

      Description copied from interface: `DatatypeCoder`
      Encode a `Timestamp` using a given `Calendar`.
      Specified by:
        `encodeTimestamp` in interface `DatatypeCoder`
      Parameters:
        `value` - The `Timestamp` to be encoded
        `cal` - The `Calendar` to be used for encoding, may be `null`

    - #### encodeTimestamp

          public java.sql.Timestamp encodeTimestamp(java.sql.Timestamp value,
                                                    java.util.Calendar cal,
                                                    boolean invertTimeZone)

      Description copied from interface: `DatatypeCoder`
      Encode a `Timestamp` using a given `Calendar`.
      Specified by:
        `encodeTimestamp` in interface `DatatypeCoder`
      Parameters:
        `value` - The `Timestamp` to be encoded
        `cal` - The `Calendar` to be used for encoding, may be `null`
        `invertTimeZone` - If `true`, the timezone offset value will be subtracted from the encoded value, otherwise it will be added
      Returns:
        The encoded `Timestamp`

    - #### encodeTimestamp

          public byte[] encodeTimestamp(java.sql.Timestamp value)

      Description copied from interface: `DatatypeCoder`
      Encode a `Timestamp` as a `byte` array.
      Specified by:
        `encodeTimestamp` in interface `DatatypeCoder`
      Parameters:
        `value` - The `Timestamp` to be encoded
      Returns:
        The array of `byte`s that represents the given `Timestamp` value

    - #### encodeTimestampRaw

          public byte[] encodeTimestampRaw(DatatypeCoder.RawDateTimeStruct raw)

      Description copied from interface: `DatatypeCoder`
      Encode the date and time portions of a raw date time struct into a `byte` array.
      Specified by:
        `encodeTimestampRaw` in interface `DatatypeCoder`
      Parameters:
        `raw` - The `RawDateTimeStruct` to be encoded
      Returns:
        The array of `byte`s representing the date and time of the given `RawDateTimeStruct`

    - #### encodeTimestampCalendar

          public byte[] encodeTimestampCalendar(java.sql.Timestamp value,
                                                java.util.Calendar c)

      Specified by:
        `encodeTimestampCalendar` in interface `DatatypeCoder`

    - #### decodeTimestamp

          public java.sql.Timestamp decodeTimestamp(java.sql.Timestamp value,
                                                    java.util.Calendar cal)

      Description copied from interface: `DatatypeCoder`
      Decode a `Timestamp` value using a given `Calendar`.
      Specified by:
        `decodeTimestamp` in interface `DatatypeCoder`
      Parameters:
        `value` - The `Timestamp` to be decoded
        `cal` - The `Calendar` to be used in decoding, may be `null`
      Returns:
        The decoded `Timestamp`

    - #### decodeTimestamp

          public java.sql.Timestamp decodeTimestamp(java.sql.Timestamp value,
                                                    java.util.Calendar cal,
                                                    boolean invertTimeZone)

      Description copied from interface: `DatatypeCoder`
      Decode a `Timestamp` value using a given `Calendar`.
      Specified by:
        `decodeTimestamp` in interface `DatatypeCoder`
      Parameters:
        `value` - The `Timestamp` to be decoded
        `cal` - The `Calendar` to be used in decoding, may be `null`
        `invertTimeZone` - If `true`, the timezone offset value will be subtracted from the decoded value, otherwise it will be added
      Returns:
        The encoded `Timestamp`

    - #### decodeTimestamp

          public java.sql.Timestamp decodeTimestamp(byte[] byte_long)

      Description copied from interface: `DatatypeCoder`
      Decode a 8-byte `byte` array into a `Timestamp`.
      Specified by:
        `decodeTimestamp` in interface `DatatypeCoder`
      Parameters:
        `byte_long` - The `byte` array to be decoded
      Returns:
        A `Timestamp` value from the decoded bytes

    - #### decodeTimestampRaw

          public DatatypeCoder.RawDateTimeStruct decodeTimestampRaw(byte[] byte_long)

      Description copied from interface: `DatatypeCoder`
      Decode a 8-byte `byte` array into a raw date time struct.
      Specified by:
        `decodeTimestampRaw` in interface `DatatypeCoder`
      Parameters:
        `byte_long` - The `byte` array to be decoded
      Returns:
        A `DatatypeCoder.RawDateTimeStruct`.

    - #### decodeTimestampCalendar

          public java.sql.Timestamp decodeTimestampCalendar(byte[] byte_long,
                                                            java.util.Calendar c)

      Specified by:
        `decodeTimestampCalendar` in interface `DatatypeCoder`

    - #### encodeTime

          public java.sql.Time encodeTime(java.sql.Time d,
                                          java.util.Calendar cal,
                                          boolean invertTimeZone)

      Description copied from interface: `DatatypeCoder`
      Encode a given `Time` value using a given `Calendar`.
      Specified by:
        `encodeTime` in interface `DatatypeCoder`
      Parameters:
        `d` - The `Time` to be encoded
        `cal` - The `Calendar` to be used in the encoding, may be `null`
      Returns:
        The encoded `Time`

    - #### encodeTime

          public byte[] encodeTime(java.sql.Time d)

      Description copied from interface: `DatatypeCoder`
      Encode a `Time` value into a `byte` array.
      Specified by:
        `encodeTime` in interface `DatatypeCoder`
      Parameters:
        `d` - The `Time` to be encoded
      Returns:
        The array of `byte`s representing the given `Time`

    - #### encodeTimeRaw

          public byte[] encodeTimeRaw(DatatypeCoder.RawDateTimeStruct raw)

      Description copied from interface: `DatatypeCoder`
      Encode the time portion of a raw date time struct into a `byte` array.
      Specified by:
        `encodeTimeRaw` in interface `DatatypeCoder`
      Parameters:
        `raw` - The `RawDateTimeStruct` to be encoded
      Returns:
        The array of `byte`s representing the time of the given `RawDateTimeStruct`

    - #### encodeTimeCalendar

          public byte[] encodeTimeCalendar(java.sql.Time d,
                                           java.util.Calendar c)

      Specified by:
        `encodeTimeCalendar` in interface `DatatypeCoder`

    - #### decodeTime

          public java.sql.Time decodeTime(java.sql.Time d,
                                          java.util.Calendar cal,
                                          boolean invertTimeZone)

      Description copied from interface: `DatatypeCoder`
      Decode a `Time` value using a given `Calendar`.
      Specified by:
        `decodeTime` in interface `DatatypeCoder`
      Parameters:
        `d` - The `Time` to be decoded
        `cal` - The `Calendar` to be used in the decoding, may be `null`
      Returns:
        The decooded `Time`

    - #### decodeTime

          public java.sql.Time decodeTime(byte[] int_byte)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a `Time` value.
      Specified by:
        `decodeTime` in interface `DatatypeCoder`
      Parameters:
        `int_byte` - The `byte` array to be decoded
      Returns:
        The decoded `Time`

    - #### decodeTimeRaw

          public DatatypeCoder.RawDateTimeStruct decodeTimeRaw(byte[] int_byte)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a raw date time struct.
      Specified by:
        `decodeTimeRaw` in interface `DatatypeCoder`
      Parameters:
        `int_byte` - The `byte` array to be decoded
      Returns:
        The `DatatypeCoder.RawDateTimeStruct`

    - #### decodeTimeCalendar

          public java.sql.Time decodeTimeCalendar(byte[] int_byte,
                                                  java.util.Calendar c)

      Specified by:
        `decodeTimeCalendar` in interface `DatatypeCoder`

    - #### encodeDate

          public java.sql.Date encodeDate(java.sql.Date d,
                                          java.util.Calendar cal)

      Description copied from interface: `DatatypeCoder`
      Encode a given `Date` value using a given `Calendar`.
      Specified by:
        `encodeDate` in interface `DatatypeCoder`
      Parameters:
        `d` - The `Date` to be encoded
        `cal` - The `Calendar` to be used in the encoding, may be `null`
      Returns:
        The encoded `Date`

    - #### encodeDate

          public byte[] encodeDate(java.sql.Date d)

      Description copied from interface: `DatatypeCoder`
      Encode a `Date` value into a `byte` array.
      Specified by:
        `encodeDate` in interface `DatatypeCoder`
      Parameters:
        `d` - The `Date` to be encoded
      Returns:
        The array of `byte`s representing the given `Date`

    - #### encodeDateRaw

          public byte[] encodeDateRaw(DatatypeCoder.RawDateTimeStruct raw)

      Description copied from interface: `DatatypeCoder`
      Encode the date portion of a raw date time struct into a `byte` array.
      Specified by:
        `encodeDateRaw` in interface `DatatypeCoder`
      Parameters:
        `raw` - The `RawDateTimeStruct` to be encoded
      Returns:
        The array of `byte`s representing the date of the given `RawDateTimeStruct`

    - #### encodeDateCalendar

          public byte[] encodeDateCalendar(java.sql.Date d,
                                           java.util.Calendar c)

      Specified by:
        `encodeDateCalendar` in interface `DatatypeCoder`

    - #### decodeDate

          public java.sql.Date decodeDate(java.sql.Date d,
                                          java.util.Calendar cal)

      Description copied from interface: `DatatypeCoder`
      Decode a `Date` value using a given `Calendar`.
      Specified by:
        `decodeDate` in interface `DatatypeCoder`
      Parameters:
        `d` - The `Date` to be decoded
        `cal` - The `Calendar` to be used in the decoding, may be `null`
      Returns:
        The decoded `Date`

    - #### decodeDate

          public java.sql.Date decodeDate(byte[] byte_int)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a `Date` value.
      Specified by:
        `decodeDate` in interface `DatatypeCoder`
      Parameters:
        `byte_int` - The `byte` array to be decoded
      Returns:
        The decoded `Date`

    - #### decodeDateRaw

          public DatatypeCoder.RawDateTimeStruct decodeDateRaw(byte[] byte_int)

      Description copied from interface: `DatatypeCoder`
      Decode a `byte` array into a raw date time struct.
      Specified by:
        `decodeDateRaw` in interface `DatatypeCoder`
      Parameters:
        `byte_int` - The `byte` array to be decoded
      Returns:
        The `DatatypeCoder.RawDateTimeStruct`

    - #### decodeDateCalendar

          public java.sql.Date decodeDateCalendar(byte[] byte_int,
                                                  java.util.Calendar c)

      Specified by:
        `decodeDateCalendar` in interface `DatatypeCoder`

    - #### decodeBoolean

          public boolean decodeBoolean(byte[] data)

      Description copied from interface: `DatatypeCoder`
      Decode boolean from supplied data.
      Specified by:
        `decodeBoolean` in interface `DatatypeCoder`
      Parameters:
        `data` - (expected) 1 bytes
      Returns:
        `false` when 0, `true` for all other values

    - #### encodeBoolean

          public byte[] encodeBoolean(boolean value)

      Description copied from interface: `DatatypeCoder`
      Encodes boolean to 1 byte data.
      Specified by:
        `encodeBoolean` in interface `DatatypeCoder`
      Parameters:
        `value` - Boolean value to encode
      Returns:
        `true` as 1, `false` as 0.

    - #### encodeLocalTime

          public byte[] encodeLocalTime(int hour,
                                        int minute,
                                        int second,
                                        int nanos)

      Description copied from interface: `DatatypeCoder`
      Encodes a java.time.LocalTime equivalent to time bytes.
      Specified by:
        `encodeLocalTime` in interface `DatatypeCoder`
      Parameters:
        `hour` - Number of hours (is assumed to be 0..23)
        `minute` - Number of minutes (is assumed to be 0..59)
        `second` - Number of seconds (is assumed to be 0..59)
        `nanos` - Sub-second nanoseconds (actual resolution is 100 microseconds, is assumed to be 0 .. 10^9 - 1 ns)
      Returns:
        Byte array for time

    - #### encodeLocalDate

          public byte[] encodeLocalDate(int year,
                                        int month,
                                        int day)

      Description copied from interface: `DatatypeCoder`
      Encodes a java.time.LocalDate equivalent to date bytes.
      Specified by:
        `encodeLocalDate` in interface `DatatypeCoder`
      Parameters:
        `year` - Year
        `month` - Month (is assumed to be 1..12)
        `day` - Day (is assumed to be valid for year and month)
      Returns:
        Byte array for date

    - #### encodeLocalDateTime

          public byte[] encodeLocalDateTime(int year,
                                            int month,
                                            int day,
                                            int hour,
                                            int minute,
                                            int second,
                                            int nanos)

      Description copied from interface: `DatatypeCoder`
      Encodes a java.time.LocalDateTime equivalent to timestamp bytes.
      Specified by:
        `encodeLocalDateTime` in interface `DatatypeCoder`
      Parameters:
        `year` - Year
        `month` - Month (is assumed to be 1..12)
        `day` - Day (is assumed to be valid for year and month)
        `hour` - Number of hours (is assumed to be 0..23)
        `minute` - Number of minutes (is assumed to be 0..59)
        `second` - Number of seconds (is assumed to be 0..59)
        `nanos` - Sub-second nanoseconds (actual resolution is 100 microseconds, is assumed to be 0 .. 10^9 - 1 ns)
      Returns:
        Byte array for timestamp

    - #### getEncodingFactory

          public IEncodingFactory getEncodingFactory()

      Specified by:
        `getEncodingFactory` in interface `DatatypeCoder`
      Returns:
        The encoding factory.

Copyright © 2001-2021 Jaybird (Firebird JDBC/JCA) team. All rights reserved.