The Tor Browser / file comparison

comparison: intl/icu/source/common/unicode/usetiter.h

intl/icu/source/common/unicode/usetiter.h

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:6a3df20a01da
1 /*
2 **********************************************************************
3 * Copyright (c) 2002-2008, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 **********************************************************************
6 */
7 #ifndef USETITER_H
8 #define USETITER_H
9
10 #include "unicode/utypes.h"
11 #include "unicode/uobject.h"
12 #include "unicode/unistr.h"
13
14 /**
15 * \file
16 * \brief C++ API: UnicodeSetIterator iterates over the contents of a UnicodeSet.
17 */
18
19 U_NAMESPACE_BEGIN
20
21 class UnicodeSet;
22 class UnicodeString;
23
24 /**
25 *
26 * UnicodeSetIterator iterates over the contents of a UnicodeSet. It
27 * iterates over either code points or code point ranges. After all
28 * code points or ranges have been returned, it returns the
29 * multicharacter strings of the UnicodeSet, if any.
30 *
31 * This class is not intended to be subclassed. Consider any fields
32 * or methods declared as "protected" to be private. The use of
33 * protected in this class is an artifact of history.
34 *
35 * <p>To iterate over code points and strings, use a loop like this:
36 * <pre>
37 * UnicodeSetIterator it(set);
38 * while (it.next()) {
39 * processItem(it.getString());
40 * }
41 * </pre>
42 * <p>Each item in the set is accessed as a string. Set elements
43 * consisting of single code points are returned as strings containing
44 * just the one code point.
45 *
46 * <p>To iterate over code point ranges, instead of individual code points,
47 * use a loop like this:
48 * <pre>
49 * UnicodeSetIterator it(set);
50 * while (it.nextRange()) {
51 * if (it.isString()) {
52 * processString(it.getString());
53 * } else {
54 * processCodepointRange(it.getCodepoint(), it.getCodepointEnd());
55 * }
56 * }
57 * </pre>
58 * @author M. Davis
59 * @stable ICU 2.4
60 */
61 class U_COMMON_API UnicodeSetIterator : public UObject {
62
63 protected:
64
65 /**
66 * Value of <tt>codepoint</tt> if the iterator points to a string.
67 * If <tt>codepoint == IS_STRING</tt>, then examine
68 * <tt>string</tt> for the current iteration result.
69 * @stable ICU 2.4
70 */
71 enum { IS_STRING = -1 };
72
73 /**
74 * Current code point, or the special value <tt>IS_STRING</tt>, if
75 * the iterator points to a string.
76 * @stable ICU 2.4
77 */
78 UChar32 codepoint;
79
80 /**
81 * When iterating over ranges using <tt>nextRange()</tt>,
82 * <tt>codepointEnd</tt> contains the inclusive end of the
83 * iteration range, if <tt>codepoint != IS_STRING</tt>. If
84 * iterating over code points using <tt>next()</tt>, or if
85 * <tt>codepoint == IS_STRING</tt>, then the value of
86 * <tt>codepointEnd</tt> is undefined.
87 * @stable ICU 2.4
88 */
89 UChar32 codepointEnd;
90
91 /**
92 * If <tt>codepoint == IS_STRING</tt>, then <tt>string</tt> points
93 * to the current string. If <tt>codepoint != IS_STRING</tt>, the
94 * value of <tt>string</tt> is undefined.
95 * @stable ICU 2.4
96 */
97 const UnicodeString* string;
98
99 public:
100
101 /**
102 * Create an iterator over the given set. The iterator is valid
103 * only so long as <tt>set</tt> is valid.
104 * @param set set to iterate over
105 * @stable ICU 2.4
106 */
107 UnicodeSetIterator(const UnicodeSet& set);
108
109 /**
110 * Create an iterator over nothing. <tt>next()</tt> and
111 * <tt>nextRange()</tt> return false. This is a convenience
112 * constructor allowing the target to be set later.
113 * @stable ICU 2.4
114 */
115 UnicodeSetIterator();
116
117 /**
118 * Destructor.
119 * @stable ICU 2.4
120 */
121 virtual ~UnicodeSetIterator();
122
123 /**
124 * Returns true if the current element is a string. If so, the
125 * caller can retrieve it with <tt>getString()</tt>. If this
126 * method returns false, the current element is a code point or
127 * code point range, depending on whether <tt>next()</tt> or
128 * <tt>nextRange()</tt> was called.
129 * Elements of types string and codepoint can both be retrieved
130 * with the function <tt>getString()</tt>.
131 * Elements of type codepoint can also be retrieved with
132 * <tt>getCodepoint()</tt>.
133 * For ranges, <tt>getCodepoint()</tt> returns the starting codepoint
134 * of the range, and <tt>getCodepointEnd()</tt> returns the end
135 * of the range.
136 * @stable ICU 2.4
137 */
138 inline UBool isString() const;
139
140 /**
141 * Returns the current code point, if <tt>isString()</tt> returned
142 * false. Otherwise returns an undefined result.
143 * @stable ICU 2.4
144 */
145 inline UChar32 getCodepoint() const;
146
147 /**
148 * Returns the end of the current code point range, if
149 * <tt>isString()</tt> returned false and <tt>nextRange()</tt> was
150 * called. Otherwise returns an undefined result.
151 * @stable ICU 2.4
152 */
153 inline UChar32 getCodepointEnd() const;
154
155 /**
156 * Returns the current string, if <tt>isString()</tt> returned
157 * true. If the current iteration item is a code point, a UnicodeString
158 * containing that single code point is returned.
159 *
160 * Ownership of the returned string remains with the iterator.
161 * The string is guaranteed to remain valid only until the iterator is
162 * advanced to the next item, or until the iterator is deleted.
163 *
164 * @stable ICU 2.4
165 */
166 const UnicodeString& getString();
167
168 /**
169 * Advances the iteration position to the next element in the set,
170 * which can be either a single code point or a string.
171 * If there are no more elements in the set, return false.
172 *
173 * <p>
174 * If <tt>isString() == TRUE</tt>, the value is a
175 * string, otherwise the value is a
176 * single code point. Elements of either type can be retrieved
177 * with the function <tt>getString()</tt>, while elements of
178 * consisting of a single code point can be retrieved with
179 * <tt>getCodepoint()</tt>
180 *
181 * <p>The order of iteration is all code points in sorted order,
182 * followed by all strings sorted order. Do not mix
183 * calls to <tt>next()</tt> and <tt>nextRange()</tt> without
184 * calling <tt>reset()</tt> between them. The results of doing so
185 * are undefined.
186 *
187 * @return true if there was another element in the set.
188 * @stable ICU 2.4
189 */
190 UBool next();
191
192 /**
193 * Returns the next element in the set, either a code point range
194 * or a string. If there are no more elements in the set, return
195 * false. If <tt>isString() == TRUE</tt>, the value is a
196 * string and can be accessed with <tt>getString()</tt>. Otherwise the value is a
197 * range of one or more code points from <tt>getCodepoint()</tt> to
198 * <tt>getCodepointeEnd()</tt> inclusive.
199 *
200 * <p>The order of iteration is all code points ranges in sorted
201 * order, followed by all strings sorted order. Ranges are
202 * disjoint and non-contiguous. The value returned from <tt>getString()</tt>
203 * is undefined unless <tt>isString() == TRUE</tt>. Do not mix calls to
204 * <tt>next()</tt> and <tt>nextRange()</tt> without calling
205 * <tt>reset()</tt> between them. The results of doing so are
206 * undefined.
207 *
208 * @return true if there was another element in the set.
209 * @stable ICU 2.4
210 */
211 UBool nextRange();
212
213 /**
214 * Sets this iterator to visit the elements of the given set and
215 * resets it to the start of that set. The iterator is valid only
216 * so long as <tt>set</tt> is valid.
217 * @param set the set to iterate over.
218 * @stable ICU 2.4
219 */
220 void reset(const UnicodeSet& set);
221
222 /**
223 * Resets this iterator to the start of the set.
224 * @stable ICU 2.4
225 */
226 void reset();
227
228 /**
229 * ICU "poor man's RTTI", returns a UClassID for this class.
230 *
231 * @stable ICU 2.4
232 */
233 static UClassID U_EXPORT2 getStaticClassID();
234
235 /**
236 * ICU "poor man's RTTI", returns a UClassID for the actual class.
237 *
238 * @stable ICU 2.4
239 */
240 virtual UClassID getDynamicClassID() const;
241
242 // ======================= PRIVATES ===========================
243
244 protected:
245
246 // endElement and nextElements are really UChar32's, but we keep
247 // them as signed int32_t's so we can do comparisons with
248 // endElement set to -1. Leave them as int32_t's.
249 /** The set
250 * @stable ICU 2.4
251 */
252 const UnicodeSet* set;
253 /** End range
254 * @stable ICU 2.4
255 */
256 int32_t endRange;
257 /** Range
258 * @stable ICU 2.4
259 */
260 int32_t range;
261 /** End element
262 * @stable ICU 2.4
263 */
264 int32_t endElement;
265 /** Next element
266 * @stable ICU 2.4
267 */
268 int32_t nextElement;
269 //UBool abbreviated;
270 /** Next string
271 * @stable ICU 2.4
272 */
273 int32_t nextString;
274 /** String count
275 * @stable ICU 2.4
276 */
277 int32_t stringCount;
278
279 /**
280 * Points to the string to use when the caller asks for a
281 * string and the current iteration item is a code point, not a string.
282 * @internal
283 */
284 UnicodeString *cpString;
285
286 /** Copy constructor. Disallowed.
287 * @stable ICU 2.4
288 */
289 UnicodeSetIterator(const UnicodeSetIterator&); // disallow
290
291 /** Assignment operator. Disallowed.
292 * @stable ICU 2.4
293 */
294 UnicodeSetIterator& operator=(const UnicodeSetIterator&); // disallow
295
296 /** Load range
297 * @stable ICU 2.4
298 */
299 virtual void loadRange(int32_t range);
300
301 };
302
303 inline UBool UnicodeSetIterator::isString() const {
304 return codepoint == (UChar32)IS_STRING;
305 }
306
307 inline UChar32 UnicodeSetIterator::getCodepoint() const {
308 return codepoint;
309 }
310
311 inline UChar32 UnicodeSetIterator::getCodepointEnd() const {
312 return codepointEnd;
313 }
314
315
316 U_NAMESPACE_END
317
318 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial