/**
*******************************************************************************
* Copyright (C) 1996-2001, International Business Machines Corporation and    *
* others. All Rights Reserved.                                                *
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/utility/UTF32.java,v $
* $Date: 2004/04/17 18:21:38 $
* $Revision: 1.3 $
*
*******************************************************************************
*/

package com.ibm.text.utility;

/**
* Utility class for demonstrating UTF16 character conversions and indexing conversions.
* Ideally, these methods would be on existing classes in Java, but they can also be used
* in a stand-alone utility class like this one.
* <p>Code that uses strings alone rarely need modification.
* By design, UTF-16 does not allow overlap, so searching for strings is a safe operation.
* Similarly, concatenation is always safe. Substringing is safe if the start and end are both
* on UTF32 boundaries. In normal code, the values for start and end are on those boundaries,
* since they arose from operations like searching.
* If not, the nearest UTF-32 boundaries can be determined using <code>bounds32()</code>.
* <p>Here is a summary of the methods:
* <ul><li>
* <code>char32At()</code>, <code>count32()</code>, and <code>append32()</code>
* are most important methods for most programs.
* They are used for iteration, filtering and copying. See the examples below.
* </li><li>
* <code>bounds32()</code> is useful for finding the nearest UTF-32 boundaries.
* However, in most circumstances it is better to use
* <a <a href="http://java.sun.com/products/jdk/1.2/docs/api/java/text/BreakIterator.html#getCharacterInstance(java.util.Locale)">
* BreakIterator.getCharacterInstance(Locale)</a> to find character boundaries
* that are closer to end-user expectations.
* </li><li>
* <code>valueOf32()</code> is occasionally convenient for producing a string containing a UTF-32 value.
* </li><li>
* <code>findOffset16()</code> and <code>findOffset32()</code> are generally not needed,
* except when interfacing to specifications that use UTF-32 indices (such as XSL).
* </li><li>
* <code>isLegal()</code> can be used to test whether UTF-16 or UTF-32 values are valid.
* </li><li>
* <code>isLeadSurrogate()</code>, <code>isSurrogate()</code>, and <code>isTrailSurrogate()</code>
* test the type of a char. They are useful for lower-level code.
* </li><li>
* <code>getChar32()</code>, <code>getLead()</code>, and <code>getTrail()</code>
* are sometimes useful for putting together and taking apart UTF-32 values.
* </li></ul>
* <strong>Examples:</strong>
* <p>The following examples illustrate use of some of these methods.
<pre>
// iteration forwards: Original
for (int i = 0; i < s.length(); ++i) {
    char ch = s.charAt(i);
    doSomethingWith(ch);
}

// iteration forwards: Changes for UTF-32
int ch;
for (int i = 0; i < s.length(); i+=UTF32.count16(ch)) {
    ch = UTF32.char32At(s,i);
    doSomethingWith(ch);
}

// iteration backwards: Original
for (int i = s.length()-1; i >= 0; --i) {
    char ch = s.charAt(i);
    doSomethingWith(ch);
}

// iteration backwards: Changes for UTF-32
int ch;
for (int i = s.length()-1; i > 0; i-=UTF32.count16(ch)) {
    ch = UTF32.char32At(s,i);
    doSomethingWith(ch);
}

* </pre>
* <strong>Notes:</strong>
* <ul><li>
* <strong>Naming:</strong> For clarity, High and Low surrogates are called <code>Lead</code> and <code>Trail</code> in the API,
* which gives a better sense of their ordering in a string. <code>offset16</code> and <code>offset32</code> are used to distinguish
* offsets to UTF-16 boundaries vs offsets to UTF-32 boundaries.
* <code>int char32</code> is used to contain UTF-32 characters, as opposed to <code>char</code>, which is a UTF-16 code unit.
* </li><li>
* <strong>Roundtripping Offsets:</strong> You can always roundtrip
* from a UTF-32 offset to a UTF-16 offset and back.
* Because of the difference in structure, you can roundtrip
* from a UTF-16 offset to a UTF-32 offset and back if and only if <code>bounds(string, offset16) != TRAIL</code>.
* </li><li>
* <strong>Exceptions:</strong> The error checking will throw an exception if indices are out of bounds.
* Other than than that, all methods will behave reasonably,
* even if unmatched surrogates or out-of-bounds UTF-32 values are present.
* <code>isLegal()</code> can be used to check for validity if desired.
* </li><li>
* <strong>Unmatched Surrogates:</strong> If the string contains unmatched surrogates, then these are
* counted as one UTF-32 value. This matches their iteration behavior, which is vital.
* It also matches common display practice as
* missing glyphs (see the Unicode Standard Section 5.4, 5.5).
* </li><li>
* <strong>Out-of-bounds UTF-32 values:</strong> If a <code>char32</code> contains an out-of-bounds UTF-32 value,
* then it is treated as REPLACEMENT_CHAR for consistency across the API.
* </li><li>
* <strong>Optimization:</strong> The method implementations may need optimization if the compiler doesn't fold static final methods.
* Since surrogate pairs will form an exceeding small percentage of all the text in the world,
* the singleton case should always be optimized for.
* </li></ul>
* @author Mark Davis, with help from Markus Scherer
*/
public final class UTF32 {

    // =========================================================
    // UTILITIES
    // =========================================================

    /**
     * Unicode value used when translating into Unicode encoding form
     * and there is no existing character.
     */
	public static final char REPLACEMENT_CHAR = '\uFFFD';

    /**
     * Value returned in <code><a href="#bounds32(java.lang.String, int)">bounds32()</a></code>.
     */
    public static final int SINGLE = 1, LEAD = 2, TRAIL = 5;

    /**
    * Determines how many chars this char32 requires.
    * If a validity check is required, use <code><a href="#isLegal(char)">isLegal()</a></code>
    * on char32 before calling.
     * <p><i>If this were integrated into the Java API, it could be a static method of either Character or String.</i>
    * @return 2 if is in surrogate space, otherwise 1.
    * @param ch the input character.
    */
    public static int count16(int char32) {
        if (char32 < MIN_SUPPLEMENTARY) return 1;
        return 2;
    }

   /**
     * Extract a single UTF-32 value from a string.
     * Used when iterating forwards or backwards (with <code>count16()</code>, as well as random access.
     * If a validity check is required, use <code><a href="#isLegal(char)">isLegal()</a></code> on the return value.
     * <p><i>If this were integrated into the Java API, it could be a method of String, StringBuffer and possibly CharacterIterator.</i>
     * @return UTF-32 value for the UTF-32 value that contains the char at offset16.
     * The boundaries of that codepoint are the same as in <code>bounds32()</code>.
     * @param source array of UTF-16 chars
     * @param offset16 UTF-16 offset to the start of the character.
     */
    public static int char32At(String source, int offset16) {
        char single = source.charAt(offset16);
        if (!isSurrogate(single)) return single;

        try { // use exception to catch out-of-bounds

            // Convert the UTF-16 surrogate pair if necessary.
            // For simplicity in usage, and because the frequency of pairs is low,
            // look both directions.

	        if (isLeadSurrogate(single)) {
	            char trail = source.charAt(++offset16);
	            if (isTrailSurrogate(trail)) {
	                return ((int)single << SURROGATE_SHIFT) + trail + SURROGATE_OFFSET;
	            }
            } else { // isTrailSurrogate(single), so
	            char lead = source.charAt(--offset16);
	            if (isLeadSurrogate(lead)) {
	                return ((int)lead << SURROGATE_SHIFT) + single + SURROGATE_OFFSET;
	            }
            }
        } catch (StringIndexOutOfBoundsException e) {}
        return single; // return unmatched surrogate
    }

    public static int char32At(StringBuffer source, int offset16) {
        char single = source.charAt(offset16);
        if (!isSurrogate(single)) return single;

        try { // use exception to catch out-of-bounds

            // Convert the UTF-16 surrogate pair if necessary.
            // For simplicity in usage, and because the frequency of pairs is low,
            // look both directions.

	        if (isLeadSurrogate(single)) {
	            char trail = source.charAt(++offset16);
	            if (isTrailSurrogate(trail)) {
	                return ((int)single << SURROGATE_SHIFT) + trail + SURROGATE_OFFSET;
	            }
            } else { // isTrailSurrogate(single), so
	            char lead = source.charAt(--offset16);
	            if (isLeadSurrogate(lead)) {
	                return ((int)lead << SURROGATE_SHIFT) + single + SURROGATE_OFFSET;
	            }
            }
        } catch (StringIndexOutOfBoundsException e) {}
        return single; // return unmatched surrogate
    }

    public static int char32At(char[] source, int start16, int end16, int offset16) {
        if (offset16 < start16 || offset16 >= end16) {
            throw new ArrayIndexOutOfBoundsException(offset16);
        }

        char single = source[offset16];
        if (!isSurrogate(single)) return single;

        try { // use exception to catch out-of-bounds

            // Convert the UTF-16 surrogate pair if necessary.
            // For simplicity in usage, and because the frequency of pairs is low,
            // look both directions.

	        if (isLeadSurrogate(single)) {
	            ++offset16;
	            if (offset16 >= end16) return single;
	            char trail = source[offset16];
	            if (isTrailSurrogate(trail)) {
	                return ((int)single << SURROGATE_SHIFT) + trail + SURROGATE_OFFSET;
	            }
            } else { // isTrailSurrogate(single), so
	            char lead = source[--offset16];
	            if (isLeadSurrogate(lead)) {
	                return ((int)lead << SURROGATE_SHIFT) + single + SURROGATE_OFFSET;
	            }
            }
        } catch (ArrayIndexOutOfBoundsException e) {}
        return single; // return unmatched surrogate
    }


    // moral equivalent of valueOf32(charAt32(x)), but no memory alloc
    public static String getCodePointSubstring(String s, int offset16) {
        switch(bounds32(s,offset16)) {
          default: return s.substring(offset16,offset16+1);
          case LEAD: return s.substring(offset16,offset16+2);
          case TRAIL: return s.substring(offset16-1,offset16+1);
        }
    }

    // moral equivalent of valueOf32(charAt32(x)), but no memory alloc
    public static String getCodePointSubstring(StringBuffer s, int offset16) {
        switch(bounds32(s,offset16)) {
          default: return s.substring(offset16,offset16+1);
          case LEAD: return s.substring(offset16,offset16+2);
          case TRAIL: return s.substring(offset16-1,offset16+1);
        }
    }

    public static int append32(char[] output, int oPosition, int oEnd, int cp) {
        if (oPosition >= oEnd) throw new ArrayIndexOutOfBoundsException(oPosition);
        output[oPosition++] = UTF32.getLead(cp);
        if (UTF32.count16(cp) != 1) {
            if (oPosition >= oEnd) throw new ArrayIndexOutOfBoundsException(oPosition);
            output[oPosition++] = UTF32.getTrail(cp);
        }
        return oPosition;
    }

    public static void setChar32At(StringBuffer b, int position, int codePoint) {
        int type = bounds32(b, position);
        // handle simple cases: #chars at position match #chars in codePoint
        int end = position;
        switch (type) {
          case SINGLE:
            if (isSupplementary(codePoint)) break;
            b.setCharAt(position, (char)codePoint);
            return;
          case LEAD:
            if (!isSupplementary(codePoint)) {
                ++end;
                break;
            }
            b.setCharAt(position++, (char)getLead(codePoint));
            b.setCharAt(position, (char)getTrail(codePoint));
            return;
          case TRAIL:
            if (!isSupplementary(codePoint)) {
                --position;
                break;
            }
            b.setCharAt(position++, (char)getLead(codePoint));
            b.setCharAt(position, (char)getTrail(codePoint));
            return;
        }
        // mismatch, just use long form
        b.replace(position, end+1, valueOf32(codePoint));
    }

    /**
     * See if a char value is legal. It can't be:
     * <ul><li>Not-a-character (either \\uFFFF or\\uFFFE).
     * The datatype char itself prevents out of bounds errors.
     * </li></ul>
     * Note: legal does not mean that it is assigned in this version of Unicode.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
     * @param UTF-32 value to test
     * @return true iff legal.
     */
    public static boolean isLegal(char char16) {
        return (char16 < 0xFFFE);
    }

    /**
     * See if a UTF32 value is legal. It can't be:
     * <ul>
     * <li>Out of bounds (less than 0 or greater than MAX_UNICODE)</li>
     * <li>A surrogate value (00D800 to 00DCFF)</li>
     * <li>Not-a-character (of the form xxFFFF or xxFFFE)</li>
     * </ul>
     * Note: legal does not mean that it is assigned in this version of Unicode.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
     * @param char32 UTF-32 value to test
     * @return true iff legal.
     */
    public static boolean isLegal(int char32) {
        if (char32 < 0) return false;
        //if (char32 < SURROGATE_BASE) return true;
        //if (char32 < SURROGATE_LIMIT) return false;
        if ((char32 & PLANE_MASK) >= NON_CHARACTER_BASE) return false;
        return (char32 <= MAX_UNICODE);
    }

   /**
    * Determines whether the code unit OR code point is a surrogate.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return true iff the input character is a surrogate.
    * @param ch the input character.
    */
    public static boolean isSurrogate(int char32) {
        return (SURROGATE_BASE <= char32 && char32 < SURROGATE_LIMIT);
    }

   /**
    * Determines whether the code point is a supplementary.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return true iff the input character is a surrogate.
    * @param ch the input character.
    */
    public static boolean isSupplementary(int char32) {
        return (char32 >= MIN_SUPPLEMENTARY && char32 <= MAX_UNICODE);
    }

   /**
    * Determines whether the code point is a supplementary.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return true iff the input character is a surrogate.
    * @param ch the input character.
    */
    public static boolean isBasic(int char32) {
        return (char32 >= 0 && char32 < MIN_SUPPLEMENTARY);
    }

   /**
    * Determines whether the character is a trail surrogate.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return true iff the input character is a trail surrogate.
    * @param ch the input character.
    */
    public static boolean isTrailSurrogate(char ch) {
        return (TRAIL_BASE <= ch && ch < TRAIL_LIMIT);
    }

   /**
    * Determines whether the character is a lead surrogate.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return true iff the input character is a lead surrogate.
    * @param ch the input character.
    */
    public static boolean isLeadSurrogate(char ch) {
        return (LEAD_BASE <= ch && ch < LEAD_LIMIT);
    }

   /**
    * Returns the lead surrogate.
    * If a validity check is required, use <code><a href="#isLegal(char)">isLegal()</a></code> on char32 before calling.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return lead surrogate if the count16(ch) is 2;
    * <br>otherwise the character itself
    * @param char32 the input character.
    */
    public static char getLead(int char32) {
        if (char32 >= MIN_SUPPLEMENTARY) {
            return (char)(LEAD_BASE_OFFSET + (char32 >> SURROGATE_SHIFT));
        }
        return (char)char32;
    }

   /**
    * Returns the trail surrogate.
    * If a validity check is required, use <code><a href="#isLegal(char)">isLegal()</a></code> on char32 before calling.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return the trail surrogate if the count16(ch) is 2;
    * <br>and 0 otherwise (note: 0 is not a valid lead surrogate).
    * @param char32 the input character.
    */
    public static char getTrail(int char32) {
        if (char32 >= MIN_SUPPLEMENTARY) {
            return (char)(TRAIL_BASE + (char32 & TRAIL_MASK));
        }
        return '\u0000';
    }

