The Range enum replaces the traditional bit mask-based values (e.g., {@link NumericShaper#ARABIC}), and supports more Unicode ranges than the bit mask-based ones. For example, the following code using the bit mask:

NumericShaper.getContextualShaper(NumericShaper.ARABIC |
                                    NumericShaper.TAMIL,
                                  NumericShaper.EUROPEAN);

NumericShaper.getContextualShaper(EnumSet.of(
                                    NumericShaper.Range.ARABIC,
                                    NumericShaper.Range.TAMIL),
                                  NumericShaper.Range.EUROPEAN);

This constant specifies all of the bit mask-based ranges. Use {@code EmunSet.allOf(NumericShaper.Range.class)} to specify all of the enum-based ranges. 

 public boolean equals(Object o) 
{
        if (o != null) {
            try {
                NumericShaper rhs = (NumericShaper)o;
                if (rangeSet != null) {
                    if (rhs.rangeSet != null) {
                        return isContextual() == rhs.isContextual()
                            && rangeSet.equals(rhs.rangeSet)
                            && shapingRange == rhs.shapingRange;
                    }
                    return isContextual() == rhs.isContextual()
                        && rangeSet.equals(Range.maskToRangeSet(rhs.mask))
                        && shapingRange == Range.indexToRange(rhs.key);
                } else if (rhs.rangeSet != null) {
                    Set< Range > rset = Range.maskToRangeSet(mask);
                    Range srange = Range.indexToRange(key);
                    return isContextual() == rhs.isContextual()
                        && rset.equals(rhs.rangeSet)
                        && srange == rhs.shapingRange;
                }
                return rhs.mask == mask && rhs.key == key;
            }
            catch (ClassCastException e) {
            }
        }
        return false;
}

Returns {@code true} if the specified object is an instance of NumericShaper and shapes identically to this one, regardless of the range representations, the bit mask or the enum. For example, the following code produces {@code "true"}.

NumericShaper ns1 = NumericShaper.getShaper(NumericShaper.ARABIC);
NumericShaper ns2 = NumericShaper.getShaper(NumericShaper.Range.ARABIC);
System.out.println(ns1.equals(ns2));

 public static NumericShaper getContextualShaper(int ranges) 
{
        ranges |= CONTEXTUAL_MASK;
        return new NumericShaper(EUROPEAN_KEY, ranges);
}

Returns a contextual shaper for the provided unicode range(s). Latin-1 (EUROPEAN) digits are converted to the decimal digits corresponding to the range of the preceding text, if the range is one of the provided ranges. Multiple ranges are represented by or-ing the values together, such as, NumericShaper.ARABIC | NumericShaper.THAI. The shaper assumes EUROPEAN as the starting context, that is, if EUROPEAN digits are encountered before any strong directional text in the string, the context is presumed to be EUROPEAN, and so the digits will not shape.

 public static NumericShaper getContextualShaper(Set<Range> ranges) 
{
        NumericShaper shaper = new NumericShaper(Range.EUROPEAN, ranges);
        shaper.mask = CONTEXTUAL_MASK;
        return shaper;
}

Returns a contextual shaper for the provided Unicode range(s). The Latin-1 (EUROPEAN) digits are converted to the decimal digits corresponding to the range of the preceding text, if the range is one of the provided ranges.

The shaper assumes EUROPEAN as the starting context, that is, if EUROPEAN digits are encountered before any strong directional text in the string, the context is presumed to be EUROPEAN, and so the digits will not shape.

 public static NumericShaper getContextualShaper(int ranges,
    int defaultContext) 
{
        int key = getKeyFromMask(defaultContext);
        ranges |= CONTEXTUAL_MASK;
        return new NumericShaper(key, ranges);
}

Returns a contextual shaper for the provided unicode range(s). Latin-1 (EUROPEAN) digits will be converted to the decimal digits corresponding to the range of the preceding text, if the range is one of the provided ranges. Multiple ranges are represented by or-ing the values together, for example, NumericShaper.ARABIC | NumericShaper.THAI. The shaper uses defaultContext as the starting context.

 public static NumericShaper getContextualShaper(Set<Range> ranges,
    Range defaultContext) 
{
        if (defaultContext == null) {
            throw new NullPointerException();
        }
        NumericShaper shaper = new NumericShaper(defaultContext, ranges);
        shaper.mask = CONTEXTUAL_MASK;
        return shaper;
}

Returns a contextual shaper for the provided Unicode range(s). The Latin-1 (EUROPEAN) digits will be converted to the decimal digits corresponding to the range of the preceding text, if the range is one of the provided ranges. The shaper uses {@code defaultContext} as the starting context.

 public Set<Range> getRangeSet() 
{
        if (rangeSet != null) {
            return EnumSet.copyOf(rangeSet);
        }
        return Range.maskToRangeSet(mask);
}

Returns a {@code Set} representing all the Unicode ranges in this {@code NumericShaper} that will be shaped.

 public int getRanges() 
{
        return mask & ~CONTEXTUAL_MASK;
}

Returns an int that ORs together the values for all the ranges that will be shaped.

For example, to check if a shaper shapes to Arabic, you would use the following:

if ((shaper.getRanges() & shaper.ARABIC) != 0) { ...

Note that this method supports only the bit mask-based ranges. Call #getRangeSet() for the enum-based ranges.

 public static NumericShaper getShaper(int singleRange) 
{
        int key = getKeyFromMask(singleRange);
        return new NumericShaper(key, singleRange);
}

Returns a shaper for the provided unicode range. All Latin-1 (EUROPEAN) digits are converted to the corresponding decimal unicode digits.

 public static NumericShaper getShaper(Range singleRange) 
{
        return new NumericShaper(singleRange, EnumSet.of(singleRange));
}

Returns a shaper for the provided Unicode range. All Latin-1 (EUROPEAN) digits are converted to the corresponding decimal digits of the specified Unicode range.

 public int hashCode() 
{
        int hash = mask;
        if (rangeSet != null) {
            // Use the CONTEXTUAL_MASK bit only for the enum-based
            // NumericShaper. A deserialized NumericShaper might have
            // bit masks.
            hash &= CONTEXTUAL_MASK;
            hash ^= rangeSet.hashCode();
        }
        return hash;
}

Returns a hash code for this shaper.

 public boolean isContextual() 
{
        return (mask & CONTEXTUAL_MASK) != 0;
}

Returns a boolean indicating whether or not this shaper shapes contextually.

 public  void shape(char[] text,
    int start,
    int count) 
{
        checkParams(text, start, count);
        if (isContextual()) {
            if (rangeSet == null) {
                shapeContextually(text, start, count, key);
            } else {
                shapeContextually(text, start, count, shapingRange);
            }
        } else {
            shapeNonContextually(text, start, count);
        }
}

Converts the digits in the text that occur between start and start + count.

 public  void shape(char[] text,
    int start,
    int count,
    int context) 
{
        checkParams(text, start, count);
        if (isContextual()) {
            int ctxKey = getKeyFromMask(context);
            if (rangeSet == null) {
                shapeContextually(text, start, count, ctxKey);
            } else {
                shapeContextually(text, start, count, Range.values()[ctxKey]);
            }
        } else {
            shapeNonContextually(text, start, count);
        }
}

Converts the digits in the text that occur between start and start + count, using the provided context. Context is ignored if the shaper is not a contextual shaper.

 public  void shape(char[] text,
    int start,
    int count,
    Range context) 
{
        checkParams(text, start, count);
        if (context == null) {
            throw new NullPointerException("context is null");
        }
        if (isContextual()) {
            if (rangeSet != null) {
                shapeContextually(text, start, count, context);
            } else {
                int key = Range.toRangeIndex(context);
                if (key  >= 0) {
                    shapeContextually(text, start, count, key);
                } else {
                    shapeContextually(text, start, count, shapingRange);
                }
            }
        } else {
            shapeNonContextually(text, start, count);
        }
}

Converts the digits in the text that occur between {@code start} and {@code start + count}, using the provided {@code context}. {@code Context} is ignored if the shaper is not a contextual shaper.

 public String toString() 
{
        StringBuilder buf = new StringBuilder(super.toString());
        buf.append("[contextual:").append(isContextual());
        String[] keyNames = null;
        if (isContextual()) {
            buf.append(", context:");
            buf.append(shapingRange == null ? Range.values()[key] : shapingRange);
        }
        if (rangeSet == null) {
            buf.append(", range(s): ");
            boolean first = true;
            for (int i = 0; i <  NUM_KEYS; ++i) {
                if ((mask & (1 < <  i)) != 0) {
                    if (first) {
                        first = false;
                    } else {
                        buf.append(", ");
                    }
                    buf.append(Range.values()[i]);
                }
            }
        } else {
            buf.append(", range set: ").append(rangeSet);
        }
        buf.append(']');
        return buf.toString();
}

Returns a String that describes this shaper. This method is used for debugging purposes only.