public static Appendable fastAppendToAppendable()

in java/dfp/src/main/java/com/epam/deltix/dfp/JavaImpl.java [1065:1225]

• 102 lines of code
• 29 McCabe index (conditional complexity)

    public static Appendable fastAppendToAppendable(final long value, final char decimalMark, final boolean floatStyle, final Appendable appendable) throws IOException {
        if (isNull(value))
            return appendable.append("null");

        if (isNonFinite(value)) {
            // Value is either Inf or NaN
            // TODO: Do we need SNaN?
            return appendable.append(isNaN(value) ? "NaN" : value < 0 ? "-Infinity" : "Infinity");
        }

        //final Decimal64Parts parts = tlsDecimal64Parts.get();
        //final long coefficient = toParts(value, parts);
        long partsCoefficient;
//        long partsSignMask;
        int partsExponent;
        {
//            partsSignMask = value & MASK_SIGN;

            if (isSpecial(value)) {
//                if (isNonFinite(value)) {
//                    partsExponent = 0;
//
//                    partsCoefficient = value & 0xFE03_FFFF_FFFF_FFFFL;
//                    if ((value & 0x0003_FFFF_FFFF_FFFFL) > MAX_COEFFICIENT)
//                        partsCoefficient = value & ~MASK_COEFFICIENT;
//                    if (isInfinity(value))
//                        partsCoefficient = value & MASK_SIGN_INFINITY_NAN; // TODO: Why this was done??
////                return 0;
//                } else
                {
                    // Check for non-canonical values.
                    final long coefficient = (value & LARGE_COEFFICIENT_MASK) | LARGE_COEFFICIENT_HIGH_BIT;
                    partsCoefficient = coefficient > MAX_COEFFICIENT ? 0 : coefficient;

                    // Extract exponent.
                    final long tmp = value >> EXPONENT_SHIFT_LARGE;
                    partsExponent = (int) (tmp & EXPONENT_MASK);

//                return parts.coefficient;
                }
            } else {
                // Extract exponent. Maximum biased value for "small exponent" is 0x2FF(*2=0x5FE), signed: []
                // upper 1/4 of the mask range is "special", as checked in the code above
                final long tmp = value >> EXPONENT_SHIFT_SMALL;
                partsExponent = (int) (tmp & EXPONENT_MASK);

                // Extract coefficient.
//            return
                partsCoefficient = (value & SMALL_COEFFICIENT_MASK);
            }
        }

        if (partsCoefficient == 0) {
            appendable.append('0');
            if (floatStyle)
                appendable.append(decimalMark).append('0');
            return appendable;
        }

        int exponent = partsExponent - EXPONENT_BIAS;

        final MutableCharBuffer charBuffer = MUTABLE_CHAR_BUFFER.get();
        final char[] buffer = charBuffer.buffer;

        if (exponent >= 0) {
            int bi = buffer.length;
            if (floatStyle) {
                buffer[--bi] = '0';
                buffer[--bi] = decimalMark;
            }
            for (int i = 0; i < exponent; ++i)
                buffer[--bi] = '0';

            while (partsCoefficient > 0) {
                bi = formatUIntFromBcdTable((int) (partsCoefficient % BCD_DIVIDER), buffer, bi);
                partsCoefficient /= BCD_DIVIDER;
            }

            while (buffer[bi] == '0')
                ++bi;

            if (value < 0)
                buffer[--bi] = '-';

            return appendable.append(charBuffer.setRange(bi, buffer.length - bi));

        } else { // exponent < 0
            int bi = buffer.length;

            final int digits = numberOfDigits(partsCoefficient);

            if (digits + exponent > 0) {
                long integralPart = partsCoefficient / POWERS_OF_TEN[-exponent];
                long fractionalPart = partsCoefficient % POWERS_OF_TEN[-exponent];

                while (fractionalPart > 0) {
                    bi = formatUIntFromBcdTable((int) (fractionalPart % BCD_DIVIDER), buffer, bi);
                    fractionalPart /= BCD_DIVIDER;
                }

                final int written = buffer.length - bi /* already written */;
                //if (written < -exponent /* must be written */)
                for (int ei = 0, ee = -exponent - written; ei < ee; ++ei)
                    buffer[--bi] = '0';

                bi = buffer.length + exponent; /* buffer.length - (-exponent) */

                buffer[--bi] = decimalMark;

                while (integralPart > 0) {
                    bi = formatUIntFromBcdTable((int) (integralPart % BCD_DIVIDER), buffer, bi);
                    integralPart /= BCD_DIVIDER;
                }

                while (buffer[bi] == '0')
                    ++bi;

                if (value < 0)
                    buffer[--bi] = '-';

                int be = buffer.length;
                while (buffer[be - 1] == '0')
                    --be;

                if (buffer[be - 1] == decimalMark) {
                    if (!floatStyle) {
                        --be;
                    } else if (be < buffer.length) {
                        buffer[be++] = '0';
                    }
                }

                return appendable.append(charBuffer.setRange(bi, be - bi));

            } else {
                while (partsCoefficient > 0) {
                    bi = formatUIntFromBcdTable((int) (partsCoefficient % BCD_DIVIDER), buffer, bi);
                    partsCoefficient /= BCD_DIVIDER;
                }

                final int written = buffer.length - bi /* already written */;
                //if (written < -exponent /* must be written */)
                for (int ei = 0, ee = -exponent - written; ei < ee; ++ei)
                    buffer[--bi] = '0';

                bi = buffer.length + exponent; /* buffer.length - (-exponent) */

                buffer[--bi] = decimalMark;
                buffer[--bi] = '0';

                if (value < 0)
                    buffer[--bi] = '-';

                int be = buffer.length;
                while (buffer[be - 1] == '0')
                    --be;

                return appendable.append(charBuffer.setRange(bi, be - bi));
            }
        }
    }