* Copyright 2000-2009 Sun Microsystems, Inc.  All Rights Reserved.

import java.io.IOException;

import java.io.ObjectOutputStream;

import java.util.Arrays;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.Set;

 *   shaper.shape(text, start, count);

 * </pre></blockquote>

 *

 * <p><b>Bit mask- and enum-based Unicode ranges</b></p>

 *

 * <p>This class supports two different programming interfaces to

 * represent Unicode ranges for script-specific digits: bit

 * mask-based ones, such as {@link #ARABIC NumericShaper.ARABIC}, and

 * enum-based ones, such as {@link NumericShaper.Range#ARABIC}.

 * Multiple ranges can be specified by ORing bit mask-based constants,

 * such as:

 * <blockquote><pre>

 * NumericShaper.ARABIC | NumericShaper.TAMIL

 * or creating a {@code Set} with the {@link NumericShaper.Range}

 * constants, such as:

 * <blockquote><pre>

 * EnumSet.of(NumericShaper.Scirpt.ARABIC, NumericShaper.Range.TAMIL)

 * </pre></blockquote>

 * The enum-based ranges are a super set of the bit mask-based ones.

 *

 * <p>If the two interfaces are mixed (including serialization),

 * Unicode range values are mapped to their counterparts where such

 * mapping is possible, such as {@code NumericShaper.Range.ARABIC}

 * from/to {@code NumericShaper.ARABIC}.  If any unmappable range

 * values are specified, such as {@code NumericShaper.Range.BALINESE},

 * those ranges are ignored.

    /**

     * A {@code NumericShaper.Range} represents a Unicode range of a

     * script having its own decimal digits. For example, the {@link

     * NumericShaper.Range#THAI} range has the Thai digits, THAI DIGIT

     * ZERO (U+0E50) to THAI DIGIT NINE (U+0E59).

     *

     * <p>The <code>Range</code> 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:

     * <blockquote><pre>

     * NumericShaper.getContextualShaper(NumericShaper.ARABIC |

     *                                     NumericShaper.TAMIL,

     *                                   NumericShaper.EUROPEAN);

     * </pre></blockquote>

     * can be written using this enum as:

     * <blockquote><pre>

     * NumericShaper.getContextualShaper(EnumSet.of(

     *                                     NumericShaper.Range.ARABIC,

     *                                     NumericShaper.Range.TAMIL),

     *                                   NumericShaper.Range.EUROPEAN);

     * </pre></blockquote>

     *

     * @since 1.7

     */

    public static enum Range {

        /**

         * The Latin (European) range with the Latin (ASCII) digits.

         */

        EUROPEAN        ('\u0030', '\u0000', '\u0300'),

        /**

         * The Arabic range with the Arabic-Indic digits.

         */

        ARABIC          ('\u0660', '\u0600', '\u0780'),

        /**

         * The Arabic range with the Eastern Arabic-Indic digits.

         */

        EASTERN_ARABIC  ('\u06f0', '\u0600', '\u0780'),

        /**

         * The Devanagari range with the Devanagari digits.

         */

        DEVANAGARI      ('\u0966', '\u0900', '\u0980'),

        /**

         * The Bengali range with the Bengali digits.

         */

        BENGALI         ('\u09e6', '\u0980', '\u0a00'),

        /**

         * The Gurmukhi range with the Gurmukhi digits.

         */

        GURMUKHI        ('\u0a66', '\u0a00', '\u0a80'),

        /**

         * The Gujarati range with the Gujarati digits.

         */

        GUJARATI        ('\u0ae6', '\u0b00', '\u0b80'),

        /**

         * The Oriya range with the Oriya digits.

         */

        ORIYA           ('\u0b66', '\u0b00', '\u0b80'),

        /**

         * The Tamil range with the Tamil digits.

         */

        TAMIL           ('\u0be6', '\u0b80', '\u0c00'),

        /**

         * The Telugu range with the Telugu digits.

         */

        TELUGU          ('\u0c66', '\u0c00', '\u0c80'),

        /**

         * The Kannada range with the Kannada digits.

         */

        KANNADA         ('\u0ce6', '\u0c80', '\u0d00'),

        /**

         * The Malayalam range with the Malayalam digits.

         */

        MALAYALAM       ('\u0d66', '\u0d00', '\u0d80'),

        /**

         * The Thai range with the Thai digits.

         */

        THAI            ('\u0e50', '\u0e00', '\u0e80'),

        /**

         * The Lao range with the Lao digits.

         */

        LAO             ('\u0ed0', '\u0e80', '\u0f00'),

        /**

         * The Tibetan range with the Tibetan digits.

         */

        TIBETAN         ('\u0f20', '\u0f00', '\u1000'),

        /**

         * The Myanmar range with the Myanmar digits.

         */

        MYANMAR         ('\u1040', '\u1000', '\u1080'),

        /**

         * The Ethiopic range with the Ethiopic digits. Ethiopic

         * does not have a decimal digit 0 so Latin (European) 0 is

         * used.

         */

        ETHIOPIC        ('\u1369', '\u1200', '\u1380') {

            @Override

            char getNumericBase() { return 1; }

        },

        /**

         * The Khmer range with the Khmer digits.

         */

        KHMER           ('\u17e0', '\u1780', '\u1800'),

        /**

         * The Mongolian range with the Mongolian digits.

         */

        MONGOLIAN       ('\u1810', '\u1800', '\u1900'),

        /**

         * The N'Ko range with the N'Ko digits.

         */

        NKO             ('\u07c0', '\u07c0', '\u0800'),

        /**

         * The Myanmar range with the Myanmar Shan digits.

         */

        MYANMAR_SHAN    ('\u1090', '\u1000', '\u10a0'),

        /**

         * The Limbu range with the Limbu digits.

         */

        LIMBU           ('\u1946', '\u1900', '\u1950'),

        /**

         * The New Tai Lue range with the New Tai Lue digits.

         */

        NEW_TAI_LUE     ('\u19d0', '\u1980', '\u19e0'),

        /**

         * The Balinese range with the Balinese digits.

         */

        BALINESE        ('\u1b50', '\u1b00', '\u1b80'),

        /**

         * The Sundanese range with the Sundanese digits.

         */

        SUNDANESE       ('\u1bb0', '\u1b80', '\u1bc0'),

        /**

         * The Lepcha range with the Lepcha digits.

         */

        LEPCHA          ('\u1c40', '\u1c00', '\u1c50'),

        /**

         * The Ol Chiki range with the Ol Chiki digits.

         */

        OL_CHIKI        ('\u1c50', '\u1c50', '\u1c80'),

        /**

         * The Vai range with the Vai digits.

         */

        VAI             ('\ua620', '\ua500', '\ua640'),

        /**

         * The Saurashtra range with the Saurashtra digits.

         */

        SAURASHTRA      ('\ua8d0', '\ua880', '\ua8e0'),

        /**

         * The Kayah Li range with the Kayah Li digits.

         */

        KAYAH_LI        ('\ua900', '\ua900', '\ua930'),

        /**

         * The Cham range with the Cham digits.

         */

        CHAM            ('\uaa50', '\uaa00', '\uaa60');

        private static final Range[] ranges = Range.class.getEnumConstants();

        static {

            // sort ranges[] by base for binary search

            Arrays.sort(ranges,

                        new Comparator<Range>() {

                            public int compare(Range s1, Range s2) {

                                return s1.base > s2.base ? 1 : s1.base == s2.base ? 0 : -1;

                            }

                        });

        }

        private static int toRangeIndex(Range script) {

            int index = script.ordinal();

            return index < NUM_KEYS ? index : -1;

        }

        private static Range indexToRange(int index) {

            return index < NUM_KEYS ? Range.values()[index] : null;

        }

        private static int toRangeMask(Set<Range> ranges) {

            int m = 0;

            for (Range range : ranges) {

                int index = range.ordinal();

                if (index < NUM_KEYS) {

                    m |= 1 << index;

                }

            }

            return m;

        }

        private static Set<Range> maskToRangeSet(int mask) {

            Set<Range> set = EnumSet.noneOf(Range.class);

            Range[] a = Range.values();

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

                if ((mask & (1 << i)) != 0) {

                    set.add(a[i]);

                }

            }

            return set;

        }

        // base character of range digits

        private final int base;

        // Unicode range

        private final int start, // inclusive

                          end;   // exclusive

        private Range(int base, int start, int end) {

            this.base = base - ('0' + getNumericBase());

            this.start = start;

            this.end = end;

        }

        private int getDigitBase() {

            return base;

        }

        char getNumericBase() {

            return 0;

        }

        private boolean inRange(int c) {

            return start <= c && c < end;

        }

    }

    /**

     * The context {@code Range} for contextual shaping or the {@code

     * Range} for non-contextual shaping. {@code null} for the bit

     * mask-based API.

     *

     * @since 1.7

     */

    private Range shapingRange;

    /**

     * {@code Set<Range>} indicating which Unicode ranges to

     * shape. {@code null} for the bit mask-based API.

     *

     * @since 1.7

     */

    private transient Set<Range> rangeSet;

    private static final long serialVersionUID = -8022764705923730308L;

    /** Identifies the TAMIL range and decimal base. */

    // TAMIL DIGIT ZERO was added in Unicode 4.1

    /** Identifies all ranges, for full contextual shaping.

     *

     * <p>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.

     */

    private static final int NUM_KEYS = MONGOLIAN_KEY + 1; // fixed

        '\u0660' - '\u0030', // ARABIC-INDIC

        '\u06f0' - '\u0030', // EXTENDED ARABIC-INDIC (EASTERN_ARABIC)

        '\u0be6' - '\u0030', // TAMIL - zero was added in Unicode 4.1

        '\u1369' - '\u0031', // ETHIOPIC - no zero

        '\u0600', '\u0780', // ARABIC

        '\u0600', '\u0780', // EASTERN_ARABIC -- note overlap with arabic

        '\u0b80', '\u0c00', // TAMIL

        '\u1200', '\u1380', // ETHIOPIC - note missing zero