The Tor Browser / file comparison

comparison: intl/icu/source/i18n/rbt_set.h

intl/icu/source/i18n/rbt_set.h

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:28ae4837eea1
1 /*
2 **********************************************************************
3 * Copyright (C) 1999-2007, International Business Machines Corporation
4 * and others. All Rights Reserved.
5 **********************************************************************
6 * Date Name Description
7 * 11/17/99 aliu Creation.
8 **********************************************************************
9 */
10 #ifndef RBT_SET_H
11 #define RBT_SET_H
12
13 #include "unicode/utypes.h"
14
15 #if !UCONFIG_NO_TRANSLITERATION
16
17 #include "unicode/uobject.h"
18 #include "unicode/utrans.h"
19 #include "uvector.h"
20
21 U_NAMESPACE_BEGIN
22
23 class Replaceable;
24 class TransliterationRule;
25 class TransliterationRuleData;
26 class UnicodeFilter;
27 class UnicodeString;
28 class UnicodeSet;
29
30 /**
31 * A set of rules for a <code>RuleBasedTransliterator</code>.
32 * @author Alan Liu
33 */
34 class TransliterationRuleSet : public UMemory {
35 /**
36 * Vector of rules, in the order added. This is used while the
37 * rule set is getting built. After that, freeze() reorders and
38 * indexes the rules into rules[]. Any given rule is stored once
39 * in ruleVector, and one or more times in rules[]. ruleVector
40 * owns and deletes the rules.
41 */
42 UVector* ruleVector;
43
44 /**
45 * Sorted and indexed table of rules. This is created by freeze()
46 * from the rules in ruleVector. It contains alias pointers to
47 * the rules in ruleVector. It is zero before freeze() is called
48 * and non-zero thereafter.
49 */
50 TransliterationRule** rules;
51
52 /**
53 * Index table. For text having a first character c, compute x = c&0xFF.
54 * Now use rules[index[x]..index[x+1]-1]. This index table is created by
55 * freeze(). Before freeze() is called it contains garbage.
56 */
57 int32_t index[257];
58
59 /**
60 * Length of the longest preceding context
61 */
62 int32_t maxContextLength;
63
64 public:
65
66 /**
67 * Construct a new empty rule set.
68 * @param status Output parameter filled in with success or failure status.
69 */
70 TransliterationRuleSet(UErrorCode& status);
71
72 /**
73 * Copy constructor.
74 */
75 TransliterationRuleSet(const TransliterationRuleSet&);
76
77 /**
78 * Destructor.
79 */
80 virtual ~TransliterationRuleSet();
81
82 /**
83 * Change the data object that this rule belongs to. Used
84 * internally by the TransliterationRuleData copy constructor.
85 * @param data the new data value to be set.
86 */
87 void setData(const TransliterationRuleData* data);
88
89 /**
90 * Return the maximum context length.
91 * @return the length of the longest preceding context.
92 */
93 virtual int32_t getMaximumContextLength(void) const;
94
95 /**
96 * Add a rule to this set. Rules are added in order, and order is
97 * significant. The last call to this method must be followed by
98 * a call to <code>freeze()</code> before the rule set is used.
99 * This method must <em>not</em> be called after freeze() has been
100 * called.
101 *
102 * @param adoptedRule the rule to add
103 */
104 virtual void addRule(TransliterationRule* adoptedRule,
105 UErrorCode& status);
106
107 /**
108 * Check this for masked rules and index it to optimize performance.
109 * The sequence of operations is: (1) add rules to a set using
110 * <code>addRule()</code>; (2) freeze the set using
111 * <code>freeze()</code>; (3) use the rule set. If
112 * <code>addRule()</code> is called after calling this method, it
113 * invalidates this object, and this method must be called again.
114 * That is, <code>freeze()</code> may be called multiple times,
115 * although for optimal performance it shouldn't be.
116 * @param parseError A pointer to UParseError to receive information about errors
117 * occurred.
118 * @param status Output parameter filled in with success or failure status.
119 */
120 virtual void freeze(UParseError& parseError, UErrorCode& status);
121
122 /**
123 * Transliterate the given text with the given UTransPosition
124 * indices. Return TRUE if the transliteration should continue
125 * or FALSE if it should halt (because of a U_PARTIAL_MATCH match).
126 * Note that FALSE is only ever returned if isIncremental is TRUE.
127 * @param text the text to be transliterated
128 * @param index the position indices, which will be updated
129 * @param isIncremental if TRUE, assume new text may be inserted
130 * at index.limit, and return FALSE if thre is a partial match.
131 * @return TRUE unless a U_PARTIAL_MATCH has been obtained,
132 * indicating that transliteration should stop until more text
133 * arrives.
134 */
135 UBool transliterate(Replaceable& text,
136 UTransPosition& index,
137 UBool isIncremental);
138
139 /**
140 * Create rule strings that represents this rule set.
141 * @param result string to receive the rule strings. Current
142 * contents will be deleted.
143 * @param escapeUnprintable True, will escape the unprintable characters
144 * @return A reference to 'result'.
145 */
146 virtual UnicodeString& toRules(UnicodeString& result,
147 UBool escapeUnprintable) const;
148
149 /**
150 * Return the set of all characters that may be modified
151 * (getTarget=false) or emitted (getTarget=true) by this set.
152 */
153 UnicodeSet& getSourceTargetSet(UnicodeSet& result,
154 UBool getTarget) const;
155
156 private:
157
158 TransliterationRuleSet &operator=(const TransliterationRuleSet &other); // forbid copying of this class
159 };
160
161 U_NAMESPACE_END
162
163 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
164
165 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial