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. * *
A rule may contain segments in its input string and segment
* references in its output string. A segment is a substring of the
* input pattern, indicated by an offset and limit. The segment may
* be in the preceding or following context. It may not span a
* context boundary. A segment reference is a special character in
* the output string that causes a segment of the input string (not
* the input pattern) to be copied to the output string. The range of
* special characters that represent segment references is defined by
* RuleBasedTransliterator.Data.
*
* @author Alan Liu
*/
class TransliterationRule : public UObject {
private:
// TODO Eliminate the pattern and keyLength data members. They
// are used only by masks() and getIndexValue() which are called
// only during build time, not during run-time. Perhaps these
// methods and pattern/keyLength can be isolated into a separate
// object.
/**
* The match that must occur before the key, or null if there is no
* preceding context.
*/
StringMatcher *anteContext;
/**
* The matcher object for the key. If null, then the key is empty.
*/
StringMatcher *key;
/**
* The match that must occur after the key, or null if there is no
* following context.
*/
StringMatcher *postContext;
/**
* The object that performs the replacement if the key,
* anteContext, and postContext are matched. Never null.
*/
UnicodeFunctor* output;
/**
* 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;
/**
* An array of matcher objects corresponding to the input pattern
* segments. If there are no segments this is null. N.B. This is
* a UnicodeMatcher for generality, but in practice it is always a
* StringMatcher. In the future we may generalize this, but for
* now we sometimes cast down to StringMatcher.
*
* The array is owned, but the pointers within it are not.
*/
UnicodeFunctor** segments;
/**
* The number of elements in segments[] or zero if segments is NULL.
*/
int32_t segmentsCount;
/**
* 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;
/**
* Miscellaneous attributes.
*/
int8_t flags;
/**
* Flag attributes.
*/
enum {
ANCHOR_START = 1,
ANCHOR_END = 2
};
/**
* An alias pointer to the data for this rule. The data provides
* lookup services for matchers and segments.
*/
const TransliterationRuleData* data;
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 outputStr 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 segs array of UnicodeMatcher corresponding to input pattern
* segments, or null if there are none. The array itself is adopted,
* but the pointers within it are not.
* @param segsCount number of elements in segs[].
* @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.
* @param data the rule data.
* @param status Output parameter filled in with success or failure status.
*/
TransliterationRule(const UnicodeString& input,
int32_t anteContextPos, int32_t postContextPos,
const UnicodeString& outputStr,
int32_t cursorPosition, int32_t cursorOffset,
UnicodeFunctor** segs,
int32_t segsCount,
UBool anchorStart, UBool anchorEnd,
const TransliterationRuleData* data,
UErrorCode& status);
/**
* Copy constructor.
* @param other the object to be copied.
*/
TransliterationRule(TransliterationRule& other);
/**
* Destructor.
*/
virtual ~TransliterationRule();
/**
* Change the data object that this rule belongs to. Used
* internally by the TransliterationRuleData copy constructor.
* @param data the new data value to be set.
*/
void setData(const TransliterationRuleData* data);
/**
* Return the preceding context length. This method is needed to
* support the Transliterator method
* getMaximumContextLength(). Internally, this is
* implemented as the anteContextLength, optionally plus one if
* there is a start anchor. The one character anchor gap is
* needed to make repeated incremental transliteration with
* anchors work.
* @return the preceding context length.
*/
virtual int32_t getContextLength(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.
* @return 8-bit index value for this rule.
*/
int16_t getIndexValue() 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.
* @param v the given index value.
* @return true if this rule matches the given index value.
*/
UBool matchesIndexValue(uint8_t v) 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".
* @param r2 the given rule to be compared with.
* @return true if this rule masks 'r2'
*/
virtual UBool masks(const TransliterationRule& r2) const;
/**
* Attempt a match and replacement at the given position. 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.
*
* If a full match is obtained, perform a replacement, update pos,
* and return U_MATCH. Otherwise both text and pos are unchanged.
*
* @param text the text
* @param pos the position indices
* @param incremental if TRUE, test for partial matches that may
* be completed by additional text inserted at pos.limit.
* @return one of U_MISMATCH,
* U_PARTIAL_MATCH, or U_MATCH. If
* incremental is FALSE then U_PARTIAL_MATCH will not be returned.
*/
UMatchDegree matchAndReplace(Replaceable& text,
UTransPosition& pos,
UBool incremental) const;
/**
* Create a rule string that represents this rule object. Append
* it to the given string.
*/
virtual UnicodeString& toRule(UnicodeString& pat,
UBool escapeUnprintable) const;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*
* @draft ICU 2.2
*/
virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @draft ICU 2.2
*/
static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
/**
* Union the set of all characters that may be modified by this rule
* into the given set.
*/
void addSourceSetTo(UnicodeSet& toUnionTo) const;
/**
* Union the set of all characters that may be emitted by this rule
* into the given set.
*/
void addTargetSetTo(UnicodeSet& toUnionTo) const;
private:
friend class StringMatcher;
/**
* The address of this static class variable serves as this class's ID
* for ICU "poor man's RTTI".
*/
static const char fgClassID;
};
U_NAMESPACE_END
#endif