   /**
    * Convenience method corresponding to String.valueOf(char). It returns a one or two char string containing
    * the UTF-32 value. If the input value can't be converted, it substitutes REPLACEMENT_CHAR.
    * If a validity check is required, use <code><a href="#isLegal(char)">isLegal()</a></code> before calling.
     * <p><i>If this were integrated into the Java API, it could be a static method of String.</i>
    * @return string value of char32
    * @param ch the input character.
    */
    public static String valueOf32(int char32) {
        if (char32 < 0 || MAX_UNICODE < char32) return String.valueOf(REPLACEMENT_CHAR);
        if (char32 < MIN_SUPPLEMENTARY) return String.valueOf((char)char32);
        synchronized (buf2) {   // saves allocations
            buf2[0] = (char)(LEAD_BASE_OFFSET + (char32 >> SURROGATE_SHIFT));
            buf2[1] = (char)(TRAIL_BASE + (char32 & TRAIL_MASK));
            return String.valueOf(buf2);
        }
    }
    private static char[] buf2 = new char[2]; // used to avoid allocations

   /**
    * Returns the UTF-32 character corresponding to the two chars.
    * If a validity check is required, check the arguments with
    * <code>isLeadSurrogate()</code> and <code>isTrailSurrogate()</code>, respectively before calling.
     * <p><i>If this were integrated into the Java API, it could be a static method of String or Character.</i>
    * @return the UTF-32 character, or REPLACEMENT_CHAR if invalid.
    * @param lead the lead char
    * @param lead the trail char
    */
    public static int getChar32(char lead, char trail) {
        if (isLeadSurrogate(lead) && isTrailSurrogate(trail)) {
            return (lead <<= SURROGATE_SHIFT) + trail + SURROGATE_OFFSET;
        }
        return REPLACEMENT_CHAR;
    }

    /**
    * Returns the type of the UTF32 boundaries around the char at offset16.
    * Used for random access.
     * <p><i>If this were integrated into the Java API, it could be a method of String, StringBuffer and possibly CharacterIterator.</i>
    * @return SINGLE, FIRST, or SECOND:
    * <ul><li>
    * SINGLE: a single char; the bounds are [offset16, offset16+1]
    * </li><li>
    * LEAD: a surrogate pair starting at offset16; the bounds are [offset16, offset16+2]
    * </li><li>
    * TRAIL: a surrogate pair starting at offset16-1; the bounds are [offset16-1, offset16+1]
    * </ul>
    * For bit-twiddlers, the return values for these are chosen so that the boundaries can be gotten by:
    * [offset16 - (value>>2), offset16 + (value&3)].
    * @param source text to analyse
    * @param offset16 UTF-16 offset
    * @exception StringIndexOutOfBoundsException if offset16 is out of bounds.
    */
    public static int bounds32(String source, int offset16) {
        char ch = source.charAt(offset16);
        if (isSurrogate(ch)) {
            if (isLeadSurrogate(ch)) {
                if (++offset16 < source.length()
                  && isTrailSurrogate(source.charAt(offset16))) return LEAD;
            } else { // isTrailSurrogate(ch), so
                if (--offset16 >= 0
                  && isLeadSurrogate(source.charAt(offset16))) return TRAIL;
            }
        }
        return SINGLE;
    }

    public static int bounds32(StringBuffer source, int offset16) {
        char ch = source.charAt(offset16);
        if (isSurrogate(ch)) {
            if (isLeadSurrogate(ch)) {
                if (++offset16 < source.length()
                  && isTrailSurrogate(source.charAt(offset16))) return LEAD;
            } else { // isTrailSurrogate(ch), so
                if (--offset16 >= 0
                  && isLeadSurrogate(source.charAt(offset16))) return TRAIL;
            }
        }
        return SINGLE;
    }

    // should be renamed bounds

    public static int bounds32(char[] source, int oStart, int oEnd, int offset16) {
        if (offset16 < oStart || offset16 >= oEnd) {
            throw new ArrayIndexOutOfBoundsException(offset16);
        }
        char ch = source[offset16];
        if (isSurrogate(ch)) {
            if (isLeadSurrogate(ch)) {
                if (++offset16 < oEnd
                  && isTrailSurrogate(source[offset16])) return LEAD;
            } else { // isTrailSurrogate(ch), so
                if (--offset16 >= oStart
                  && isLeadSurrogate(source[offset16])) return TRAIL;
            }
        }
        return SINGLE;
    }


