Add back support for BigDecimal now that key encoding works correctly.

6 files changed, 286 insertions, 227 deletions

diff --git a/src/main/java/com/amazon/carbonado/raw/DataDecoder.java b/src/main/java/com/amazon/carbonado/raw/DataDecoder.java
index ce5b7c9..407df0c 100644
--- a/src/main/java/com/amazon/carbonado/raw/DataDecoder.java
+++ b/src/main/java/com/amazon/carbonado/raw/DataDecoder.java
@@ -400,7 +400,7 @@ public class DataDecoder {
      * @return amount of bytes read from source

      * @throws CorruptEncodingException if source data is corrupt

      * @since 1.2

-     * /

+     */

     public static int decode(byte[] src, int srcOffset, BigDecimal[] valueRef)

         throws CorruptEncodingException

     {

@@ -446,7 +446,6 @@ public class DataDecoder {
             throw new CorruptEncodingException(null, e);

         }

     }

-    */

 

     /**

      * Decodes the given byte array.

diff --git a/src/main/java/com/amazon/carbonado/raw/DataEncoder.java b/src/main/java/com/amazon/carbonado/raw/DataEncoder.java
index 990b7e7..4b6cab4 100644
--- a/src/main/java/com/amazon/carbonado/raw/DataEncoder.java
+++ b/src/main/java/com/amazon/carbonado/raw/DataEncoder.java
@@ -362,7 +362,7 @@ public class DataEncoder {
      * @param dstOffset offset into destination array

      * @return amount of bytes written

      * @since 1.2

-     * /

+     */

     public static int encode(BigDecimal value, byte[] dst, int dstOffset) {

         if (value == null) {

             dst[dstOffset] = NULL_BYTE_HIGH;

@@ -378,14 +378,13 @@ public class DataEncoder {
      * @param value BigDecimal value to encode, may be null

      * @return amount of bytes needed to encode

      * @since 1.2

-     * /

+     */

     public static int calculateEncodedLength(BigDecimal value) {

         if (value == null) {

             return 1;

         }

         return signedVarIntLength(value.scale()) + calculateEncodedLength(value.unscaledValue());

     }

-    */

 

     /**

      * Encodes the given optional byte array into a variable amount of

diff --git a/src/main/java/com/amazon/carbonado/raw/EncodingConstants.java b/src/main/java/com/amazon/carbonado/raw/EncodingConstants.java
index 997e491..5defdc2 100644
--- a/src/main/java/com/amazon/carbonado/raw/EncodingConstants.java
+++ b/src/main/java/com/amazon/carbonado/raw/EncodingConstants.java
@@ -18,6 +18,8 @@
 

 package com.amazon.carbonado.raw;

 

+import java.math.BigInteger;

+

 /**

  * 

  *

@@ -40,4 +42,7 @@ class EncodingConstants {
 

     /** Byte to terminate variable data encoded for ascending order */

     static final byte TERMINATOR = (byte)1;

+

+    static final BigInteger ONE_HUNDRED = BigInteger.valueOf(100);

+    static final BigInteger ONE_THOUSAND = BigInteger.valueOf(1000);

 }

diff --git a/src/main/java/com/amazon/carbonado/raw/GenericEncodingStrategy.java b/src/main/java/com/amazon/carbonado/raw/GenericEncodingStrategy.java
index c68f06b..c5417c4 100644
--- a/src/main/java/com/amazon/carbonado/raw/GenericEncodingStrategy.java
+++ b/src/main/java/com/amazon/carbonado/raw/GenericEncodingStrategy.java
@@ -383,8 +383,8 @@ public class GenericEncodingStrategy<S extends Storable> {
         Class clazz = propertyType.toClass();

         if (clazz != null) {

             return Lob.class.isAssignableFrom(clazz) ||

-                BigInteger.class.isAssignableFrom(clazz);/* ||

-                BigDecimal.class.isAssignableFrom(clazz);*/

+                BigInteger.class.isAssignableFrom(clazz) ||

+                BigDecimal.class.isAssignableFrom(clazz);

         }

         return false;

     }

diff --git a/src/main/java/com/amazon/carbonado/raw/KeyDecoder.java b/src/main/java/com/amazon/carbonado/raw/KeyDecoder.java
index eb44c53..a14a1a3 100644
--- a/src/main/java/com/amazon/carbonado/raw/KeyDecoder.java
+++ b/src/main/java/com/amazon/carbonado/raw/KeyDecoder.java
@@ -443,60 +443,11 @@ public class KeyDecoder {
      * @return amount of bytes read from source

      * @throws CorruptEncodingException if source data is corrupt

      * @since 1.2

-     * /

+     */

     public static int decode(byte[] src, int srcOffset, BigDecimal[] valueRef)

         throws CorruptEncodingException

     {

-        final int originalOffset;

-        BigInteger unscaledValue;

-        int scale;

-

-        try {

-            int header = src[srcOffset] & 0xff;

-

-            int headerSize;

-            switch (header) {

-            case (NULL_BYTE_HIGH & 0xff): case (NULL_BYTE_LOW & 0xff):

-                valueRef[0] = null;

-                return 1;

-

-            case 0x7f: case 0x80:

-                valueRef[0] = BigDecimal.ZERO;

-                return 1;

-

-            case 1: case 0x7e: case 0x81: case 0xfe:

-                headerSize = 5;

-                break;

-

-            default:

-                headerSize = 1;

-                break;

-            }

-

-            originalOffset = srcOffset;

-            srcOffset += headerSize;

-

-            BigInteger[] unscaledRef = new BigInteger[1];

-            srcOffset += decode(src, srcOffset, unscaledRef);

-

-            header = src[srcOffset++] & 0xff;

-            if (header > 0 && header < 0xff) {

-                scale = header - 0x80;

-            } else {

-                scale = DataDecoder.decodeInt(src, srcOffset);

-                srcOffset += 4;

-            }

-

-            unscaledValue = unscaledRef[0];

-            if (unscaledValue.signum() < 0) {

-                scale = ~scale;

-            }

-        } catch (IndexOutOfBoundsException e) {

-            throw new CorruptEncodingException(null, e);

-        }

-

-        valueRef[0] = new BigDecimal(unscaledValue, scale);

-        return srcOffset - originalOffset;

+        return decode(src, srcOffset, valueRef, 0);

     }

 

     /**

@@ -508,18 +459,29 @@ public class KeyDecoder {
      * @return amount of bytes read from source

      * @throws CorruptEncodingException if source data is corrupt

      * @since 1.2

-     * /

+     */

     public static int decodeDesc(byte[] src, int srcOffset, BigDecimal[] valueRef)

         throws CorruptEncodingException

     {

-        final int originalOffset;

+        return decode(src, srcOffset, valueRef, -1);

+    }

+

+    /**

+     * @param xorMask 0 for normal decoding, -1 for descending decoding

+     */

+    private static int decode(byte[] src, int srcOffset, BigDecimal[] valueRef, int xorMask)

+        throws CorruptEncodingException

+    {

+        final int originalOffset = srcOffset;

         BigInteger unscaledValue;

         int scale;

 

         try {

-            int header = src[srcOffset] & 0xff;

+            int header = (src[srcOffset] ^ xorMask) & 0xff;

+

+            int digitAdjust;

+            int exponent;

 

-            int headerSize;

             switch (header) {

             case (NULL_BYTE_HIGH & 0xff): case (NULL_BYTE_LOW & 0xff):

                 valueRef[0] = null;

@@ -529,33 +491,92 @@ public class KeyDecoder {
                 valueRef[0] = BigDecimal.ZERO;

                 return 1;

 

-            case 1: case 0x7e: case 0x81: case 0xfe:

-                headerSize = 5;

+            case 1: case 0x7e:

+                digitAdjust = 999 + 12;

+                exponent = (~DataDecoder.decodeInt(src, srcOffset + 1)) ^ xorMask;

+                srcOffset += 5;

+                break;

+

+            case 0x81: case 0xfe:

+                digitAdjust = 12;

+                exponent = DataDecoder.decodeInt(src, srcOffset + 1) ^ xorMask;

+                srcOffset += 5;

                 break;

 

             default:

-                headerSize = 1;

+                exponent = (src[srcOffset++] ^ xorMask) & 0xff;

+                if (exponent >= 0x82) {

+                    digitAdjust = 12;

+                    exponent -= 0xc0;

+                } else {

+                    digitAdjust = 999 + 12;

+                    exponent = 0x3f - exponent;

+                }

                 break;

             }

 

-            originalOffset = srcOffset;

-            srcOffset += headerSize;

-

-            BigInteger[] unscaledRef = new BigInteger[1];

-            srcOffset += decodeDesc(src, srcOffset, unscaledRef);

-

-            header = src[srcOffset++] & 0xff;

-            if (header > 0 && header < 0xff) {

-                scale = 0x7f - header;

-            } else {

-                scale = ~DataDecoder.decodeInt(src, srcOffset);

-                srcOffset += 4;

+            // Significand is base 1000 encoded, 10 bits per digit.

+

+            unscaledValue = null;

+            int precision = 0;

+

+            int accum = 0;

+            int bits = 0;

+            BigInteger lastDigit = null;

+

+            loop: while (true) {

+                accum = (accum << 8) | ((src[srcOffset++] ^ xorMask) & 0xff);

+                bits += 8;

+                if (bits >= 10) {

+                    int digit = (accum >> (bits - 10)) & 0x3ff;

+

+                    switch (digit) {

+                    case 0:

+                    case 1023:

+                        lastDigit = lastDigit.divide(ONE_HUNDRED);

+                        if (unscaledValue == null) {

+                            unscaledValue = lastDigit;

+                        } else {

+                            unscaledValue = unscaledValue.multiply(BigInteger.TEN).add(lastDigit);

+                        }

+                        precision += 1;

+                        break loop;

+                    case 1:

+                    case 1022:

+                        lastDigit = lastDigit.divide(BigInteger.TEN);

+                        if (unscaledValue == null) {

+                            unscaledValue = lastDigit;

+                        } else {

+                            unscaledValue = unscaledValue.multiply(ONE_HUNDRED).add(lastDigit);

+                        }

+                        precision += 2;

+                        break loop;

+                    case 2:

+                    case 1021:

+                        if (unscaledValue == null) {

+                            unscaledValue = lastDigit;

+                        } else {

+                            unscaledValue = unscaledValue.multiply(ONE_THOUSAND).add(lastDigit);

+                        }

+                        precision += 3;

+                        break loop;

+

+                    default:

+                        if (unscaledValue == null) {

+                            if ((unscaledValue = lastDigit) != null) {

+                                precision += 3;

+                            }

+                        } else {

+                            unscaledValue = unscaledValue.multiply(ONE_THOUSAND).add(lastDigit);

+                            precision += 3;

+                        }

+                        bits -= 10;

+                        lastDigit = BigInteger.valueOf(digit - digitAdjust);

+                    }

+                }

             }

 

-            unscaledValue = unscaledRef[0];

-            if (unscaledValue.signum() < 0) {

-                scale = ~scale;

-            }

+            scale = precision - exponent;

         } catch (IndexOutOfBoundsException e) {

             throw new CorruptEncodingException(null, e);

         }

@@ -563,7 +584,6 @@ public class KeyDecoder {
         valueRef[0] = new BigDecimal(unscaledValue, scale);

         return srcOffset - originalOffset;

     }

-    */

 

     /**

      * Decodes the given byte array as originally encoded for ascending order.

diff --git a/src/main/java/com/amazon/carbonado/raw/KeyEncoder.java b/src/main/java/com/amazon/carbonado/raw/KeyEncoder.java
index 0c90499..bea676b 100644
--- a/src/main/java/com/amazon/carbonado/raw/KeyEncoder.java
+++ b/src/main/java/com/amazon/carbonado/raw/KeyEncoder.java
@@ -434,90 +434,19 @@ public class KeyEncoder {
      * @param dstOffset offset into destination array

      * @return amount of bytes written

      * @since 1.2

-     * /

+     */

     public static int encode(BigDecimal value, byte[] dst, int dstOffset) {

-        /* Encoding of first byte:

-

-        0x00:       null low (unused)

-        0x01:       negative signum; four bytes follow for positive exponent

-        0x02..0x3f: negative signum; positive exponent; 3e range, 61..0

-        0x40..0x7d: negative signum; negative exponent; 3e range, -1..-62

-        0x7e:       negative signum; four bytes follow for negative exponent

-        0x7f:       negative zero (unused)

-        0x80:       zero

-        0x81:       positive signum; four bytes follow for negative exponent

-        0x82..0xbf: positive signum; negative exponent; 3e range, -62..-1

-        0xc0..0xfd: positive signum; positive exponent; 3e range, 0..61

-        0xfe:       positive signum; four bytes follow for positive exponent

-        0xff:       null high

-        * /

-

         if (value == null) {

             dst[dstOffset] = NULL_BYTE_HIGH;

             return 1;

         }

 

-        int signum = value.signum();

-        if (signum == 0) {

+        if (value.signum() == 0) {

             dst[dstOffset] = (byte) 0x80;

             return 1;

         }

 

-        final int originalOffset = dstOffset;

-

-        int scale = value.scale();

-        int exponent = value.precision() - scale;

-        System.out.println("exponent: " + exponent);

-        System.out.println("unscaled: " + value.unscaledValue());

-

-        if (signum < 0) {

-            if (exponent >= -0x3e && exponent < 0x3e) {

-                dst[dstOffset++] = (byte) (0x3f - exponent);

-            } else {

-                if (exponent < 0) {

-                    dst[dstOffset++] = (byte) 0x7e;

-                } else {

-                    dst[dstOffset++] = (byte) 1;

-                }

-                DataEncoder.encode(~exponent, dst, dstOffset);

-                dstOffset += 4;

-            }

-        } else {

-            if (exponent >= -0x3e && exponent < 0x3e) {

-                dst[dstOffset++] = (byte) (exponent + 0xc0);

-            } else {

-                if (exponent < 0) {

-                    dst[dstOffset++] = (byte) 0x81;

-                } else {

-                    dst[dstOffset++] = (byte) 0xfe;

-                }

-                DataEncoder.encode(exponent, dst, dstOffset);

-                dstOffset += 4;

-            }

-        }

-

-        dstOffset += encode(value.unscaledValue(), dst, dstOffset);

-

-        /* Encoding of scale:

-

-        0x00:       negative scale; four bytes follow for scale

-        0x01..0x7f: negative scale; 7f range, -127..-1

-        0x80..0xfe: positive scale; 7f range, 0..126

-        0xff:       positive scale; four bytes follow for scale

-        * /

-

-        if (signum < 0) {

-            scale = ~scale;

-        }

-        if (scale >= -0x7f && scale < 0x7f) {

-            dst[dstOffset++] = (byte) (scale + 0x80);

-        } else {

-            dst[dstOffset++] = scale < 0 ? ((byte) 0) : ((byte) 0xff);

-            DataEncoder.encode(scale, dst, dstOffset);

-            dstOffset += 4;

-        }

-

-        return dstOffset - originalOffset;

+        return encode(value).copyTo(dst, dstOffset);

     }

 

     /**

@@ -534,114 +463,221 @@ public class KeyEncoder {
      * @param dstOffset offset into destination array

      * @return amount of bytes written

      * @since 1.2

-     * /

+     */

     public static int encodeDesc(BigDecimal value, byte[] dst, int dstOffset) {

-        /* Encoding of first byte:

-

-        0x00:       null high (unused)

-        0x01:       positive signum; four bytes follow for positive exponent

-        0x02..0x3f: positive signum; positive exponent; 3e range, 0..61

-        0x40..0x7d: positive signum; negative exponent; 3e range, -62..-1

-        0x7e:       positive signum; four bytes follow for negative exponent

-        0x7f:       zero

-        0x80:       negative zero (unused)

-        0x81:       negative signum; four bytes follow for negative exponent

-        0x82..0xbf: negative signum; negative exponent; 3e range, -1..-62

-        0xc0..0xfd: negative signum; positive exponent; 3e range, 61..0

-        0xfe:       negative signum; four bytes follow for positive exponent

-        0xff:       null low

-        * /

-

         if (value == null) {

             dst[dstOffset] = NULL_BYTE_LOW;

             return 1;

         }

 

-        int signum = value.signum();

-        if (signum == 0) {

+        if (value.signum() == 0) {

             dst[dstOffset] = (byte) 0x7f;

             return 1;

         }

 

-        final int originalOffset = dstOffset;

+        return encode(value).copyDescTo(dst, dstOffset);

+    }

+

+    /**

+     * Returns the amount of bytes required to encode a BigDecimal.

+     *

+     * <p><i>Note:</i> It is recommended that value be normalized by stripping

+     * trailing zeros. This makes searching by value much simpler.

+     *

+     * @param value BigDecimal value to encode, may be null

+     * @return amount of bytes needed to encode

+     * @since 1.2

+     */

+    public static int calculateEncodedLength(BigDecimal value) {

+        if (value == null || value.signum() == 0) {

+            return 1;

+        }

+

+        return encode(value).mLength;

+    }

+

+    private static class CachedBigDecimal {

+        static final ThreadLocal<CachedBigDecimal> cLocal =

+            new ThreadLocal<CachedBigDecimal>();

+

+        final BigDecimal mValue;

+        final byte[] mEncoded;

+        final int mLength;

+

+        CachedBigDecimal(BigDecimal value, byte[] encoded, int length) {

+            mValue = value;

+            mEncoded = encoded;

+            mLength = length;

+        }

+

+        int copyTo(byte[] dst, int dstOffset) {

+            int length = mLength;

+            System.arraycopy(mEncoded, 0, dst, dstOffset, length);

+            return length;

+        }

+

+        int copyDescTo(byte[] dst, int dstOffset) {

+            byte[] encoded = mEncoded;

+            int length = mLength;

+            for (int i=0; i<length; i++) {

+                dst[dstOffset++] = (byte) ~encoded[i];

+            }

+            return length;

+        }

+    }

+

+    /**

+     * @param value cannot be null or zero

+     * @return non-null cached encoding

+     */

+    private static CachedBigDecimal encode(BigDecimal value) {

+        CachedBigDecimal cached = CachedBigDecimal.cLocal.get();

+        if (cached != null && cached.mValue.equals(value)) {

+            return cached;

+        }

+

+        // Exactly predicting encoding length is hard. Instead, overestimate

+        // and compare with actual encoded result. Result is cached to avoid

+        // recomputation.

+

+        // 5:  maximum header encoding length

+        // 1:  extra byte for last digit

+        // 10: bits for rare extra digit

+        // 10: bits for terminator digit

+        int length = (5 + 1) + (((value.unscaledValue().bitLength() + (10 + 10)) + 7) >> 3);

+

+        byte[] encoded = new byte[length];

+        length = encodeUncached(value, encoded);

+

+        cached = new CachedBigDecimal(value, encoded, length);

+        CachedBigDecimal.cLocal.set(cached);

+

+        return cached;

+    }

+

+    /**

+     * @param value cannot be null or zero

+     */

+    private static int encodeUncached(BigDecimal value, byte[] dst) {

+        /* Encoding of header:

+

+        0x00:       null low (unused)

+        0x01:       negative signum; four bytes follow for positive exponent

+        0x02..0x3f: negative signum; positive exponent; 3e range, 61..0

+        0x40..0x7d: negative signum; negative exponent; 3e range, -1..-62

+        0x7e:       negative signum; four bytes follow for negative exponent

+        0x7f:       negative zero (unused)

+        0x80:       zero

+        0x81:       positive signum; four bytes follow for negative exponent

+        0x82..0xbf: positive signum; negative exponent; 3e range, -62..-1

+        0xc0..0xfd: positive signum; positive exponent; 3e range, 0..61

+        0xfe:       positive signum; four bytes follow for positive exponent

+        0xff:       null high

+        */

 

-        int scale = value.scale();

-        int exponent = value.precision() - scale;

+        int dstOffset = 0;

+        int precision = value.precision();

+        int exponent = precision - value.scale();

 

-        if (signum < 0) {

+        if (value.signum() < 0) {

             if (exponent >= -0x3e && exponent < 0x3e) {

-                dst[dstOffset++] = (byte) (exponent + 0xc0);

+                dst[dstOffset++] = (byte) (0x3f - exponent);

             } else {

                 if (exponent < 0) {

-                    dst[dstOffset++] = (byte) 0x81;

+                    dst[dstOffset] = (byte) 0x7e;

                 } else {

-                    dst[dstOffset++] = (byte) 0xfe;

+                    dst[dstOffset] = (byte) 1;

                 }

-                DataEncoder.encode(exponent, dst, dstOffset);

-                dstOffset += 4;

+                DataEncoder.encode(~exponent, dst, dstOffset + 1);

+                dstOffset += 5;

             }

         } else {

             if (exponent >= -0x3e && exponent < 0x3e) {

-                dst[dstOffset++] = (byte) (0x3f - exponent);

+                dst[dstOffset++] = (byte) (exponent + 0xc0);

             } else {

                 if (exponent < 0) {

-                    dst[dstOffset++] = (byte) 0x7e;

+                    dst[dstOffset] = (byte) 0x81;

                 } else {

-                    dst[dstOffset++] = (byte) 1;

+                    dst[dstOffset] = (byte) 0xfe;

                 }

-                DataEncoder.encode(~exponent, dst, dstOffset);

-                dstOffset += 4;

+                DataEncoder.encode(exponent, dst, dstOffset + 1);

+                dstOffset += 5;

             }

         }

 

-        dstOffset += encodeDesc(value.unscaledValue(), dst, dstOffset);

-

-        /* Encoding of scale:

+        // Significand must be decimal encoded to maintain proper sort order.

+        // Base 1000 is more efficient than base 10 and still maintains proper

+        // sort order. A minimum of two bytes must be generated, however.

+

+        BigInteger unscaledValue = value.unscaledValue();

+

+        // Ensure a non-fractional amount of base 1000 digits.

+        int terminator;

+        switch (precision % 3) {

+        case 0: default:

+            terminator = 2;

+            break;

+        case 1:

+            terminator = 0;

+            unscaledValue = unscaledValue.multiply(ONE_HUNDRED);

+            break;

+        case 2:

+            terminator = 1;

+            unscaledValue = unscaledValue.multiply(BigInteger.TEN);

+            break;

+        }

 

-        0x00:       positive scale; four bytes follow for scale

-        0x01..0x7f: positive scale; 7f range, 0..126

-        0x80..0xfe: negative scale; 7f range, -127..-1

-        0xff:       negative scale; four bytes follow for scale

-        * /

+        // 10 bits per digit and 1 extra terminator digit. Digit values 0..999

+        // are encoded as 12..1011. Digit values 0..11 and 1012..1023 are used

+        // for terminators.

 

-        if (signum < 0) {

-            scale = ~scale;

-        }

-        if (scale >= -0x7f && scale < 0x7f) {

-            dst[dstOffset++] = (byte) (0x7f - scale);

+        int digitAdjust;

+        if (unscaledValue.signum() >= 0) {

+            digitAdjust = 12;

         } else {

-            dst[dstOffset++] = scale < 0 ? ((byte) 0xff) : ((byte) 0);

-            DataEncoder.encode(~scale, dst, dstOffset);

-            dstOffset += 4;

+            digitAdjust = 999 + 12;

+            terminator = 1023 - terminator;

         }

 

-        return dstOffset - originalOffset;

-    }

+        int pos = ((unscaledValue.bitLength() + 9) / 10) + 1;

+        int[] digits = new int[pos];

+        digits[--pos] = terminator;

 

-    /**

-     * Returns the amount of bytes required to encode a BigDecimal.

-     *

-     * <p><i>Note:</i> It is recommended that value be normalized by stripping

-     * trailing zeros. This makes searching by value much simpler.

-     *

-     * @param value BigDecimal value to encode, may be null

-     * @return amount of bytes needed to encode

-     * @since 1.2

-     * /

-    public static int calculateEncodedLength(BigDecimal value) {

-        if (value == null || value.signum() == 0) {

-            return 1;

+        while (unscaledValue.signum() != 0) {

+            BigInteger[] divrem = unscaledValue.divideAndRemainder(ONE_THOUSAND);

+

+            if (--pos < 0) {

+                // Handle rare case when an extra digit is required.

+                int[] newDigits = new int[digits.length + 1];

+                System.arraycopy(digits, 0, newDigits, 1, digits.length);

+                digits = newDigits;

+                pos = 0;

+            }

+

+            digits[pos] = divrem[1].intValue() + digitAdjust;

+

+            unscaledValue = divrem[0];

+        }

+

+        // Now encode digits in proper order, 10 bits per digit. 1024 possible

+        // values per 10 bits, and so base 1000 is quite efficient.

+

+        int accum = 0;

+        int bits = 0;

+        for (int i=0; i<digits.length; i++) {

+            accum = (accum << 10) | digits[i];

+            bits += 10;

+            do {

+                dst[dstOffset++] = (byte) (accum >> (bits -= 8));

+            } while (bits >= 8);

         }

 

-        int scale = value.scale();

-        int exponent = value.precision() - value.scale();

+        if (bits != 0) {

+            dst[dstOffset++] = (byte) (accum << (8 - bits));

+        }

 

-        int headerSize = (exponent >= -0x3e && exponent < 0x3e) ? 1 : 5;

-        int scaleSize = (scale >= -0x7f && scale < 0x7f) ? 1 : 5;

-            

-        return headerSize + calculateEncodedLength(value.unscaledValue()) + scaleSize;

+        return dstOffset;

     }

-    */

 

     /**

      * Encodes the given optional unsigned byte array into a variable amount of