/// <summary>
/// UnicodeReplacer API
/// </summary>
///
public virtual int Replace(Replaceable text, int start, int limit, int[] cursor)
{
int outLen = 0;
// Copy segment with out-of-band data
int dest = limit;
// If there was no match, that means that a quantifier
// matched zero-length. E.g., x (a)* y matched "xy".
if (matchStart >= 0)
{
if (matchStart != matchLimit)
{
text.Copy(matchStart, matchLimit, dest);
outLen = matchLimit - matchStart;
}
}
text.Replace(start, limit, ""); // delete original text
return(outLen);
}
// = public static UnicodeReplacer valueOf(String output,
// = int cursorPos,
// = RuleBasedTransliterator.Data data) {
// = if (output.length() == 1) {
// = char c = output.charAt(0);
// = UnicodeReplacer r = data.lookupReplacer(c);
// = if (r != null) {
// = return r;
// = }
// = }
// = return new StringReplacer(output, cursorPos, data);
// = }
/// <summary>
/// UnicodeReplacer API
/// </summary>
///
public virtual int Replace(Replaceable text, int start, int limit, int[] cursor)
{
int outLen;
int newStart = 0;
// NOTE: It should be possible to _always_ run the complex
// processing code; just slower. If not, then there is a bug
// in the complex processing code.
// Simple (no nested replacers) Processing Code :
if (!isComplex)
{
text.Replace(start, limit, output);
outLen = output.Length;
// Setup default cursor position (for cursorPos within output)
newStart = cursorPos;
}
// Complex (nested replacers) Processing Code :
else
{
/*
* When there are segments to be copied, use the Replaceable.copy()
* API in order to retain out-of-band data. Copy everything to the
* end of the string, then copy them back over the key. This
* preserves the integrity of indices into the key and surrounding
* context while generating the output text.
*/
StringBuilder buf = new StringBuilder();
int oOutput; // offset into 'output'
isComplex = false;
// The temporary buffer starts at tempStart, and :
// to destLimit + tempExtra. The start of the buffer has a single
// character from before the key. This provides style
// data when addition characters are filled into the
// temporary buffer. If there is nothing to the left, use
// the non-character U+FFFF, which Replaceable subclasses
// should treat specially as a "no-style character."
// destStart points to the point after the style context
// character, so it is tempStart+1 or tempStart+2.
int tempStart = text.Length(); // start of temp buffer
int destStart = tempStart; // copy new text to here
if (start > 0)
{
int len = IBM.ICU.Text.UTF16.GetCharCount(text.Char32At(start - 1));
text.Copy(start - len, start, tempStart);
destStart += len;
}
else
{
text.Replace(tempStart, tempStart, "\uFFFF");
destStart++;
}
int destLimit = destStart;
int tempExtra = 0; // temp chars after destLimit
for (oOutput = 0; oOutput < output.Length;)
{
if (oOutput == cursorPos)
{
// Record the position of the cursor
newStart = buf.Length + destLimit - destStart; // relative
// to start
// the buf.length() was inserted for bug 5789
// the problem is that if we are accumulating into a buffer
// (when r == null below)
// then the actual length of the text at that point needs to
// add the buf length.
// there was an alternative suggested in #5789, but that
// looks like it won't work
// if we have accumulated some stuff in the dest part AND
// have a non-zero buffer.
}
int c = IBM.ICU.Text.UTF16.CharAt(output, oOutput);
// When we are at the last position copy the right style
// context character into the temporary buffer. We don't
// do this before because it will provide an incorrect
// right context for previous replace() operations.
int nextIndex = oOutput + IBM.ICU.Text.UTF16.GetCharCount(c);
if (nextIndex == output.Length)
{
tempExtra = IBM.ICU.Text.UTF16.GetCharCount(text.Char32At(limit));
text.Copy(limit, limit + tempExtra, destLimit);
}
UnicodeReplacer r = data.LookupReplacer(c);
if (r == null)
{
// Accumulate straight (non-segment) text.
IBM.ICU.Text.UTF16.Append(buf, c);
}
else
{
isComplex = true;
// Insert any accumulated straight text.
if (buf.Length > 0)
{
text.Replace(destLimit, destLimit, buf.ToString());
destLimit += buf.Length;
buf.Length = 0;
}
// Delegate output generation to replacer object
int len_0 = r.Replace(text, destLimit, destLimit, cursor);
destLimit += len_0;
}
oOutput = nextIndex;
}
// Insert any accumulated straight text.
if (buf.Length > 0)
{
text.Replace(destLimit, destLimit, buf.ToString());
destLimit += buf.Length;
}
if (oOutput == cursorPos)
{
// Record the position of the cursor
newStart = destLimit - destStart; // relative to start
}
outLen = destLimit - destStart;
// Copy new text to start, and delete it
text.Copy(destStart, destLimit, start);
text.Replace(tempStart + outLen, destLimit + tempExtra + outLen, "");
// Delete the old text (the key)
text.Replace(start + outLen, limit + outLen, "");
}
if (hasCursor)
{
// Adjust the cursor for positions outside the key. These
// refer to code points rather than code units. If cursorPos
// is within the output string, then use newStart, which has
// already been set above.
if (cursorPos < 0)
{
newStart = start;
int n = cursorPos;
// Outside the output string, cursorPos counts code points
while (n < 0 && newStart > 0)
{
newStart -= IBM.ICU.Text.UTF16.GetCharCount(text.Char32At(newStart - 1));
++n;
}
newStart += n;
}
else if (cursorPos > output.Length)
{
newStart = start + outLen;
int n_1 = cursorPos - output.Length;
// Outside the output string, cursorPos counts code points
while (n_1 > 0 && newStart < text.Length())
{
newStart += IBM.ICU.Text.UTF16.GetCharCount(text.Char32At(newStart));
--n_1;
}
newStart += n_1;
}
else
{
// Cursor is within output string. It has been set up above
// to be relative to start.
newStart += start;
}
cursor[0] = newStart;
}
return(outLen);
}