    /**
    * Returns the UTF-16 offset that corresponds to a UTF-32 offset.
    * Used for random access. See the <a name="_top_">class description</a>
    * for notes on roundtripping.
     * <p><i>If this were integrated into the Java API, it could be a method of String, StringBuffer and possibly CharacterIterator.</i>
    * @return UTF-16 offset
    * @param offset32 UTF-32 offset
    * @param source text to analyse
    * @exception StringIndexOutOfBoundsException if offset32 is out of bounds.
    */
    public static int findOffset16(String source, int offset32) {
        int remaining = offset32; // for decrementing
        boolean hadLeadSurrogate = false;
        int i;

        for (i = 0; remaining > 0 && i < source.length(); ++i) {
            char ch = source.charAt(i);
            if (hadLeadSurrogate && isTrailSurrogate(ch)) {
                hadLeadSurrogate = false;           // count valid trail as zero
            } else {
                hadLeadSurrogate = isLeadSurrogate(ch);
                --remaining;                        // count others as 1
            }
        }

        // if we didn't use up all of remaining (or if we started < 0)
        // then it is beyond the bounds

        if (remaining != 0) throw new StringIndexOutOfBoundsException(offset32);

        // special check for last surrogate if needed, for consistency with
        // other situations

        if (hadLeadSurrogate && i < source.length() && isTrailSurrogate(source.charAt(i))) {
            ++i;                                // grab extra unicode
        }
        return i;
    }

    /**
    * Returns the UTF-32 offset corresponding to the first UTF-32 boundary at or after the given UTF-16 offset.
    * Used for random access. See the <a name="_top_">class description</a>
    * for notes on roundtripping.
    * <i>Note: If the UTF-16 offset is into the middle of a surrogate pair, then
    * the UTF-32 offset of the <strong>end</strong> of the pair is returned.</i>
    * <p>To find the UTF-32 length of a string, use:
    * <pre>
    * len32 = getOffset32(source, source.length());
    * </pre>
     * <p><i>If this were integrated into the Java API, it could be a methods of String, StringBuffer and possibly CharacterIterator.</i>
    * @return UTF-32 offset
    * @param source text to analyse
    * @param offset16 UTF-16 offset
    * @exception StringIndexOutOfBoundsException if offset16 is out of bounds.
    */
    public static int findOffset32(String source, int offset16) {
        int result = 0;
        boolean hadLeadSurrogate = false;
        for (int i = 0; i < offset16; ++i) {
            char ch = source.charAt(i);
            if (hadLeadSurrogate && isTrailSurrogate(ch)) {
                hadLeadSurrogate = false;           // count valid trail as zero
            } else {
                hadLeadSurrogate = isLeadSurrogate(ch);
                ++result;                           // count others as 1
            }
        }
        return result;
    }

    public static int length32(String source) {
        return findOffset32(source, source.length());
    }

    /**
     * Append a single UTF-32 value to the end of a StringBuffer.
    * If a validity check is required, use <code><a href="#isLegal(char)">isLegal()</a></code> on char32 before calling.
     * <p><i>If this were integrated into the Java API, it could be a method of StringBuffer.</i>
     * @param char32 value to append. If out of bounds, substitutes REPLACEMENT_CHAR.
     * @param target string to add to
     */
    public static void append32(StringBuffer target, int char32) {

        // Check for irregular values

        if (char32 < 0 || char32 > MAX_UNICODE) char32 = REPLACEMENT_CHAR;

        // Write the UTF-16 values

	    if (char32 >= MIN_SUPPLEMENTARY) {
	        target.append((char)(LEAD_BASE_OFFSET + (char32 >> SURROGATE_SHIFT)));
	        target.append((char)(TRAIL_BASE + (char32 & TRAIL_MASK)));
	    } else {
	        target.append((char)char32);
	    }
    }

