organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-21 12:40:02 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 1

ICU-199 new rule syntax; performance improvement

Browse source 
X-SVN-Rev: 560
This commit is contained in:
Alan Liu 2000-01-13 07:28:31 +00:00
parent 1a6cfef879
commit 712db54818
2 changed files with 294 additions and 217 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

314
icu4c/source/i18n/unicode/rbt.h
View file

@ -16,179 +16,193 @@
class TransliterationRuleData;
/**
* A transliterator that reads a set of rules in order to determine how to
* perform translations. Rules are stored in resource bundles indexed by name.
* Rules are separated by newline characters ('\n'); to include a literal
* newline, prefix it with a backslash ('\\\n'). Whitespace is significant. If
* the first character on a line is '#', the entire line is ignored as a
* comment.
*
* <p>Each set of rules consists of two groups, one forward, and one reverse.
* This is a convention that is not enforced; rules for one direction may be
* omitted, with the result that translations in that direction will not modify
* the source text.
*
* <p><b>Rule syntax</b>
*
* <p>Rule statements take one of the following forms:
* A transliterator that reads a set of rules in order to determine how to perform
* translations. Rules are stored in resource bundles indexed by name. Rules are separated by
* semicolons (';'). To include a literal semicolon, prefix it with a backslash ('\;').
* Whitespace, as defined by <code>Character.isWhitespace()</code>, is ignored. If the first
* non-blank character on a line is '#', the entire line is ignored as a comment. </p>
*
* <p>Each set of rules consists of two groups, one forward, and one reverse. This is a
* convention that is not enforced; rules for one direction may be omitted, with the result
* that translations in that direction will not modify the source text. </p>
*
* <p><b>Rule syntax</b> </p>
*
* <p>Rule statements take one of the following forms:
*
* <dl>
* <dt><code>alefmadda=&#092;u0622</code></dt>
*
* <dd><strong>Variable definition.</strong> The name on the left is
* assigned the character or expression on the right. Names may not
* contain any special characters (see list below). Duplicate names
* (including duplicates of simple variables or category names)
* cause an exception to be thrown. If the right hand side consists
* of one character, then the variable stands for that character.
* In this example, after this statement, instances of the left hand
* name surrounded by braces, &quot;<code>{alefmadda}</code>&quot,
* will be replaced by the Unicode character U+0622.</dd> If the
* right hand side is longer than one character, then it is
* interpreted as a character category expression; see below for
* details.
*
* <dt><code>alefmadda=\u0622</code></dt>
* <dd><strong>Variable definition.</strong> The name on the left is assigned the character or
* expression on the right. Names may not contain any special characters (see list below).
* Duplicate names (including duplicates of simple variables or category names) cause an
* exception to be thrown. If the right hand side consists of one character, then the
* variable stands for that character. In this example, after this statement, instances of
* the left hand name surrounded by braces, &quot;<code>{alefmadda}</code>&quot;, will be
* replaced by the Unicode character U+0622. If the right hand side is longer than one
* character, then it is interpreted as a character category expression; see below for
* details.</dd>
* <dt>&nbsp;</dt>
* <dt><code>softvowel=[eiyEIY]</code></dt>
*
* <dd><strong>Category definition.</strong> The name on the left is assigned
* to stand for a set of characters. The same rules for names of simple
* variables apply. After this statement, the left hand variable will be
* interpreted as indicating a set of characters in appropriate contexts. The
* pattern syntax defining sets of characters is defined by {@link UnicodeSet}.
* Examples of valid patterns are:<table>
*
* <tr valign=top>
* <dd><strong>Category definition.</strong> The name on the left is assigned to stand for a
* set of characters. The same rules for names of simple variables apply. After this
* statement, the left hand variable will be interpreted as indicating a set of characters in
* appropriate contexts. The pattern syntax defining sets of characters is defined by {@link
* UnicodeSet}. Examples of valid patterns are:<table>
* <tr valign="top">
* <td nowrap><code>[abc]</code></td>
* <td>The set containing the characters 'a', 'b', and 'c'.</td>
* </tr>
* <tr valign=top>
* <tr valign="top">
* <td nowrap><code>[^abc]</code></td>
* <td>The set of all characters <em>except</em> 'a', 'b', and 'c'.</td>
* </tr>
* <tr valign=top>
* <tr valign="top">
* <td nowrap><code>[A-Z]</code></td>
* <td>The set of all characters from 'A' to 'Z' in Unicode order.</td>
* </tr>
* <tr valign=top>
* <tr valign="top">
* <td nowrap><code>[:Lu:]</code></td>
* <td>The set of Unicode uppercase letters. See
* <a href="http://www.unicode.org">www.unicode.org</a>
* <td>The set of Unicode uppercase letters. See <a href="http://www.unicode.org">www.unicode.org</a>
* for a complete list of categories and their two-letter codes.</td>
* </tr>
* <tr valign=top>
* <tr valign="top">
* <td nowrap><code>[^a-z[:Lu:][:Ll:]]</code></td>
* <td>The set of all characters <em>except</em> 'a' through 'z' and
* uppercase or lowercase letters.</td>
* <td>The set of all characters <em>except</em> 'a' through 'z' and uppercase or lowercase
* letters.</td>
* </tr>
* </table>
*
* See {@link UnicodeSet} for more documentation and examples.
* <p>See {@link UnicodeSet} for more documentation and examples. </p>
* </dd>
*
* <dt><code>ai&gt;{alefmadda}</code></dt>
*
* <dd><strong>Forward translation rule.</strong> This rule states that the
* string on the left will be changed to the string on the right when
* performing forward transliteration.</dd>
*
* <dd><strong>Forward translation rule.</strong> This rule states that the string on the left
* will be changed to the string on the right when performing forward transliteration.</dd>
* <dt>&nbsp;</dt>
* <dt><code>ai&lt;{alefmadda}</code></dt>
*
* <dd><strong>Reverse translation rule.</strong> This rule states that the
* string on the right will be changed to the string on the left when
* performing reverse transliteration.</dd>
*
* <dd><strong>Reverse translation rule.</strong> This rule states that the string on the right
* will be changed to the string on the left when performing reverse transliteration.</dd>
* </dl>
*
* <p>Forward and reverse translation rules consist of a <em>match
* pattern</em> and an <em>output string</em>. The match pattern consists
* of literal characters, optionally preceded by context, and optionally
* followed by context. Context characters, like literal pattern characters,
* must be matched in the text being transliterated. However, unlike literal
* pattern characters, they are not replaced by the output text. For example,
* the pattern "<code>[abc]def</code>" indicates the characters
* "<code>def</code>" must be preceded by "<code>abc</code>" for a successful
* match. If there is a successful match, "<code>def</code>" will be replaced,
* but not "<code>abc</code>". The initial '<code>[</code>' is optional, so
* "<code>abc]def</code>" is equivalent to "<code>[abc]def</code>". Another
* example is "<code>123[456]</code>" (or "<code>123[456</code>") in which the
* literal pattern "<code>123</code>" must be followed by "<code>456</code>".
*
* <p>The output string of a forward or reverse rule consists of characters to
* replace the literal pattern characters. If the output string contains the
* character '<code>|</code>', this is taken to indicate the location of the
* <em>cursor</em> after replacement. The cursor is the point in the text
* at which the next replacement, if any, will be applied.
*
* <p><b>Example</b>
*
* <p>The following example rules illustrate many of the features of the rule
* language.
*
* <dl>
* <dt><code>ai&lt;&gt;{alefmadda}</code></dt>
* <dd><strong>Bidirectional translation rule.</strong> This rule states that the string on the
* right will be changed to the string on the left when performing forward transliteration,
* and vice versa when performing reverse transliteration.</dd>
* </dl>
*
* <p>Forward and reverse translation rules consist of a <em>match pattern</em> and an <em>output
* string</em>. The match pattern consists of literal characters, optionally preceded by
* context, and optionally followed by context. Context characters, like literal pattern
* characters, must be matched in the text being transliterated. However, unlike literal
* pattern characters, they are not replaced by the output text. For example, the pattern
* &quot;<code>(abc)def</code>&quot; indicates the characters &quot;<code>def</code>&quot;
* must be preceded by &quot;<code>abc</code>&quot; for a successful match. If there is a
* successful match, &quot;<code>def</code>&quot; will be replaced, but not &quot;<code>abc</code>&quot;.
* The initial '<code>(</code>' is optional, so &quot;<code>abc)def</code>&quot; is
* equivalent to &quot;<code>(abc)def</code>&quot;. Another example is &quot;<code>123(456)</code>&quot;
* (or &quot;<code>123(456</code>&quot;) in which the literal pattern &quot;<code>123</code>&quot;
* must be followed by &quot;<code>456</code>&quot;. </p>
*
* <p>The output string of a forward or reverse rule consists of characters to replace the
* literal pattern characters. If the output string contains the character '<code>|</code>',
* this is taken to indicate the location of the <em>cursor</em> after replacement. The
* cursor is the point in the text at which the next replacement, if any, will be applied. </p>
*
* <p>In addition to being defined in variables, <code>UnicodeSet</code> patterns may be
* embedded directly into rule strings. Thus, the following two rules are equivalent:</p>
*
* <blockquote>
* <p><code>vowel=[aeiou]; {vowel}&gt;*; # One way to do this<br>
* [aeiou]&gt;*;
* &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; #
* Another way</code></p>
* </blockquote>
*
* <p><b>Example</b> </p>
*
* <p>The following example rules illustrate many of the features of the rule language. </p>
*
* <table cellpadding="4">
* <tr valign=top><td>Rule 1.</td>
* <td nowrap><code>abc]def&gt;x|y</code></td></tr>
* <tr valign=top><td>Rule 2.</td>
* <td nowrap><code>xyz&gt;r</code></td></tr>
* <tr valign=top><td>Rule 3.</td>
* <td nowrap><code>yz&gt;q</code></td></tr>
* <tr valign="top">
* <td>Rule 1.</td>
* <td nowrap><code>(abc)def&gt;x|y</code></td>
* </tr>
* <tr valign="top">
* <td>Rule 2.</td>
* <td nowrap><code>xyz&gt;r</code></td>
* </tr>
* <tr valign="top">
* <td>Rule 3.</td>
* <td nowrap><code>yz&gt;q</code></td>
* </tr>
* </table>
*
* <p>Applying these rules to the string "<code>adefabcdefz</code>" yields the
* following results:
*
*
* <p>Applying these rules to the string &quot;<code>adefabcdefz</code>&quot; yields the
* following results: </p>
*
* <table cellpadding="4">
* <tr valign=top><td nowrap><code>|adefabcdefz</code></td>
* <td>Initial state, no rules match. Advance cursor.</td></tr>
* <tr valign=top><td nowrap><code>a|defabcdefz</code></td>
* <td>Still no match. Rule 1 does not match because the preceding
* context is not present.</td></tr>
* <tr valign=top><td nowrap><code>ad|efabcdefz</code></td>
* <td>Still no match. Keep advancing until there is a match...</td></tr>
* <tr valign=top><td nowrap><code>ade|fabcdefz</code></td>
* <td>...</td></tr>
* <tr valign=top><td nowrap><code>adef|abcdefz</code></td>
* <td>...</td></tr>
* <tr valign=top><td nowrap><code>adefa|bcdefz</code></td>
* <td>...</td></tr>
* <tr valign=top><td nowrap><code>adefab|cdefz</code></td>
* <td>...</td></tr>
* <tr valign=top><td nowrap><code>adefabc|defz</code></td>
* <td>Rule 1 matches; replace "<code>def</code>" with "<code>xy</code>"
* and back up the cursor to before the '<code>y</code>'.</td></tr>
* <tr valign=top><td nowrap><code>adefabcx|yz</code></td>
* <td>Although "<code>xyz</code>" is present, rule 2 does not match
* because the cursor is before the '<code>y</code>', not before the
* '<code>x</code>'. Rule 3 does match. Replace "<code>yz</code>" with
* "<code>q</code>".</td></tr>
* <tr valign=top><td nowrap><code>adefabcxq|</code></td>
* <td>The cursor is at the end; transliteration is complete.</td></tr>
* <tr valign="top">
* <td nowrap><code>|adefabcdefz</code></td>
* <td>Initial state, no rules match. Advance cursor.</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>a|defabcdefz</code></td>
* <td>Still no match. Rule 1 does not match because the preceding context is not present.</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>ad|efabcdefz</code></td>
* <td>Still no match. Keep advancing until there is a match...</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>ade|fabcdefz</code></td>
* <td>...</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>adef|abcdefz</code></td>
* <td>...</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>adefa|bcdefz</code></td>
* <td>...</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>adefab|cdefz</code></td>
* <td>...</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>adefabc|defz</code></td>
* <td>Rule 1 matches; replace &quot;<code>def</code>&quot; with &quot;<code>xy</code>&quot;
* and back up the cursor to before the '<code>y</code>'.</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>adefabcx|yz</code></td>
* <td>Although &quot;<code>xyz</code>&quot; is present, rule 2 does not match because the
* cursor is before the '<code>y</code>', not before the '<code>x</code>'. Rule 3 does match.
* Replace &quot;<code>yz</code>&quot; with &quot;<code>q</code>&quot;.</td>
* </tr>
* <tr valign="top">
* <td nowrap><code>adefabcxq|</code></td>
* <td>The cursor is at the end; transliteration is complete.</td>
* </tr>
* </table>
*
* <p>The order of rules is significant. If multiple rules may match at some
* point, the first matching rule is applied.
*
* <p>Forward and reverse rules may have an empty output string. Otherwise, an
* empty left or right hand side of any statement is a syntax error.
*
* <p>Single quotes are used to quote the special characters
* <code>=&gt;&lt;{}[]|</code>. To specify a single quote itself, inside or
* outside of quotes, use two single quotes in a row. For example, the rule
* "<code>'&gt;'&gt;o''clock</code>" changes the string "<code>&gt;</code>" to
* the string "<code>o'clock</code>".
*
* <p><b>Notes</b>
*
* <p>While a RuleBasedTransliterator is being built, it checks that the rules
* are added in proper order. For example, if the rule "a>x" is followed by the
* rule "ab>y", then the second rule will throw an exception. The reason is
* that the second rule can never be triggered, since the first rule always
* matches anything it matches. In other words, the first rule <em>masks</em>
* the second rule. There is a cost of O(n^2) to make this check; in real-world
* tests it appears to approximately double build time.
*
* <p>One optimization that can be made is to add a pragma to the rule language,
* "#pragma order", that turns off ordering checking. This pragma can then be
* added to all of our resource-based rules (after we build these once and
* determine that there are no ordering errors). I haven't made this change yet
* in the interests of keeping the code from getting too byzantine.
*
* <p>The order of rules is significant. If multiple rules may match at some point, the first
* matching rule is applied. </p>
*
* <p>Forward and reverse rules may have an empty output string. Otherwise, an empty left or
* right hand side of any statement is a syntax error. </p>
*
* <p>Single quotes are used to quote the special characters <code>=&gt;&lt;{}[]()|</code>.
* To specify a single quote itself, inside or outside of quotes, use two single quotes in a
* row. For example, the rule &quot;<code>'&gt;'&gt;o''clock</code>&quot; changes the string
* &quot;<code>&gt;</code>&quot; to the string &quot;<code>o'clock</code>&quot;. </p>
*
* <p><b>Notes</b> </p>
*
* <p>While a RuleBasedTransliterator is being built, it checks that the rules are added in
* proper order. For example, if the rule &quot;a&gt;x&quot; is followed by the rule
* &quot;ab&gt;y&quot;, then the second rule will throw an exception. The reason is that the
* second rule can never be triggered, since the first rule always matches anything it
* matches. In other words, the first rule <em>masks</em> the second rule. </p>
*
* @author Alan Liu
*/
@ -227,7 +241,7 @@ public:
/**
* Constructs a new transliterator from the given rules.
* @param rules rules, separated by '\n'
* @param rules rules, separated by ';'
* @param direction either FORWARD or REVERSE.
* @exception IllegalArgumentException if rules are malformed
* or direction is invalid.
@ -323,7 +337,7 @@ private:
/**
* Constructs a new transliterator from the given rules.
* @param rules rules, separated by '\n'
* @param rules rules, separated by ';'
* @param direction either FORWARD or REVERSE.
* @exception IllegalArgumentException if rules are malformed
* or direction is invalid.

197
icu4c/source/i18n/unicode/uniset.h
View file

@ -49,35 +49,98 @@ class TransliterationRuleData;
* similar to that employed by version 8 regular expression character
* classes:
*
* <blockquote><code>
* pattern := ('[' '^'? item* ']') | ('[:' '^'? category ':]')<br>
* item := char | (char '-' char) | pattern-expr<br>
* pattern-expr := pattern | pattern-expr pattern | pattern-expr op pattern<br>
* op := '&' | '-'<br>
* special := '[' | ']' | '-'<br>
* char := <em>any character that is not</em> special |
* ('\' <em>any character</em>) |
* ('\\u' hex hex hex hex)<br>
* hex := <em>any hex digit, as defined by </em>Character.digit(c, 16)
* </code>
*
* <br>Legend:
*
* <table>
* <tr><td width=20%><code>a:=b</code>
* <td><code>a</code> may be replaced by
* <code>b</code>
* <tr><td><code>a?</code>
* <td>zero or one instance of <code>a</code><br>
* <tr><td><code>a*</code>
* <td>one or more instances of <code>a</code><br>
* <tr><td><code>a|b</code>
* <td>either <code>a</code> or <code>b</code><br>
* <tr><td><code>'a'</code>
* <td>the literal string between the quotes
* </table>
* <blockquote>
* <table>
* <tr align="top">
* <td nowrap valign="top" align="right"><code>pattern :=&nbsp; </code></td>
* <td valign="top"><code>('[' '^'? item* ']') |
* ('[:' '^'? category ':]')</code></td>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right"><code>item :=&nbsp; </code></td>
* <td valign="top"><code>char | (char '-' char) | pattern-expr<br>
* </code></td>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right"><code>pattern-expr :=&nbsp; </code></td>
* <td valign="top"><code>pattern | pattern-expr pattern |
* pattern-expr op pattern<br>
* </code></td>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right"><code>op :=&nbsp; </code></td>
* <td valign="top"><code>'&amp;' | '-'<br>
* </code></td>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right"><code>special :=&nbsp; </code></td>
* <td valign="top"><code>'[' | ']' | '-'<br>
* </code></td>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right"><code>char :=&nbsp; </code></td>
* <td valign="top"><em>any character that is not</em><code> special<br>
* | ('\u005C' </code><em>any character</em><code>)<br>
* | ('\u005Cu' hex hex hex hex)<br>
* </code></td>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right"><code>hex :=&nbsp; </code></td>
* <td valign="top"><em>any character for which
* </em><code>Character.digit(c, 16)</code><em>
* returns a non-negative result</em></td>
* </tr>
* <tr>
* <td nowrap valign="top" align="right"><code>category :=&nbsp; </code></td>
* <td valign="top"><code>'M' | 'N' | 'Z' | 'C' | 'L' | 'P' |
* 'S' | 'Mn' | 'Mc' | 'Me' | 'Nd' | 'Nl' | 'No' | 'Zs' | 'Zl' |
* 'Zp' | 'Cc' | 'Cf' | 'Cs' | 'Co' | 'Cn' | 'Lu' | 'Ll' | 'Lt'
* | 'Lm' | 'Lo' | 'Pc' | 'Pd' | 'Ps' | 'Pe' | 'Po' | 'Sm' |
* 'Sc' | 'Sk' | 'So'</code></td>
* </tr>
* </table>
* <br>
* <table border="1">
* <tr>
* <td>Legend: <table>
* <tr>
* <td nowrap valign="top"><code>a := b</code></td>
* <td width="20" valign="top">&nbsp; </td>
* <td valign="top"><code>a</code> may be replaced by <code>b</code> </td>
* </tr>
* <tr>
* <td nowrap valign="top"><code>a?</code></td>
* <td valign="top"></td>
* <td valign="top">zero or one instance of <code>a</code><br>
* </td>
* </tr>
* <tr>
* <td nowrap valign="top"><code>a*</code></td>
* <td valign="top"></td>
* <td valign="top">one or more instances of <code>a</code><br>
* </td>
* </tr>
* <tr>
* <td nowrap valign="top"><code>a | b</code></td>
* <td valign="top"></td>
* <td valign="top">either <code>a</code> or <code>b</code><br>
* </td>
* </tr>
* <tr>
* <td nowrap valign="top"><code>'a'</code></td>
* <td valign="top"></td>
* <td valign="top">the literal string between the quotes </td>
* </tr>
* </table>
* </td>
* </tr>
* </table>
* </blockquote>
*
* Any character may be preceded by a backslash in order to remove any special
* meaning. White space characters, as defined by Character.isWhitespace(), are
* ignored, unless they are escaped.
*
* Patterns specify individual characters, ranges of characters, and
* Unicode character categories. When elements are concatenated, they
* specify their union. To complement a set, place a '^' immediately
@ -256,21 +319,6 @@ public:
UnicodeSet(const UnicodeString& pattern,
UErrorCode& status);
/**
* Constructs a set from the given pattern, optionally ignoring
* white space. See the class description for the syntax of the
* pattern language.
* @param pattern a string specifying what characters are in the set
* @param ignoreSpaces if <code>true</code>, all spaces in the
* pattern are ignored, except those preceded by '\\'. Spaces are
* those characters for which <code>Character.isSpaceChar()</code>
* is <code>true</code>.
* @exception <code>IllegalArgumentException</code> if the pattern
* contains a syntax error.
*/
UnicodeSet(const UnicodeString& pattern, bool_t ignoreSpaces,
UErrorCode& status);
/**
* Constructs a set from the given Unicode character category.
* @param category an integer indicating the character category as
@ -330,30 +378,12 @@ public:
* pattern, optionally ignoring white space. See the class
* description for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param ignoreSpaces if <code>true</code>, all spaces in the
* pattern are ignored. Spaces are those characters for which
* <code>Character.isSpaceChar()</code> is <code>true</code>.
* Characters preceded by '\\' are escaped, losing any special
* meaning they otherwise have. Spaces may be included by
* escaping them.
* @exception <code>IllegalArgumentException</code> if the pattern
* contains a syntax error.
*/
virtual void applyPattern(const UnicodeString& pattern,
bool_t ignoreSpaces,
UErrorCode& status);
/**
* Modifies this set to represent the set specified by the given
* pattern. See the class description for the syntax of the pattern
* language.
* @param pattern a string specifying what characters are in the set
* @exception <code>IllegalArgumentException</code> if the pattern
* contains a syntax error.
*/
void applyPattern(const UnicodeString& pattern,
UErrorCode& status);
/**
* Returns a string representation of this set. If the result of
* calling this function is passed to a UnicodeSet constructor, it
@ -489,12 +519,50 @@ public:
*/
virtual void clear(void);
private:
//----------------------------------------------------------------
// RuleBasedTransliterator support
//----------------------------------------------------------------
friend class TransliterationRuleParser;
friend class TransliterationRule;
/**
* Constructs a set from the given pattern. See the class description
* for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param pos on input, the position in pattern at which to start parsing.
* On output, the position after the last character parsed.
* @param varNameToChar a mapping from variable names (String) to characters
* (Character). May be null. If varCharToSet is non-null, then names may
* map to either single characters or sets, depending on whether a mapping
* exists in varCharToSet. If varCharToSet is null then all names map to
* single characters.
* @param varCharToSet a mapping from characters (Character objects from
* varNameToChar) to UnicodeSet objects. May be null. Is only used if
* varNameToChar is also non-null.
* @exception <code>IllegalArgumentException</code> if the pattern
* contains a syntax error.
*/
UnicodeSet(const UnicodeString& pattern, ParsePosition& pos,
const TransliterationRuleData* data,
UErrorCode& status);
/**
* Returns <tt>true</tt> if this set contains any character whose low byte
* is the given value. This is used by <tt>RuleBasedTransliterator</tt> for
* indexing.
*/
bool_t containsIndexValue(uint8_t v) const;
private:
//----------------------------------------------------------------
// Implementation: Pattern parsing
//----------------------------------------------------------------
private:
/**
* Parses the given pattern, starting at the given position. The
* character at pattern.charAt(pos.getIndex()) must be '[', or the
@ -617,11 +685,6 @@ private:
static UChar charAfter(const UnicodeString& str, int32_t i);
};
inline void UnicodeSet::applyPattern(const UnicodeString& pattern,
UErrorCode& status) {
applyPattern(pattern, FALSE, status);
}
inline bool_t UnicodeSet::operator!=(const UnicodeSet& o) const {
return !operator==(o);
}