RuleBasedTransliterator.
* TransliterationRule is an immutable object.
*
* A rule consists of an input pattern and an output string. When
* the input pattern is matched, the output string is emitted. The
* input pattern consists of zero or more characters which are matched
* exactly (the key) and optional context. Context must match if it
* is specified. Context may be specified before the key, after the
* key, or both. The key, preceding context, and following context
* may contain variables. Variables represent a set of Unicode
* characters, such as the letters a through z.
* Variables are detected by looking up each character in a supplied
* variable list to see if it has been so defined.
*
* @author Alan Liu
*/
class TransliterationRule {
public:
/**
* Constants returned by getMatchDegree() indicating
* the degree of match between the text and this rule.
* @see #getMatchDegree
*/
enum {
/**
* Constant returned by getMatchDegree()
* indicating a mismatch between the text and this rule. One
* or more characters of the context or key do not match the
* text.
*/
MISMATCH,
/**
* Constant returned by getMatchDegree()
* indicating a partial match between the text and this rule.
* All characters of the text match the corresponding context
* or key, but more characters are required for a complete
* match. There are some key or context characters at the end
* of the pattern that remain unmatched because the text isn't
* long enough.
*/
PARTIAL_MATCH,
/**
* Constant returned by getMatchDegree()
* indicating a complete match between the text and this rule.
* The text matches all context and key characters.
*/
FULL_MATCH
};
/**
* The character at index i, where i < contextStart || i >= contextLimit,
* is ETHER. This allows explicit matching by rules and UnicodeSets
* of text outside the context. In traditional terms, this allows anchoring
* at the start and/or end.
*/
static const UChar ETHER;
private:
/**
* The string that must be matched, consisting of the anteContext, key,
* and postContext, concatenated together, in that order. Some components
* may be empty (zero length).
* @see anteContextLength
* @see keyLength
*/
UnicodeString pattern;
/**
* The string that is emitted if the key, anteContext, and postContext
* are matched.
*/
UnicodeString output;
/**
* Array of segments. These are segments of the input string that may be
* referenced and appear in the output string. Each segment is stored as an
* offset, limit pair. Segments are referenced by a 1-based index;
* reference i thus includes characters at offset segments[2*i-2] to
* segments[2*i-1]-1 in the pattern string.
*
* In the output string, a segment reference is indicated by a character in
* a special range, as defined by RuleBasedTransliterator.Data.
*
* Most rules have no segments, in which case segments is null, and the
* output string need not be checked for segment reference characters.
*/
int32_t* segments;
/**
* The length of the string that must match before the key. If
* zero, then there is no matching requirement before the key.
* Substring [0,anteContextLength) of pattern is the anteContext.
*/
int32_t anteContextLength;
/**
* The length of the key. Substring [anteContextLength,
* anteContextLength + keyLength) is the key.
*/
int32_t keyLength;
/**
* The position of the cursor after emitting the output string, from 0 to
* output.length(). For most rules with no special cursor specification,
* the cursorPos is output.length().
*/
int32_t cursorPos;
public:
/**
* Construct a new rule with the given input, output text, and other
* attributes. A cursor position may be specified for the output text.
* @param input input string, including key and optional ante and
* post context
* @param anteContextPos offset into input to end of ante context, or -1 if
* none. Must be <= input.length() if not -1.
* @param postContextPos offset into input to start of post context, or -1
* if none. Must be <= input.length() if not -1, and must be >=
* anteContextPos.
* @param output output string
* @param cursorPosition offset into output at which cursor is located, or -1 if
* none. If less than zero, then the cursor is placed after the
* output; that is, -1 is equivalent to
* output.length(). If greater than
* output.length() then an exception is thrown.
* @param cursorOffset an offset to be added to cursorPos to position the
* cursor either in the ante context, if < 0, or in the post context, if >
* 0. For example, the rule "abc{def} > | @@@ xyz;" changes "def" to
* "xyz" and moves the cursor to before "a". It would have a cursorOffset
* of -3.
* @param adoptedSegs array of 2n integers. Each of n pairs consists of offset,
* limit for a segment of the input string. Characters in the output string
* refer to these segments if they are in a special range determined by the
* associated RuleBasedTransliterator.Data object. May be null if there are
* no segments.
* @param anchorStart TRUE if the the rule is anchored on the left to
* the context start
* @param anchorEnd TRUE if the rule is anchored on the right to the
* context limit
*/
TransliterationRule(const UnicodeString& input,
int32_t anteContextPos, int32_t postContextPos,
const UnicodeString& outputStr,
int32_t cursorPosition, int32_t cursorOffset,
int32_t* adoptedSegs,
UBool anchorStart, UBool anchorEnd,
UErrorCode& status);
/**
* Construct a new rule with the given input, output text, and other
* attributes. A cursor position may be specified for the output text.
* @param input input string, including key and optional ante and
* post context
* @param anteContextPos offset into input to end of ante context, or -1 if
* none. Must be <= input.length() if not -1.
* @param postContextPos offset into input to start of post context, or -1
* if none. Must be <= input.length() if not -1, and must be >=
* anteContextPos.
* @param output output string
* @param cursorPosition offset into output at which cursor is located, or -1 if
* none. If less than zero, then the cursor is placed after the
* output; that is, -1 is equivalent to
* output.length(). If greater than
* output.length() then an exception is thrown.
*/
TransliterationRule(const UnicodeString& input,
int32_t anteContextPos, int32_t postContextPos,
const UnicodeString& outputStr,
int32_t cursorPosition,
UErrorCode& status);
/**
* Copy constructor.
*/
TransliterationRule(TransliterationRule& other);
/**
* Destructor.
*/
virtual ~TransliterationRule();
/**
* Return the position of the cursor within the output string.
* @return a value from 0 to getOutput().length(), inclusive.
*/
virtual int32_t getCursorPos(void) const;
/**
* Return the preceding context length. This method is needed to
* support the Transliterator method
* getMaximumContextLength().
*/
virtual int32_t getAnteContextLength(void) const;
/**
* Internal method. Returns 8-bit index value for this rule.
* This is the low byte of the first character of the key,
* unless the first character of the key is a set. If it's a
* set, or otherwise can match multiple keys, the index value is -1.
*/
int16_t getIndexValue(const TransliterationRuleData& data) const;
/**
* Do a replacement of the input pattern with the output text in
* the given string, at the given offset. This method assumes
* that a match has already been found in the given text at the
* given position.
* @param text the text containing the substring to be replaced
* @param offset the offset into the text at which the pattern
* matches. This is the offset to the point after the ante
* context, if any, and before the match string and any post
* context.
* @param data the RuleBasedTransliterator.Data object specifying
* context for this transliterator.
* @return the change in the length of the text
*/
int32_t replace(Replaceable& text, int32_t offset,
const TransliterationRuleData& data) const;
/**
* Internal method. Returns true if this rule matches the given
* index value. The index value is an 8-bit integer, 0..255,
* representing the low byte of the first character of the key.
* It matches this rule if it matches the first character of the
* key, or if the first character of the key is a set, and the set
* contains any character with a low byte equal to the index
* value. If the rule contains only ante context, as in foo)>bar,
* then it will match any key.
*/
UBool matchesIndexValue(uint8_t v,
const TransliterationRuleData& data) const;
/**
* Return true if this rule masks another rule. If r1 masks r2 then
* r1 matches any input string that r2 matches. If r1 masks r2 and r2 masks
* r1 then r1 == r2. Examples: "a>x" masks "ab>y". "a>x" masks "a[b]>y".
* "[c]a>x" masks "[dc]a>y".
*/
virtual UBool masks(const TransliterationRule& r2) const;
/**
* Return true if this rule matches the given text.
* @param text the text, both translated and untranslated
* @param start the beginning index, inclusive; 0 <= start
* <= limit.
* @param limit the ending index, exclusive; start <= limit
* <= text.length().
* @param cursor position at which to translate next, representing offset
* into text. This value must be between start and
* limit.
* @param filter the filter. Any character for which
* filter.isIn() returns false will not be
* altered by this transliterator. If filter is
* null then no filtering is applied.
*/
virtual UBool matches(const Replaceable& text,
const UTransPosition& pos,
const TransliterationRuleData& data,
const UnicodeFilter* filter) const;
/**
* Return the degree of match between this rule and the given text. The
* degree of match may be mismatch, a partial match, or a full match. A
* mismatch means at least one character of the text does not match the
* context or key. A partial match means some context and key characters
* match, but the text is not long enough to match all of them. A full
* match means all context and key characters match.
* @param text the text, both translated and untranslated
* @param start the beginning index, inclusive; 0 <= start
* <= limit.
* @param limit the ending index, exclusive; start <= limit
* <= text.length().
* @param cursor position at which to translate next, representing offset
* into text. This value must be between start and
* limit.
* @param filter the filter. Any character for which
* filter.isIn() returns false will not be
* altered by this transliterator. If filter is
* null then no filtering is applied.
* @return one of MISMATCH, PARTIAL_MATCH, or
* FULL_MATCH.
* @see #MISMATCH
* @see #PARTIAL_MATCH
* @see #FULL_MATCH
*/
virtual int32_t getMatchDegree(const Replaceable& text,
const UTransPosition& pos,
const TransliterationRuleData& data,
const UnicodeFilter* filter) const;
/**
* Return the number of characters of the text that match this rule. If
* there is a mismatch, return -1. If the text is not long enough to match
* any characters, return 0.
* @param text the text, both translated and untranslated
* @param start the beginning index, inclusive; 0 <= start
* <= limit.
* @param limit the ending index, exclusive; start <= limit
* <= text.length().
* @param cursor position at which to translate next, representing offset
* into text. This value must be between start and
* limit.
* @param data a dictionary of variables mapping Character
* to UnicodeSet
* @param filter the filter. Any character for which
* filter.isIn() returns false will not be
* altered by this transliterator. If filter is
* null then no filtering is applied.
* @return -1 if there is a mismatch, 0 if the text is not long enough to
* match any characters, otherwise the number of characters of text that
* match this rule.
*/
virtual int32_t getRegionMatchLength(const Replaceable& text,
const UTransPosition& pos,
const TransliterationRuleData& data,
const UnicodeFilter* filter) const;
/**
* Return true if the given key matches the given text. This method
* accounts for the fact that the key character may represent a character
* set. Note that the key and text characters may not be interchanged
* without altering the results.
* @param keyChar a character in the match key
* @param textChar a character in the text being transliterated
* @param data a dictionary of variables mapping Character
* to UnicodeSet
* @param filter the filter. Any character for which
* filter.isIn() returns false will not be
* altered by this transliterator. If filter is
* null then no filtering is applied.
*/
virtual UBool charMatches(UChar keyChar, const Replaceable& textChar,
int32_t index,
const UTransPosition& pos,
const TransliterationRuleData& data,
const UnicodeFilter* filter) const;
/**
* Return true if the given key matches the given text. This method
* accounts for the fact that the key character may represent a character
* set. Note that the key and text characters may not be interchanged
* without altering the results.
* @param keyChar a character in the match key
* @param textChar a character in the text being transliterated
* @param data a dictionary of variables mapping Character
* to UnicodeSet
* @param filter the filter. Any character for which
* filter.isIn() returns false will not be
* altered by this transliterator. If filter is
* null then no filtering is applied.
*/
//[ANCHOR] virtual UBool charMatches(UChar keyChar, UChar textChar,
//[ANCHOR] const TransliterationRuleData& data,
//[ANCHOR] const UnicodeFilter* filter) const;
private:
void init(const UnicodeString& input,
int32_t anteContextPos, int32_t postContextPos,
const UnicodeString& output,
int32_t cursorPos, int32_t cursorOffset,
int32_t* adoptedSegs,
UBool anchorStart, UBool anchorEnd,
UErrorCode& status);
};
#endif