    /**
     * Compare strings using Unicode code point order, instead of UTF-16 code unit order.
     */
    public static final class StringComparator implements java.util.Comparator {
        /**
         * Standard String compare. Only one small section is different, marked in the code.
         */
        public int compare(Object a, Object b) {
	        if (a == b) {
	            return 0;
	        }
            if (a == null) {
                return -1;
            } else if (b == null) {
                return 1;
            }
            String sa = (String) a;
            String sb = (String) b;
            int lena = sa.length();
            int lenb = sb.length();
            int len = lena;
            if (len > lenb) len = lenb;
            for (int i = 0; i < len; ++i) {
                char ca = sa.charAt(i);
                char cb = sb.charAt(i);
                if (ca == cb) continue; // skip remap if equal

                // start of only different section
                if (ca >= 0xD800) {  // reshuffle to get right codepoint order
                    ca += (ca < 0xE000) ? 0x2000 : -0x800;
                }
                if (cb >= 0xD800) {  // reshuffle to get right codepoint order
                    cb += (cb < 0xE000) ? 0x2000 : -0x800;
                }
                // end of only different section

                if (ca < cb) return -1;
                return 1; // wasn't equal, so return 1
            }
            if (lena < lenb) return -1;
            if (lena > lenb) return 1;
            return 0;
        }
    }

    // ===========================================================
    // PRIVATES
    // ===========================================================

    /**
     * Prevent instance from being created.
     */
    private UTF32() {}

   /**
     * Maximum code point values for UTF-32.
     */
    private static final int MAX_UNICODE = 0x10FFFF;

   /**
     * Maximum values for Basic code points (BMP).
     */
    private static final int MAX_BASIC = 0xFFFF;

   /**
     * Minimum value for Supplementary code points (SMP).
     */
    private static final int MIN_SUPPLEMENTARY = 0x10000;

    /**
     * Used to mask off single plane in checking for NON_CHARACTER
     */
    private static final int PLANE_MASK = 0xFFFF;

    /**
     * Range of non-characters in each plane
     */
    private static final int
        NON_CHARACTER_BASE = 0xFFFE,
        NON_CHARACTER_END = 0xFFFF;

    // useful statics and tables for fast lookup

	/**
	 * Values for surrogate detection. X is a surrogate iff X & SURROGATE_MASK == SURROGATE_MASK.
	 */
    static final int SURROGATE_MASK = 0xD800;

    /**
     * Bottom 10 bits for use in surrogates.
     */
	private static final int TRAIL_MASK = 0x3FF;

    /**
     * Shift value for surrogates.
     */
	private static final int SURROGATE_SHIFT = 10;

	/**
	 * Lead surrogates go from LEAD_BASE up to LEAD_LIMIT-1.
	 */
	private static final int LEAD_BASE = 0xD800, LEAD_LIMIT = 0xDC00;

	/**
	 * Trail surrogates go from TRAIL_BASE up to TRAIL_LIMIT-1.
	 */
	private static final int TRAIL_BASE = 0xDC00, TRAIL_LIMIT = 0xE000;

	/**
	 * Surrogates go from SURROGATE_BASE up to SURROGATE_LIMIT-1.
	 */
	private static final int SURROGATE_BASE = 0xD800, SURROGATE_LIMIT = 0xE000;

    /**
     * Any codepoint at or greater than SURROGATE_SPACE_BASE requires 2 16-bit code units.
     */
	//private static final int SURROGATE_SPACE_BASE = 0x10000;

    /**
     * Offset to add to combined surrogate pair to avoid masking.
     */
	private static final int SURROGATE_OFFSET = MIN_SUPPLEMENTARY
	    - (LEAD_BASE << SURROGATE_SHIFT) - TRAIL_BASE;

	private static final int LEAD_BASE_OFFSET = LEAD_BASE - (MIN_SUPPLEMENTARY >> SURROGATE_SHIFT);

};