go

[Dictionary.git] / jars / icu4j-4_4_2-src / main / classes / translit / src / com / ibm / icu / text / StringReplacer.java

/*\r
**********************************************************************\r
*   Copyright (c) 2002-2007, International Business Machines Corporation\r
*   and others.  All Rights Reserved.\r
**********************************************************************\r
*   Date        Name        Description\r
*   01/14/2002  aliu        Creation.\r
**********************************************************************\r
*/\r
\r
package com.ibm.icu.text;\r
import com.ibm.icu.impl.Utility;\r
\r
/**\r
 * A replacer that produces static text as its output.  The text may\r
 * contain transliterator stand-in characters that represent nested\r
 * UnicodeReplacer objects, making it possible to encode a tree of\r
 * replacers in a StringReplacer.  A StringReplacer that contains such\r
 * stand-ins is called a <em>complex</em> StringReplacer.  A complex\r
 * StringReplacer has a slower processing loop than a non-complex one.\r
 * @author Alan Liu\r
 */\r
class StringReplacer implements UnicodeReplacer {\r
\r
    /**\r
     * Output text, possibly containing stand-in characters that\r
     * represent nested UnicodeReplacers.\r
     */\r
    private String output;\r
\r
    /**\r
     * Cursor position.  Value is ignored if hasCursor is false.\r
     */\r
    private int cursorPos;\r
\r
    /**\r
     * True if this object outputs a cursor position.\r
     */\r
    private boolean hasCursor;\r
\r
    /**\r
     * A complex object contains nested replacers and requires more\r
     * complex processing.  StringReplacers are initially assumed to\r
     * be complex.  If no nested replacers are seen during processing,\r
     * then isComplex is set to false, and future replacements are\r
     * short circuited for better performance.\r
     */\r
    private boolean isComplex;\r
\r
    /**\r
     * Object that translates stand-in characters in 'output' to\r
     * UnicodeReplacer objects.\r
     */\r
    private final RuleBasedTransliterator.Data data;\r
\r
    /**\r
     * Construct a StringReplacer that sets the emits the given output\r
     * text and sets the cursor to the given position.\r
     * @param theOutput text that will replace input text when the\r
     * replace() method is called.  May contain stand-in characters\r
     * that represent nested replacers.\r
     * @param theCursorPos cursor position that will be returned by\r
     * the replace() method\r
     * @param theData transliterator context object that translates\r
     * stand-in characters to UnicodeReplacer objects\r
     */\r
    public StringReplacer(String theOutput,\r
                          int theCursorPos,\r
                          RuleBasedTransliterator.Data theData) {\r
        output = theOutput;\r
        cursorPos = theCursorPos;\r
        hasCursor = true;\r
        data = theData;\r
        isComplex = true;\r
    }\r
\r
    /**\r
     * Construct a StringReplacer that sets the emits the given output\r
     * text and does not modify the cursor.\r
     * @param theOutput text that will replace input text when the\r
     * replace() method is called.  May contain stand-in characters\r
     * that represent nested replacers.\r
     * @param theData transliterator context object that translates\r
     * stand-in characters to UnicodeReplacer objects\r
     */\r
    public StringReplacer(String theOutput,\r
                          RuleBasedTransliterator.Data theData) {\r
        output = theOutput;\r
        cursorPos = 0;\r
        hasCursor = false;\r
        data = theData;\r
        isComplex = true;\r
    }\r
\r
//=    public static UnicodeReplacer valueOf(String output,\r
//=                                          int cursorPos,\r
//=                                          RuleBasedTransliterator.Data data) {\r
//=        if (output.length() == 1) {\r
//=            char c = output.charAt(0);\r
//=            UnicodeReplacer r = data.lookupReplacer(c);\r
//=            if (r != null) {\r
//=                return r;\r
//=            }\r
//=        }\r
//=        return new StringReplacer(output, cursorPos, data);\r
//=    }\r
\r
    /**\r
     * UnicodeReplacer API\r
     */\r
    public int replace(Replaceable text,\r
                       int start,\r
                       int limit,\r
                       int[] cursor) {\r
        int outLen;\r
        int newStart = 0;\r
\r
        // NOTE: It should be possible to _always_ run the complex\r
        // processing code; just slower.  If not, then there is a bug\r
        // in the complex processing code.\r
\r
        // Simple (no nested replacers) Processing Code :\r
        if (!isComplex) {\r
            text.replace(start, limit, output);\r
            outLen = output.length();\r
\r
            // Setup default cursor position (for cursorPos within output)\r
            newStart = cursorPos;\r
        }\r
\r
        // Complex (nested replacers) Processing Code :\r
        else {\r
            /* When there are segments to be copied, use the Replaceable.copy()\r
             * API in order to retain out-of-band data.  Copy everything to the\r
             * end of the string, then copy them back over the key.  This preserves\r
             * the integrity of indices into the key and surrounding context while\r
             * generating the output text.\r
             */\r
            StringBuffer buf = new StringBuffer();\r
            int oOutput; // offset into 'output'\r
            isComplex = false;\r
\r
            // The temporary buffer starts at tempStart, and extends\r
            // to destLimit + tempExtra.  The start of the buffer has a single\r
            // character from before the key.  This provides style\r
            // data when addition characters are filled into the\r
            // temporary buffer.  If there is nothing to the left, use\r
            // the non-character U+FFFF, which Replaceable subclasses\r
            // should treat specially as a "no-style character."\r
            // destStart points to the point after the style context\r
            // character, so it is tempStart+1 or tempStart+2.\r
            int tempStart = text.length(); // start of temp buffer\r
            int destStart = tempStart; // copy new text to here\r
            if (start > 0) {\r
                int len = UTF16.getCharCount(text.char32At(start-1));\r
                text.copy(start-len, start, tempStart);\r
                destStart += len;\r
            } else {\r
                text.replace(tempStart, tempStart, "\uFFFF");\r
                destStart++;\r
            }\r
            int destLimit = destStart;\r
            int tempExtra = 0; // temp chars after destLimit\r
\r
            for (oOutput=0; oOutput<output.length(); ) {\r
                if (oOutput == cursorPos) {\r
                    // Record the position of the cursor\r
                    newStart = buf.length() + destLimit - destStart; // relative to start\r
                    // the buf.length() was inserted for bug 5789\r
                    // the problem is that if we are accumulating into a buffer (when r == null below)\r
                    // then the actual length of the text at that point needs to add the buf length.\r
                    // there was an alternative suggested in #5789, but that looks like it won't work\r
                    // if we have accumulated some stuff in the dest part AND have a non-zero buffer.\r
                }\r
                int c = UTF16.charAt(output, oOutput);\r
\r
                // When we are at the last position copy the right style\r
                // context character into the temporary buffer.  We don't\r
                // do this before because it will provide an incorrect\r
                // right context for previous replace() operations.\r
                int nextIndex = oOutput + UTF16.getCharCount(c);\r
                if (nextIndex == output.length()) {\r
                    tempExtra = UTF16.getCharCount(text.char32At(limit));\r
                    text.copy(limit, limit+tempExtra, destLimit);\r
                }\r
\r
                UnicodeReplacer r = data.lookupReplacer(c);\r
                if (r == null) {\r
                    // Accumulate straight (non-segment) text.\r
                    UTF16.append(buf, c);\r
                } else {\r
                    isComplex = true;\r
\r
                    // Insert any accumulated straight text.\r
                    if (buf.length() > 0) {\r
                        text.replace(destLimit, destLimit, buf.toString());\r
                        destLimit += buf.length();\r
                        buf.setLength(0);\r
                    }\r
\r
                    // Delegate output generation to replacer object\r
                    int len = r.replace(text, destLimit, destLimit, cursor);\r
                    destLimit += len;\r
                }\r
                oOutput = nextIndex;\r
            }\r
            // Insert any accumulated straight text.\r
            if (buf.length() > 0) {\r
                text.replace(destLimit, destLimit, buf.toString());\r
                destLimit += buf.length();\r
            }\r
            if (oOutput == cursorPos) {\r
                // Record the position of the cursor\r
                newStart = destLimit - destStart; // relative to start\r
            }\r
\r
            outLen = destLimit - destStart;\r
\r
            // Copy new text to start, and delete it\r
            text.copy(destStart, destLimit, start);\r
            text.replace(tempStart + outLen, destLimit + tempExtra + outLen, "");\r
\r
            // Delete the old text (the key)\r
            text.replace(start + outLen, limit + outLen, "");\r
        }        \r
\r
        if (hasCursor) {\r
            // Adjust the cursor for positions outside the key.  These\r
            // refer to code points rather than code units.  If cursorPos\r
            // is within the output string, then use newStart, which has\r
            // already been set above.\r
            if (cursorPos < 0) {\r
                newStart = start;\r
                int n = cursorPos;\r
                // Outside the output string, cursorPos counts code points\r
                while (n < 0 && newStart > 0) {\r
                    newStart -= UTF16.getCharCount(text.char32At(newStart-1));\r
                    ++n;\r
                }\r
                newStart += n;\r
            } else if (cursorPos > output.length()) {\r
                newStart = start + outLen;\r
                int n = cursorPos - output.length();\r
                // Outside the output string, cursorPos counts code points\r
                while (n > 0 && newStart < text.length()) {\r
                    newStart += UTF16.getCharCount(text.char32At(newStart));\r
                    --n;\r
                }\r
                newStart += n;\r
            } else {\r
                // Cursor is within output string.  It has been set up above\r
                // to be relative to start.\r
                newStart += start;\r
            }\r
\r
            cursor[0] = newStart;\r
        }\r
\r
        return outLen;\r
    }\r
\r
    /**\r
     * UnicodeReplacer API\r
     */\r
    public String toReplacerPattern(boolean escapeUnprintable) {\r
        StringBuffer rule = new StringBuffer();\r
        StringBuffer quoteBuf = new StringBuffer();\r
\r
        int cursor = cursorPos;\r
\r
        // Handle a cursor preceding the output\r
        if (hasCursor && cursor < 0) {\r
            while (cursor++ < 0) {\r
                Utility.appendToRule(rule, '@', true, escapeUnprintable, quoteBuf);\r
            }\r
            // Fall through and append '|' below\r
        }\r
\r
        for (int i=0; i<output.length(); ++i) {\r
            if (hasCursor && i == cursor) {\r
                Utility.appendToRule(rule, '|', true, escapeUnprintable, quoteBuf);\r
            }\r
            char c = output.charAt(i); // Ok to use 16-bits here\r
\r
            UnicodeReplacer r = data.lookupReplacer(c);\r
            if (r == null) {\r
                Utility.appendToRule(rule, c, false, escapeUnprintable, quoteBuf);\r
            } else {\r
                StringBuffer buf = new StringBuffer(" ");\r
                buf.append(r.toReplacerPattern(escapeUnprintable));\r
                buf.append(' ');\r
                Utility.appendToRule(rule, buf.toString(),\r
                                     true, escapeUnprintable, quoteBuf);\r
            }\r
        }\r
\r
        // Handle a cursor after the output.  Use > rather than >= because\r
        // if cursor == output.length() it is at the end of the output,\r
        // which is the default position, so we need not emit it.\r
        if (hasCursor && cursor > output.length()) {\r
            cursor -= output.length();\r
            while (cursor-- > 0) {\r
                Utility.appendToRule(rule, '@', true, escapeUnprintable, quoteBuf);\r
            }\r
            Utility.appendToRule(rule, '|', true, escapeUnprintable, quoteBuf);\r
        }\r
        // Flush quoteBuf out to result\r
        Utility.appendToRule(rule, -1,\r
                             true, escapeUnprintable, quoteBuf);\r
\r
        return rule.toString();\r
    }\r
\r
    /**\r
     * Union the set of all characters that may output by this object\r
     * into the given set.\r
     * @param toUnionTo the set into which to union the output characters\r
     */\r
    public void addReplacementSetTo(UnicodeSet toUnionTo) {\r
        int ch;\r
        for (int i=0; i<output.length(); i+=UTF16.getCharCount(ch)) {\r
            ch = UTF16.charAt(output, i);\r
            UnicodeReplacer r = data.lookupReplacer(ch);\r
            if (r == null) {\r
                toUnionTo.add(ch);\r
            } else {\r
                r.addReplacementSetTo(toUnionTo);\r
            }\r
        }\r
    }\r
}\r
\r
//eof\r