NormalizationTable.java

/*
 *   
 *
 * Copyright  1990-2009 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

package com.sun.j2me.global;

/**
 * This interface is used to get the unicode decomposition for the given unicode
 * character.
 */
public abstract class NormalizationTable {
    /** A mask to decode the code point value. */
    protected static final int CODE_POINT_MASK              = 0x001fffff;
    /** A mask to decode the combining class. */
    protected static final int COMBINING_CLASS_MASK         = 0x07e00000;
    /** A flag indicating a code point that is unsafe to start UCA with. */
    protected static final int UNSAFE_CODE_POINT_FLAG       = 0x10000000;
    /** A flag indicating an ignorable code point. */
    protected static final int IGNORABLE_CODE_POINT_FLAG    = 0x20000000;
    /** A flag indicating a code point with a logical order exception. */
    protected static final int LOGICAL_ORDER_EXCEPTION_FLAG = 0x40000000;
    /** A flag indicating a single encoded code point. */
    protected static final int SINGLE_CODE_POINT_FLAG       = 0x80000000;
    
    /** A shift value to decode the combining class. */
    protected static final int COMBINING_CLASS_SHIFT = 21;
    
    /**
     * Returns the code point value of an encoded code point.
     *
     * @param ecp the encoded code point
     * @return the code point value
     */
    public static final int getCodePoint(int ecp) {
        return ecp & CODE_POINT_MASK;
    }

    /**
     * Returns the combining class of an encoded code point.
     *
     * @param ecp the encoded code point
     * @return the combining class
     */
    public static final int getCombiningClass(int ecp) {
        return (ecp & COMBINING_CLASS_MASK) >>> COMBINING_CLASS_SHIFT;
    }
    
    /**
     * Checks if the given code point has a logical order exception.
     *
     * @param ecp the encoded code point
     * @return <code>true</code> if the code point has a logical order 
     *      exception
     */
    public static final boolean hasLogicalOrderException(int ecp) {
        return (ecp & LOGICAL_ORDER_EXCEPTION_FLAG) != 0;
    }
    
    /**
     * Returns <code>true</code> if the given code point is unsafe to start
     * the collation algorithm with.
     *
     * @param ecp the encoded code point
     * @return <code>true</code> if the code point is unsafe
     */
    public static final boolean isUnsafe(int ecp) {
        return (ecp & UNSAFE_CODE_POINT_FLAG) != 0;
    }

    /**
     * Returns <code>true</code> if the given code point is ignorable for 
     * the collation algorithm (at all levels).
     *
     * @param ecp the encoded code point
     * @return <code>true</code> if the code point is ignorable
     */
    public static final boolean isIgnorable(int ecp) {
        return (ecp & IGNORABLE_CODE_POINT_FLAG) != 0;
    }

    /**
     * Returns <code>true</code> if the given code point has a zero combining 
     * class.
     *
     * @param ecp the encoded code point
     * @return <code>true</code> if the code point has a zero combining class
     */
    public static final boolean isStable(int ecp) {
        return (ecp & COMBINING_CLASS_MASK) == 0;
    }
    
    /**
     * Returns <code>true</code> if the given value represents a single encoded
     * code point and <code>false</code> if it's a number of code points.
     *
     * @param codeOrCount the value
     * @return <code>true</code> if the value represent a single code point,
     *      <code>false</code> if it's only a number of code points
     * @see #getCanonicalDecomposition
     */
    public static final boolean isSingleCodePoint(int codeOrCount) {
        return (codeOrCount & SINGLE_CODE_POINT_FLAG) != 0;
    }
    
    /**
     * Gets the canonical decomposition elements for the given unicode 
     * character. The decompositon is returned as a single or an array of 
     * encoded code points. The encoded values can be further decoded by 
     * the static methods of this class.
     *
     * The return value depends on the number of code points to which 
     * the given code point decomposes. If it decomposes to a single code point,
     * its encoded value is returned, otherwise the decomposition is stored in
     * the given array and the method returns only the length of the 
     * decomposition.
     *
     * @param buffer an array for the decomposition
     * @param offset the offset from the beginning of the array, where to place
     *      the decomposition
     * @param cp the code point to decompose
     * @return the length of the decomposition or a single encoded code point 
     * @see #isSingleCodePoint
     */
    public abstract int getCanonicalDecomposition(int[] buffer, int offset, 
            int cp);
    
    /**
     * Returns the length of the longest decomposition in the table.
     *
     * @return the maximum decomposition length
     */
    public abstract int getMaxDecompositionLength();
}