private static int mathematicalSizeOfType()

in src/main/java/org/apache/xmlbeans/impl/schema/StscSimpleTypeResolver.java [955:1048]
85 lines of code
40 McCabe index (conditional complexity)

    private static int mathematicalSizeOfType(SchemaTypeImpl sImpl) {
        if (sImpl.getPrimitiveType().getBuiltinTypeCode() != SchemaType.BTC_DECIMAL) {
            return SchemaType.NOT_DECIMAL;
        }

        if (sImpl.getFacet(SchemaType.FACET_FRACTION_DIGITS) == null ||
            ((SimpleValue) sImpl.getFacet(SchemaType.FACET_FRACTION_DIGITS)).getBigIntegerValue().signum() != 0) {
            return SchemaType.SIZE_BIG_DECIMAL;
        }

        BigInteger min = null;
        BigInteger max = null;

        if (sImpl.getFacet(SchemaType.FACET_MIN_EXCLUSIVE) != null) {
            min = ((SimpleValue) sImpl.getFacet(SchemaType.FACET_MIN_EXCLUSIVE)).getBigIntegerValue(); // .add(BigInteger.ONE);
        }
        if (sImpl.getFacet(SchemaType.FACET_MIN_INCLUSIVE) != null) {
            min = ((SimpleValue) sImpl.getFacet(SchemaType.FACET_MIN_INCLUSIVE)).getBigIntegerValue();
        }
        if (sImpl.getFacet(SchemaType.FACET_MAX_INCLUSIVE) != null) {
            max = ((SimpleValue) sImpl.getFacet(SchemaType.FACET_MAX_INCLUSIVE)).getBigIntegerValue();
        }
        if (sImpl.getFacet(SchemaType.FACET_MAX_EXCLUSIVE) != null) {
            max = ((SimpleValue) sImpl.getFacet(SchemaType.FACET_MAX_EXCLUSIVE)).getBigIntegerValue(); // .subtract(BigInteger.ONE);
        }

        if (sImpl.getFacet(SchemaType.FACET_TOTAL_DIGITS) != null) {
            BigInteger peg = null;
            try {
                BigInteger totalDigits = ((SimpleValue) sImpl.getFacet(SchemaType.FACET_TOTAL_DIGITS)).getBigIntegerValue();

                switch (totalDigits.intValue()) {
                    case 0:
                    case 1:
                    case 2:
                        peg = BigInteger.valueOf(99L); // BYTE size
                        break;
                    case 3:
                    case 4:
                        peg = BigInteger.valueOf(9999L); // SHORT size
                        break;
                    case 5:
                    case 6:
                    case 7:
                    case 8:
                    case 9:
                        peg = BigInteger.valueOf(999999999L); // INT size
                        break;
                    case 10:
                    case 11:
                    case 12:
                    case 13:
                    case 14:
                    case 15:
                    case 16:
                    case 17:
                    case 18:
                        peg = BigInteger.valueOf(999999999999999999L); // LONG size
                        break;
                }
            } catch (XmlValueOutOfRangeException ignored) {
            }
            if (peg != null) {
                min = (min == null ? peg.negate() : min.max(peg.negate()));
                max = (max == null ? peg : max.min(peg));
            }
        }

        if (min != null && max != null) {
            // find the largest "absolute value" number that must be dealt with
            if (min.signum() < 0) {
                min = min.negate().subtract(BigInteger.ONE);
            }
            if (max.signum() < 0) {
                max = max.negate().subtract(BigInteger.ONE);
            }

            max = max.max(min);
            if (max.compareTo(BigInteger.valueOf(Byte.MAX_VALUE)) <= 0) {
                return SchemaType.SIZE_BYTE;
            }
            if (max.compareTo(BigInteger.valueOf(Short.MAX_VALUE)) <= 0) {
                return SchemaType.SIZE_SHORT;
            }
            if (max.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) <= 0) {
                return SchemaType.SIZE_INT;
            }
            if (max.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) <= 0) {
                return SchemaType.SIZE_LONG;
            }
        }

        return SchemaType.SIZE_BIG_INTEGER;
    }