← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/common/unicode/uniset.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/common/unicode/uniset.h
1
 
/*
2
 
***************************************************************************
3
 
* Copyright (C) 1999-2010, International Business Machines Corporation
4
 
* and others. All Rights Reserved.
5
 
***************************************************************************
6
 
*   Date        Name        Description
7
 
*   10/20/99    alan        Creation.
8
 
***************************************************************************
9
 
*/
10
 
 
11
 
#ifndef UNICODESET_H
12
 
#define UNICODESET_H
13
 
 
14
 
#include "unicode/unifilt.h"
15
 
#include "unicode/unistr.h"
16
 
#include "unicode/uset.h"
17
 
 
18
 
/**
19
 
 * \file
20
 
 * \brief C++ API: Unicode Set
21
 
 */
22
 
 
23
 
U_NAMESPACE_BEGIN
24
 
 
25
 
class BMPSet;
26
 
class ParsePosition;
27
 
class SymbolTable;
28
 
class UnicodeSetStringSpan;
29
 
class UVector;
30
 
class RuleCharacterIterator;
31
 
 
32
 
/**
33
 
 * A mutable set of Unicode characters and multicharacter strings.  Objects of this class
34
 
 * represent <em>character classes</em> used in regular expressions.
35
 
 * A character specifies a subset of Unicode code points.  Legal
36
 
 * code points are U+0000 to U+10FFFF, inclusive.
37
 
 *
38
 
 * <p>The UnicodeSet class is not designed to be subclassed.
39
 
 *
40
 
 * <p><code>UnicodeSet</code> supports two APIs. The first is the
41
 
 * <em>operand</em> API that allows the caller to modify the value of
42
 
 * a <code>UnicodeSet</code> object. It conforms to Java 2's
43
 
 * <code>java.util.Set</code> interface, although
44
 
 * <code>UnicodeSet</code> does not actually implement that
45
 
 * interface. All methods of <code>Set</code> are supported, with the
46
 
 * modification that they take a character range or single character
47
 
 * instead of an <code>Object</code>, and they take a
48
 
 * <code>UnicodeSet</code> instead of a <code>Collection</code>.  The
49
 
 * operand API may be thought of in terms of boolean logic: a boolean
50
 
 * OR is implemented by <code>add</code>, a boolean AND is implemented
51
 
 * by <code>retain</code>, a boolean XOR is implemented by
52
 
 * <code>complement</code> taking an argument, and a boolean NOT is
53
 
 * implemented by <code>complement</code> with no argument.  In terms
54
 
 * of traditional set theory function names, <code>add</code> is a
55
 
 * union, <code>retain</code> is an intersection, <code>remove</code>
56
 
 * is an asymmetric difference, and <code>complement</code> with no
57
 
 * argument is a set complement with respect to the superset range
58
 
 * <code>MIN_VALUE-MAX_VALUE</code>
59
 
 *
60
 
 * <p>The second API is the
61
 
 * <code>applyPattern()</code>/<code>toPattern()</code> API from the
62
 
 * <code>java.text.Format</code>-derived classes.  Unlike the
63
 
 * methods that add characters, add categories, and control the logic
64
 
 * of the set, the method <code>applyPattern()</code> sets all
65
 
 * attributes of a <code>UnicodeSet</code> at once, based on a
66
 
 * string pattern.
67
 
 *
68
 
 * <p><b>Pattern syntax</b></p>
69
 
 *
70
 
 * Patterns are accepted by the constructors and the
71
 
 * <code>applyPattern()</code> methods and returned by the
72
 
 * <code>toPattern()</code> method.  These patterns follow a syntax
73
 
 * similar to that employed by version 8 regular expression character
74
 
 * classes.  Here are some simple examples:
75
 
 *
76
 
 * \htmlonly<blockquote>\endhtmlonly
77
 
 *   <table>
78
 
 *     <tr align="top">
79
 
 *       <td nowrap valign="top" align="left"><code>[]</code></td>
80
 
 *       <td valign="top">No characters</td>
81
 
 *     </tr><tr align="top">
82
 
 *       <td nowrap valign="top" align="left"><code>[a]</code></td>
83
 
 *       <td valign="top">The character 'a'</td>
84
 
 *     </tr><tr align="top">
85
 
 *       <td nowrap valign="top" align="left"><code>[ae]</code></td>
86
 
 *       <td valign="top">The characters 'a' and 'e'</td>
87
 
 *     </tr>
88
 
 *     <tr>
89
 
 *       <td nowrap valign="top" align="left"><code>[a-e]</code></td>
90
 
 *       <td valign="top">The characters 'a' through 'e' inclusive, in Unicode code
91
 
 *       point order</td>
92
 
 *     </tr>
93
 
 *     <tr>
94
 
 *       <td nowrap valign="top" align="left"><code>[\\u4E01]</code></td>
95
 
 *       <td valign="top">The character U+4E01</td>
96
 
 *     </tr>
97
 
 *     <tr>
98
 
 *       <td nowrap valign="top" align="left"><code>[a{ab}{ac}]</code></td>
99
 
 *       <td valign="top">The character 'a' and the multicharacter strings &quot;ab&quot; and
100
 
 *       &quot;ac&quot;</td>
101
 
 *     </tr>
102
 
 *     <tr>
103
 
 *       <td nowrap valign="top" align="left"><code>[\\p{Lu}]</code></td>
104
 
 *       <td valign="top">All characters in the general category Uppercase Letter</td>
105
 
 *     </tr>
106
 
 *   </table>
107
 
 * \htmlonly</blockquote>\endhtmlonly
108
 
 *
109
 
 * Any character may be preceded by a backslash in order to remove any special
110
 
 * meaning.  White space characters, as defined by UCharacter.isWhitespace(), are
111
 
 * ignored, unless they are escaped.
112
 
 *
113
 
 * <p>Property patterns specify a set of characters having a certain
114
 
 * property as defined by the Unicode standard.  Both the POSIX-like
115
 
 * "[:Lu:]" and the Perl-like syntax "\\p{Lu}" are recognized.  For a
116
 
 * complete list of supported property patterns, see the User's Guide
117
 
 * for UnicodeSet at
118
 
 * <a href="http://icu-project.org/userguide/unicodeSet.html">
119
 
 * http://icu-project.org/userguide/unicodeSet.html</a>.
120
 
 * Actual determination of property data is defined by the underlying
121
 
 * Unicode database as implemented by UCharacter.
122
 
 *
123
 
 * <p>Patterns specify individual characters, ranges of characters, and
124
 
 * Unicode property sets.  When elements are concatenated, they
125
 
 * specify their union.  To complement a set, place a '^' immediately
126
 
 * after the opening '['.  Property patterns are inverted by modifying
127
 
 * their delimiters; "[:^foo]" and "\\P{foo}".  In any other location,
128
 
 * '^' has no special meaning.
129
 
 *
130
 
 * <p>Ranges are indicated by placing two a '-' between two
131
 
 * characters, as in "a-z".  This specifies the range of all
132
 
 * characters from the left to the right, in Unicode order.  If the
133
 
 * left character is greater than or equal to the
134
 
 * right character it is a syntax error.  If a '-' occurs as the first
135
 
 * character after the opening '[' or '[^', or if it occurs as the
136
 
 * last character before the closing ']', then it is taken as a
137
 
 * literal.  Thus "[a\-b]", "[-ab]", and "[ab-]" all indicate the same
138
 
 * set of three characters, 'a', 'b', and '-'.
139
 
 *
140
 
 * <p>Sets may be intersected using the '&' operator or the asymmetric
141
 
 * set difference may be taken using the '-' operator, for example,
142
 
 * "[[:L:]&[\\u0000-\\u0FFF]]" indicates the set of all Unicode letters
143
 
 * with values less than 4096.  Operators ('&' and '|') have equal
144
 
 * precedence and bind left-to-right.  Thus
145
 
 * "[[:L:]-[a-z]-[\\u0100-\\u01FF]]" is equivalent to
146
 
 * "[[[:L:]-[a-z]]-[\\u0100-\\u01FF]]".  This only really matters for
147
 
 * difference; intersection is commutative.
148
 
 *
149
 
 * <table>
150
 
 * <tr valign=top><td nowrap><code>[a]</code><td>The set containing 'a'
151
 
 * <tr valign=top><td nowrap><code>[a-z]</code><td>The set containing 'a'
152
 
 * through 'z' and all letters in between, in Unicode order
153
 
 * <tr valign=top><td nowrap><code>[^a-z]</code><td>The set containing
154
 
 * all characters but 'a' through 'z',
155
 
 * that is, U+0000 through 'a'-1 and 'z'+1 through U+10FFFF
156
 
 * <tr valign=top><td nowrap><code>[[<em>pat1</em>][<em>pat2</em>]]</code>
157
 
 * <td>The union of sets specified by <em>pat1</em> and <em>pat2</em>
158
 
 * <tr valign=top><td nowrap><code>[[<em>pat1</em>]&[<em>pat2</em>]]</code>
159
 
 * <td>The intersection of sets specified by <em>pat1</em> and <em>pat2</em>
160
 
 * <tr valign=top><td nowrap><code>[[<em>pat1</em>]-[<em>pat2</em>]]</code>
161
 
 * <td>The asymmetric difference of sets specified by <em>pat1</em> and
162
 
 * <em>pat2</em>
163
 
 * <tr valign=top><td nowrap><code>[:Lu:] or \\p{Lu}</code>
164
 
 * <td>The set of characters having the specified
165
 
 * Unicode property; in
166
 
 * this case, Unicode uppercase letters
167
 
 * <tr valign=top><td nowrap><code>[:^Lu:] or \\P{Lu}</code>
168
 
 * <td>The set of characters <em>not</em> having the given
169
 
 * Unicode property
170
 
 * </table>
171
 
 *
172
 
 * <p><b>Warning</b>: you cannot add an empty string ("") to a UnicodeSet.</p>
173
 
 *
174
 
 * <p><b>Formal syntax</b></p>
175
 
 *
176
 
 * \htmlonly<blockquote>\endhtmlonly
177
 
 *   <table>
178
 
 *     <tr align="top">
179
 
 *       <td nowrap valign="top" align="right"><code>pattern :=&nbsp; </code></td>
180
 
 *       <td valign="top"><code>('[' '^'? item* ']') |
181
 
 *       property</code></td>
182
 
 *     </tr>
183
 
 *     <tr align="top">
184
 
 *       <td nowrap valign="top" align="right"><code>item :=&nbsp; </code></td>
185
 
 *       <td valign="top"><code>char | (char '-' char) | pattern-expr<br>
186
 
 *       </code></td>
187
 
 *     </tr>
188
 
 *     <tr align="top">
189
 
 *       <td nowrap valign="top" align="right"><code>pattern-expr :=&nbsp; </code></td>
190
 
 *       <td valign="top"><code>pattern | pattern-expr pattern |
191
 
 *       pattern-expr op pattern<br>
192
 
 *       </code></td>
193
 
 *     </tr>
194
 
 *     <tr align="top">
195
 
 *       <td nowrap valign="top" align="right"><code>op :=&nbsp; </code></td>
196
 
 *       <td valign="top"><code>'&amp;' | '-'<br>
197
 
 *       </code></td>
198
 
 *     </tr>
199
 
 *     <tr align="top">
200
 
 *       <td nowrap valign="top" align="right"><code>special :=&nbsp; </code></td>
201
 
 *       <td valign="top"><code>'[' | ']' | '-'<br>
202
 
 *       </code></td>
203
 
 *     </tr>
204
 
 *     <tr align="top">
205
 
 *       <td nowrap valign="top" align="right"><code>char :=&nbsp; </code></td>
206
 
 *       <td valign="top"><em>any character that is not</em><code> special<br>
207
 
 *       | ('\' </code><em>any character</em><code>)<br>
208
 
 *       | ('\\u' hex hex hex hex)<br>
209
 
 *       </code></td>
210
 
 *     </tr>
211
 
 *     <tr align="top">
212
 
 *       <td nowrap valign="top" align="right"><code>hex :=&nbsp; </code></td>
213
 
 *       <td valign="top"><em>any character for which
214
 
 *       </em><code>Character.digit(c, 16)</code><em>
215
 
 *       returns a non-negative result</em></td>
216
 
 *     </tr>
217
 
 *     <tr>
218
 
 *       <td nowrap valign="top" align="right"><code>property :=&nbsp; </code></td>
219
 
 *       <td valign="top"><em>a Unicode property set pattern</em></td>
220
 
 *     </tr>
221
 
 *   </table>
222
 
 *   <br>
223
 
 *   <table border="1">
224
 
 *     <tr>
225
 
 *       <td>Legend: <table>
226
 
 *         <tr>
227
 
 *           <td nowrap valign="top"><code>a := b</code></td>
228
 
 *           <td width="20" valign="top">&nbsp; </td>
229
 
 *           <td valign="top"><code>a</code> may be replaced by <code>b</code> </td>
230
 
 *         </tr>
231
 
 *         <tr>
232
 
 *           <td nowrap valign="top"><code>a?</code></td>
233
 
 *           <td valign="top"></td>
234
 
 *           <td valign="top">zero or one instance of <code>a</code><br>
235
 
 *           </td>
236
 
 *         </tr>
237
 
 *         <tr>
238
 
 *           <td nowrap valign="top"><code>a*</code></td>
239
 
 *           <td valign="top"></td>
240
 
 *           <td valign="top">one or more instances of <code>a</code><br>
241
 
 *           </td>
242
 
 *         </tr>
243
 
 *         <tr>
244
 
 *           <td nowrap valign="top"><code>a | b</code></td>
245
 
 *           <td valign="top"></td>
246
 
 *           <td valign="top">either <code>a</code> or <code>b</code><br>
247
 
 *           </td>
248
 
 *         </tr>
249
 
 *         <tr>
250
 
 *           <td nowrap valign="top"><code>'a'</code></td>
251
 
 *           <td valign="top"></td>
252
 
 *           <td valign="top">the literal string between the quotes </td>
253
 
 *         </tr>
254
 
 *       </table>
255
 
 *       </td>
256
 
 *     </tr>
257
 
 *   </table>
258
 
 * \htmlonly</blockquote>\endhtmlonly
259
 
 * 
260
 
 * <p>Note:
261
 
 *  - Most UnicodeSet methods do not take a UErrorCode parameter because
262
 
 *   there are usually very few opportunities for failure other than a shortage
263
 
 *   of memory, error codes in low-level C++ string methods would be inconvenient,
264
 
 *   and the error code as the last parameter (ICU convention) would prevent
265
 
 *   the use of default parameter values.
266
 
 *   Instead, such methods set the UnicodeSet into a "bogus" state
267
 
 *   (see isBogus()) if an error occurs.
268
 
 *
269
 
 * @author Alan Liu
270
 
 * @stable ICU 2.0
271
 
 */
272
 
class U_COMMON_API UnicodeSet : public UnicodeFilter {
273
 
 
274
 
    int32_t len; // length of list used; 0 <= len <= capacity
275
 
    int32_t capacity; // capacity of list
276
 
    UChar32* list; // MUST be terminated with HIGH
277
 
    BMPSet *bmpSet; // The set is frozen iff either bmpSet or stringSpan is not NULL.
278
 
    UChar32* buffer; // internal buffer, may be NULL
279
 
    int32_t bufferCapacity; // capacity of buffer
280
 
    int32_t patLen;
281
 
 
282
 
    /**
283
 
     * The pattern representation of this set.  This may not be the
284
 
     * most economical pattern.  It is the pattern supplied to
285
 
     * applyPattern(), with variables substituted and whitespace
286
 
     * removed.  For sets constructed without applyPattern(), or
287
 
     * modified using the non-pattern API, this string will be empty,
288
 
     * indicating that toPattern() must generate a pattern
289
 
     * representation from the inversion list.
290
 
     */
291
 
    UChar *pat;
292
 
    UVector* strings; // maintained in sorted order
293
 
    UnicodeSetStringSpan *stringSpan;
294
 
 
295
 
private:
296
 
    enum { // constants
297
 
        kIsBogus = 1       // This set is bogus (i.e. not valid)
298
 
    };
299
 
    uint8_t fFlags;         // Bit flag (see constants above)
300
 
public:
301
 
    /**
302
 
     * Determine if this object contains a valid set.
303
 
     * A bogus set has no value. It is different from an empty set.
304
 
     * It can be used to indicate that no set value is available.
305
 
     *
306
 
     * @return TRUE if the set is valid, FALSE otherwise
307
 
     * @see setToBogus()
308
 
     * @stable ICU 4.0
309
 
     */
310
 
    inline UBool isBogus(void) const;
311
 
    
312
 
    /**
313
 
     * Make this UnicodeSet object invalid.
314
 
     * The string will test TRUE with isBogus().
315
 
     *
316
 
     * A bogus set has no value. It is different from an empty set.
317
 
     * It can be used to indicate that no set value is available.
318
 
     *
319
 
     * This utility function is used throughout the UnicodeSet
320
 
     * implementation to indicate that a UnicodeSet operation failed,
321
 
     * and may be used in other functions,
322
 
     * especially but not exclusively when such functions do not
323
 
     * take a UErrorCode for simplicity.
324
 
     *
325
 
     * @see isBogus()
326
 
     * @stable ICU 4.0
327
 
     */
328
 
    void setToBogus();
329
 
 
330
 
public:
331
 
 
332
 
    enum {
333
 
        /**
334
 
         * Minimum value that can be stored in a UnicodeSet.
335
 
         * @stable ICU 2.4
336
 
         */
337
 
        MIN_VALUE = 0,
338
 
 
339
 
        /**
340
 
         * Maximum value that can be stored in a UnicodeSet.
341
 
         * @stable ICU 2.4
342
 
         */
343
 
        MAX_VALUE = 0x10ffff
344
 
    };
345
 
 
346
 
    //----------------------------------------------------------------
347
 
    // Constructors &c
348
 
    //----------------------------------------------------------------
349
 
 
350
 
public:
351
 
 
352
 
    /**
353
 
     * Constructs an empty set.
354
 
     * @stable ICU 2.0
355
 
     */
356
 
    UnicodeSet();
357
 
 
358
 
    /**
359
 
     * Constructs a set containing the given range. If <code>end >
360
 
     * start</code> then an empty set is created.
361
 
     *
362
 
     * @param start first character, inclusive, of range
363
 
     * @param end last character, inclusive, of range
364
 
     * @stable ICU 2.4
365
 
     */
366
 
    UnicodeSet(UChar32 start, UChar32 end);
367
 
 
368
 
    /**
369
 
     * Constructs a set from the given pattern.  See the class
370
 
     * description for the syntax of the pattern language.
371
 
     * @param pattern a string specifying what characters are in the set
372
 
     * @param status returns <code>U_ILLEGAL_ARGUMENT_ERROR</code> if the pattern
373
 
     * contains a syntax error.
374
 
     * @stable ICU 2.0
375
 
     */
376
 
    UnicodeSet(const UnicodeString& pattern,
377
 
               UErrorCode& status);
378
 
 
379
 
    /**
380
 
     * Constructs a set from the given pattern.  See the class
381
 
     * description for the syntax of the pattern language.
382
 
     * @param pattern a string specifying what characters are in the set
383
 
     * @param options bitmask for options to apply to the pattern.
384
 
     * Valid options are USET_IGNORE_SPACE and USET_CASE_INSENSITIVE.
385
 
     * @param symbols a symbol table mapping variable names to values
386
 
     * and stand-in characters to UnicodeSets; may be NULL
387
 
     * @param status returns <code>U_ILLEGAL_ARGUMENT_ERROR</code> if the pattern
388
 
     * contains a syntax error.
389
 
     * @internal
390
 
     */
391
 
    UnicodeSet(const UnicodeString& pattern,
392
 
               uint32_t options,
393
 
               const SymbolTable* symbols,
394
 
               UErrorCode& status);
395
 
 
396
 
    /**
397
 
     * Constructs a set from the given pattern.  See the class description
398
 
     * for the syntax of the pattern language.
399
 
     * @param pattern a string specifying what characters are in the set
400
 
     * @param pos on input, the position in pattern at which to start parsing.
401
 
     * On output, the position after the last character parsed.
402
 
     * @param options bitmask for options to apply to the pattern.
403
 
     * Valid options are USET_IGNORE_SPACE and USET_CASE_INSENSITIVE.
404
 
     * @param symbols a symbol table mapping variable names to values
405
 
     * and stand-in characters to UnicodeSets; may be NULL
406
 
     * @param status input-output error code
407
 
     * @stable ICU 2.8
408
 
     */
409
 
    UnicodeSet(const UnicodeString& pattern, ParsePosition& pos,
410
 
               uint32_t options,
411
 
               const SymbolTable* symbols,
412
 
               UErrorCode& status);
413
 
 
414
 
    /**
415
 
     * Constructs a set that is identical to the given UnicodeSet.
416
 
     * @stable ICU 2.0
417
 
     */
418
 
    UnicodeSet(const UnicodeSet& o);
419
 
 
420
 
    /**
421
 
     * Destructs the set.
422
 
     * @stable ICU 2.0
423
 
     */
424
 
    virtual ~UnicodeSet();
425
 
 
426
 
    /**
427
 
     * Assigns this object to be a copy of another.
428
 
     * A frozen set will not be modified.
429
 
     * @stable ICU 2.0
430
 
     */
431
 
    UnicodeSet& operator=(const UnicodeSet& o);
432
 
 
433
 
    /**
434
 
     * Compares the specified object with this set for equality.  Returns
435
 
     * <tt>true</tt> if the two sets
436
 
     * have the same size, and every member of the specified set is
437
 
     * contained in this set (or equivalently, every member of this set is
438
 
     * contained in the specified set).
439
 
     *
440
 
     * @param o set to be compared for equality with this set.
441
 
     * @return <tt>true</tt> if the specified set is equal to this set.
442
 
     * @stable ICU 2.0
443
 
     */
444
 
    virtual UBool operator==(const UnicodeSet& o) const;
445
 
 
446
 
    /**
447
 
     * Compares the specified object with this set for equality.  Returns
448
 
     * <tt>true</tt> if the specified set is not equal to this set.
449
 
     * @stable ICU 2.0
450
 
     */
451
 
    UBool operator!=(const UnicodeSet& o) const;
452
 
 
453
 
    /**
454
 
     * Returns a copy of this object.  All UnicodeFunctor objects have
455
 
     * to support cloning in order to allow classes using
456
 
     * UnicodeFunctors, such as Transliterator, to implement cloning.
457
 
     * If this set is frozen, then the clone will be frozen as well.
458
 
     * Use cloneAsThawed() for a mutable clone of a frozen set.
459
 
     * @see cloneAsThawed
460
 
     * @stable ICU 2.0
461
 
     */
462
 
    virtual UnicodeFunctor* clone() const;
463
 
 
464
 
    /**
465
 
     * Returns the hash code value for this set.
466
 
     *
467
 
     * @return the hash code value for this set.
468
 
     * @see Object#hashCode()
469
 
     * @stable ICU 2.0
470
 
     */
471
 
    virtual int32_t hashCode(void) const;
472
 
 
473
 
    /**
474
 
     * Get a UnicodeSet pointer from a USet
475
 
     *
476
 
     * @param uset a USet (the ICU plain C type for UnicodeSet)
477
 
     * @return the corresponding UnicodeSet pointer.
478
 
     *
479
 
     * @stable ICU 4.2
480
 
     */
481
 
    inline static UnicodeSet *fromUSet(USet *uset);
482
 
 
483
 
    /**
484
 
     * Get a UnicodeSet pointer from a const USet
485
 
     *
486
 
     * @param uset a const USet (the ICU plain C type for UnicodeSet)
487
 
     * @return the corresponding UnicodeSet pointer.
488
 
     *
489
 
     * @stable ICU 4.2
490
 
     */
491
 
    inline static const UnicodeSet *fromUSet(const USet *uset);
492
 
    
493
 
    /**
494
 
     * Produce a USet * pointer for this UnicodeSet.
495
 
     * USet is the plain C type for UnicodeSet
496
 
     *
497
 
     * @return a USet pointer for this UnicodeSet
498
 
     * @stable ICU 4.2
499
 
     */
500
 
    inline USet *toUSet();
501
 
 
502
 
 
503
 
    /**
504
 
     * Produce a const USet * pointer for this UnicodeSet.
505
 
     * USet is the plain C type for UnicodeSet
506
 
     *
507
 
     * @return a const USet pointer for this UnicodeSet
508
 
     * @stable ICU 4.2
509
 
     */
510
 
    inline const USet * toUSet() const;
511
 
 
512
 
 
513
 
    //----------------------------------------------------------------
514
 
    // Freezable API
515
 
    //----------------------------------------------------------------
516
 
 
517
 
    /**
518
 
     * Determines whether the set has been frozen (made immutable) or not.
519
 
     * See the ICU4J Freezable interface for details.
520
 
     * @return TRUE/FALSE for whether the set has been frozen
521
 
     * @see freeze
522
 
     * @see cloneAsThawed
523
 
     * @stable ICU 3.8
524
 
     */
525
 
    inline UBool isFrozen() const;
526
 
 
527
 
    /**
528
 
     * Freeze the set (make it immutable).
529
 
     * Once frozen, it cannot be unfrozen and is therefore thread-safe
530
 
     * until it is deleted.
531
 
     * See the ICU4J Freezable interface for details.
532
 
     * Freezing the set may also make some operations faster, for example
533
 
     * contains() and span().
534
 
     * A frozen set will not be modified. (It remains frozen.)
535
 
     * @return this set.
536
 
     * @see isFrozen
537
 
     * @see cloneAsThawed
538
 
     * @stable ICU 3.8
539
 
     */
540
 
    UnicodeFunctor *freeze();
541
 
 
542
 
    /**
543
 
     * Clone the set and make the clone mutable.
544
 
     * See the ICU4J Freezable interface for details.
545
 
     * @return the mutable clone
546
 
     * @see freeze
547
 
     * @see isFrozen
548
 
     * @stable ICU 3.8
549
 
     */
550
 
    UnicodeFunctor *cloneAsThawed() const;
551
 
 
552
 
    //----------------------------------------------------------------
553
 
    // Public API
554
 
    //----------------------------------------------------------------
555
 
 
556
 
    /**
557
 
     * Make this object represent the range <code>start - end</code>.
558
 
     * If <code>end > start</code> then this object is set to an
559
 
     * an empty range.
560
 
     * A frozen set will not be modified.
561
 
     *
562
 
     * @param start first character in the set, inclusive
563
 
     * @param end last character in the set, inclusive
564
 
     * @stable ICU 2.4
565
 
     */
566
 
    UnicodeSet& set(UChar32 start, UChar32 end);
567
 
 
568
 
    /**
569
 
     * Return true if the given position, in the given pattern, appears
570
 
     * to be the start of a UnicodeSet pattern.
571
 
     * @stable ICU 2.4
572
 
     */
573
 
    static UBool resemblesPattern(const UnicodeString& pattern,
574
 
                                  int32_t pos);
575
 
 
576
 
    /**
577
 
     * Modifies this set to represent the set specified by the given
578
 
     * pattern, optionally ignoring white space.  See the class
579
 
     * description for the syntax of the pattern language.
580
 
     * A frozen set will not be modified.
581
 
     * @param pattern a string specifying what characters are in the set
582
 
     * @param status returns <code>U_ILLEGAL_ARGUMENT_ERROR</code> if the pattern
583
 
     * contains a syntax error.
584
 
     * <em> Empties the set passed before applying the pattern.</em>
585
 
     * @return a reference to this
586
 
     * @stable ICU 2.0
587
 
     */
588
 
    UnicodeSet& applyPattern(const UnicodeString& pattern,
589
 
                             UErrorCode& status);
590
 
 
591
 
    /**
592
 
     * Modifies this set to represent the set specified by the given
593
 
     * pattern, optionally ignoring white space.  See the class
594
 
     * description for the syntax of the pattern language.
595
 
     * A frozen set will not be modified.
596
 
     * @param pattern a string specifying what characters are in the set
597
 
     * @param options bitmask for options to apply to the pattern.
598
 
     * Valid options are USET_IGNORE_SPACE and USET_CASE_INSENSITIVE.
599
 
     * @param symbols a symbol table mapping variable names to
600
 
     * values and stand-ins to UnicodeSets; may be NULL
601
 
     * @param status returns <code>U_ILLEGAL_ARGUMENT_ERROR</code> if the pattern
602
 
     * contains a syntax error.
603
 
     *<em> Empties the set passed before applying the pattern.</em>
604
 
     * @return a reference to this
605
 
     * @internal
606
 
     */
607
 
    UnicodeSet& applyPattern(const UnicodeString& pattern,
608
 
                             uint32_t options,
609
 
                             const SymbolTable* symbols,
610
 
                             UErrorCode& status);
611
 
 
612
 
    /**
613
 
     * Parses the given pattern, starting at the given position.  The
614
 
     * character at pattern.charAt(pos.getIndex()) must be '[', or the
615
 
     * parse fails.  Parsing continues until the corresponding closing
616
 
     * ']'.  If a syntax error is encountered between the opening and
617
 
     * closing brace, the parse fails.  Upon return from a successful
618
 
     * parse, the ParsePosition is updated to point to the character
619
 
     * following the closing ']', and a StringBuffer containing a
620
 
     * pairs list for the parsed pattern is returned.  This method calls
621
 
     * itself recursively to parse embedded subpatterns.
622
 
     *<em> Empties the set passed before applying the pattern.</em>
623
 
     * A frozen set will not be modified.
624
 
     *
625
 
     * @param pattern the string containing the pattern to be parsed.
626
 
     * The portion of the string from pos.getIndex(), which must be a
627
 
     * '[', to the corresponding closing ']', is parsed.
628
 
     * @param pos upon entry, the position at which to being parsing.
629
 
     * The character at pattern.charAt(pos.getIndex()) must be a '['.
630
 
     * Upon return from a successful parse, pos.getIndex() is either
631
 
     * the character after the closing ']' of the parsed pattern, or
632
 
     * pattern.length() if the closing ']' is the last character of
633
 
     * the pattern string.
634
 
     * @param options bitmask for options to apply to the pattern.
635
 
     * Valid options are USET_IGNORE_SPACE and USET_CASE_INSENSITIVE.
636
 
     * @param symbols a symbol table mapping variable names to
637
 
     * values and stand-ins to UnicodeSets; may be NULL
638
 
     * @param status returns <code>U_ILLEGAL_ARGUMENT_ERROR</code> if the pattern
639
 
     * contains a syntax error.
640
 
     * @return a reference to this
641
 
     * @stable ICU 2.8
642
 
     */
643
 
    UnicodeSet& applyPattern(const UnicodeString& pattern,
644
 
                             ParsePosition& pos,
645
 
                             uint32_t options,
646
 
                             const SymbolTable* symbols,
647
 
                             UErrorCode& status);
648
 
 
649
 
    /**
650
 
     * Returns a string representation of this set.  If the result of
651
 
     * calling this function is passed to a UnicodeSet constructor, it
652
 
     * will produce another set that is equal to this one.
653
 
     * A frozen set will not be modified.
654
 
     * @param result the string to receive the rules.  Previous
655
 
     * contents will be deleted.
656
 
     * @param escapeUnprintable if TRUE then convert unprintable
657
 
     * character to their hex escape representations, \\uxxxx or
658
 
     * \\Uxxxxxxxx.  Unprintable characters are those other than
659
 
     * U+000A, U+0020..U+007E.
660
 
     * @stable ICU 2.0
661
 
     */
662
 
    virtual UnicodeString& toPattern(UnicodeString& result,
663
 
                             UBool escapeUnprintable = FALSE) const;
664
 
 
665
 
    /**
666
 
     * Modifies this set to contain those code points which have the given value
667
 
     * for the given binary or enumerated property, as returned by
668
 
     * u_getIntPropertyValue.  Prior contents of this set are lost.
669
 
     * A frozen set will not be modified.
670
 
     *
671
 
     * @param prop a property in the range UCHAR_BIN_START..UCHAR_BIN_LIMIT-1
672
 
     * or UCHAR_INT_START..UCHAR_INT_LIMIT-1
673
 
     * or UCHAR_MASK_START..UCHAR_MASK_LIMIT-1.
674
 
     *
675
 
     * @param value a value in the range u_getIntPropertyMinValue(prop)..
676
 
     * u_getIntPropertyMaxValue(prop), with one exception.  If prop is
677
 
     * UCHAR_GENERAL_CATEGORY_MASK, then value should not be a UCharCategory, but
678
 
     * rather a mask value produced by U_GET_GC_MASK().  This allows grouped
679
 
     * categories such as [:L:] to be represented.
680
 
     *
681
 
     * @param ec error code input/output parameter
682
 
     *
683
 
     * @return a reference to this set
684
 
     *
685
 
     * @stable ICU 2.4
686
 
     */
687
 
    UnicodeSet& applyIntPropertyValue(UProperty prop,
688
 
                                      int32_t value,
689
 
                                      UErrorCode& ec);
690
 
 
691
 
    /**
692
 
     * Modifies this set to contain those code points which have the
693
 
     * given value for the given property.  Prior contents of this
694
 
     * set are lost.
695
 
     * A frozen set will not be modified.
696
 
     *
697
 
     * @param prop a property alias, either short or long.  The name is matched
698
 
     * loosely.  See PropertyAliases.txt for names and a description of loose
699
 
     * matching.  If the value string is empty, then this string is interpreted
700
 
     * as either a General_Category value alias, a Script value alias, a binary
701
 
     * property alias, or a special ID.  Special IDs are matched loosely and
702
 
     * correspond to the following sets:
703
 
     *
704
 
     * "ANY" = [\\u0000-\\U0010FFFF],
705
 
     * "ASCII" = [\\u0000-\\u007F],
706
 
     * "Assigned" = [:^Cn:].
707
 
     *
708
 
     * @param value a value alias, either short or long.  The name is matched
709
 
     * loosely.  See PropertyValueAliases.txt for names and a description of
710
 
     * loose matching.  In addition to aliases listed, numeric values and
711
 
     * canonical combining classes may be expressed numerically, e.g., ("nv",
712
 
     * "0.5") or ("ccc", "220").  The value string may also be empty.
713
 
     *
714
 
     * @param ec error code input/output parameter
715
 
     *
716
 
     * @return a reference to this set
717
 
     *
718
 
     * @stable ICU 2.4
719
 
     */
720
 
    UnicodeSet& applyPropertyAlias(const UnicodeString& prop,
721
 
                                   const UnicodeString& value,
722
 
                                   UErrorCode& ec);
723
 
 
724
 
    /**
725
 
     * Returns the number of elements in this set (its cardinality).
726
 
     * Note than the elements of a set may include both individual
727
 
     * codepoints and strings.
728
 
     *
729
 
     * @return the number of elements in this set (its cardinality).
730
 
     * @stable ICU 2.0
731
 
     */
732
 
    virtual int32_t size(void) const;
733
 
 
734
 
    /**
735
 
     * Returns <tt>true</tt> if this set contains no elements.
736
 
     *
737
 
     * @return <tt>true</tt> if this set contains no elements.
738
 
     * @stable ICU 2.0
739
 
     */
740
 
    virtual UBool isEmpty(void) const;
741
 
 
742
 
    /**
743
 
     * Returns true if this set contains the given character.
744
 
     * This function works faster with a frozen set.
745
 
     * @param c character to be checked for containment
746
 
     * @return true if the test condition is met
747
 
     * @stable ICU 2.0
748
 
     */
749
 
    virtual UBool contains(UChar32 c) const;
750
 
 
751
 
    /**
752
 
     * Returns true if this set contains every character
753
 
     * of the given range.
754
 
     * @param start first character, inclusive, of the range
755
 
     * @param end last character, inclusive, of the range
756
 
     * @return true if the test condition is met
757
 
     * @stable ICU 2.0
758
 
     */
759
 
    virtual UBool contains(UChar32 start, UChar32 end) const;
760
 
 
761
 
    /**
762
 
     * Returns <tt>true</tt> if this set contains the given
763
 
     * multicharacter string.
764
 
     * @param s string to be checked for containment
765
 
     * @return <tt>true</tt> if this set contains the specified string
766
 
     * @stable ICU 2.4
767
 
     */
768
 
    UBool contains(const UnicodeString& s) const;
769
 
 
770
 
    /**
771
 
     * Returns true if this set contains all the characters and strings
772
 
     * of the given set.
773
 
     * @param c set to be checked for containment
774
 
     * @return true if the test condition is met
775
 
     * @stable ICU 2.4
776
 
     */
777
 
    virtual UBool containsAll(const UnicodeSet& c) const;
778
 
 
779
 
    /**
780
 
     * Returns true if this set contains all the characters
781
 
     * of the given string.
782
 
     * @param s string containing characters to be checked for containment
783
 
     * @return true if the test condition is met
784
 
     * @stable ICU 2.4
785
 
     */
786
 
    UBool containsAll(const UnicodeString& s) const;
787
 
 
788
 
    /**
789
 
     * Returns true if this set contains none of the characters
790
 
     * of the given range.
791
 
     * @param start first character, inclusive, of the range
792
 
     * @param end last character, inclusive, of the range
793
 
     * @return true if the test condition is met
794
 
     * @stable ICU 2.4
795
 
     */
796
 
    UBool containsNone(UChar32 start, UChar32 end) const;
797
 
 
798
 
    /**
799
 
     * Returns true if this set contains none of the characters and strings
800
 
     * of the given set.
801
 
     * @param c set to be checked for containment
802
 
     * @return true if the test condition is met
803
 
     * @stable ICU 2.4
804
 
     */
805
 
    UBool containsNone(const UnicodeSet& c) const;
806
 
 
807
 
    /**
808
 
     * Returns true if this set contains none of the characters
809
 
     * of the given string.
810
 
     * @param s string containing characters to be checked for containment
811
 
     * @return true if the test condition is met
812
 
     * @stable ICU 2.4
813
 
     */
814
 
    UBool containsNone(const UnicodeString& s) const;
815
 
 
816
 
    /**
817
 
     * Returns true if this set contains one or more of the characters
818
 
     * in the given range.
819
 
     * @param start first character, inclusive, of the range
820
 
     * @param end last character, inclusive, of the range
821
 
     * @return true if the condition is met
822
 
     * @stable ICU 2.4
823
 
     */
824
 
    inline UBool containsSome(UChar32 start, UChar32 end) const;
825
 
 
826
 
    /**
827
 
     * Returns true if this set contains one or more of the characters
828
 
     * and strings of the given set.
829
 
     * @param s The set to be checked for containment
830
 
     * @return true if the condition is met
831
 
     * @stable ICU 2.4
832
 
     */
833
 
    inline UBool containsSome(const UnicodeSet& s) const;
834
 
 
835
 
    /**
836
 
     * Returns true if this set contains one or more of the characters
837
 
     * of the given string.
838
 
     * @param s string containing characters to be checked for containment
839
 
     * @return true if the condition is met
840
 
     * @stable ICU 2.4
841
 
     */
842
 
    inline UBool containsSome(const UnicodeString& s) const;
843
 
 
844
 
    /**
845
 
     * Returns the length of the initial substring of the input string which
846
 
     * consists only of characters and strings that are contained in this set
847
 
     * (USET_SPAN_CONTAINED, USET_SPAN_SIMPLE),
848
 
     * or only of characters and strings that are not contained
849
 
     * in this set (USET_SPAN_NOT_CONTAINED).
850
 
     * See USetSpanCondition for details.
851
 
     * Similar to the strspn() C library function.
852
 
     * Unpaired surrogates are treated according to contains() of their surrogate code points.
853
 
     * This function works faster with a frozen set and with a non-negative string length argument.
854
 
     * @param s start of the string
855
 
     * @param length of the string; can be -1 for NUL-terminated
856
 
     * @param spanCondition specifies the containment condition
857
 
     * @return the length of the initial substring according to the spanCondition;
858
 
     *         0 if the start of the string does not fit the spanCondition
859
 
     * @stable ICU 3.8
860
 
     * @see USetSpanCondition
861
 
     */
862
 
    int32_t span(const UChar *s, int32_t length, USetSpanCondition spanCondition) const;
863
 
 
864
 
    /**
865
 
     * Returns the end of the substring of the input string according to the USetSpanCondition.
866
 
     * Same as <code>start+span(s.getBuffer()+start, s.length()-start, spanCondition)</code>
867
 
     * after pinning start to 0<=start<=s.length().
868
 
     * @param s the string
869
 
     * @param start the start index in the string for the span operation
870
 
     * @param spanCondition specifies the containment condition
871
 
     * @return the exclusive end of the substring according to the spanCondition;
872
 
     *         the substring s.tempSubStringBetween(start, end) fulfills the spanCondition
873
 
     * @stable ICU 4.4
874
 
     * @see USetSpanCondition
875
 
     */
876
 
    inline int32_t span(const UnicodeString &s, int32_t start, USetSpanCondition spanCondition) const;
877
 
 
878
 
    /**
879
 
     * Returns the start of the trailing substring of the input string which
880
 
     * consists only of characters and strings that are contained in this set
881
 
     * (USET_SPAN_CONTAINED, USET_SPAN_SIMPLE),
882
 
     * or only of characters and strings that are not contained
883
 
     * in this set (USET_SPAN_NOT_CONTAINED).
884
 
     * See USetSpanCondition for details.
885
 
     * Unpaired surrogates are treated according to contains() of their surrogate code points.
886
 
     * This function works faster with a frozen set and with a non-negative string length argument.
887
 
     * @param s start of the string
888
 
     * @param length of the string; can be -1 for NUL-terminated
889
 
     * @param spanCondition specifies the containment condition
890
 
     * @return the start of the trailing substring according to the spanCondition;
891
 
     *         the string length if the end of the string does not fit the spanCondition
892
 
     * @stable ICU 3.8
893
 
     * @see USetSpanCondition
894
 
     */
895
 
    int32_t spanBack(const UChar *s, int32_t length, USetSpanCondition spanCondition) const;
896
 
 
897
 
    /**
898
 
     * Returns the start of the substring of the input string according to the USetSpanCondition.
899
 
     * Same as <code>spanBack(s.getBuffer(), limit, spanCondition)</code>
900
 
     * after pinning limit to 0<=end<=s.length().
901
 
     * @param s the string
902
 
     * @param limit the exclusive-end index in the string for the span operation
903
 
     *              (use s.length() or INT32_MAX for spanning back from the end of the string)
904
 
     * @param spanCondition specifies the containment condition
905
 
     * @return the start of the substring according to the spanCondition;
906
 
     *         the substring s.tempSubStringBetween(start, limit) fulfills the spanCondition
907
 
     * @stable ICU 4.4
908
 
     * @see USetSpanCondition
909
 
     */
910
 
    inline int32_t spanBack(const UnicodeString &s, int32_t limit, USetSpanCondition spanCondition) const;
911
 
 
912
 
    /**
913
 
     * Returns the length of the initial substring of the input string which
914
 
     * consists only of characters and strings that are contained in this set
915
 
     * (USET_SPAN_CONTAINED, USET_SPAN_SIMPLE),
916
 
     * or only of characters and strings that are not contained
917
 
     * in this set (USET_SPAN_NOT_CONTAINED).
918
 
     * See USetSpanCondition for details.
919
 
     * Similar to the strspn() C library function.
920
 
     * Malformed byte sequences are treated according to contains(0xfffd).
921
 
     * This function works faster with a frozen set and with a non-negative string length argument.
922
 
     * @param s start of the string (UTF-8)
923
 
     * @param length of the string; can be -1 for NUL-terminated
924
 
     * @param spanCondition specifies the containment condition
925
 
     * @return the length of the initial substring according to the spanCondition;
926
 
     *         0 if the start of the string does not fit the spanCondition
927
 
     * @stable ICU 3.8
928
 
     * @see USetSpanCondition
929
 
     */
930
 
    int32_t spanUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const;
931
 
 
932
 
    /**
933
 
     * Returns the start of the trailing substring of the input string which
934
 
     * consists only of characters and strings that are contained in this set
935
 
     * (USET_SPAN_CONTAINED, USET_SPAN_SIMPLE),
936
 
     * or only of characters and strings that are not contained
937
 
     * in this set (USET_SPAN_NOT_CONTAINED).
938
 
     * See USetSpanCondition for details.
939
 
     * Malformed byte sequences are treated according to contains(0xfffd).
940
 
     * This function works faster with a frozen set and with a non-negative string length argument.
941
 
     * @param s start of the string (UTF-8)
942
 
     * @param length of the string; can be -1 for NUL-terminated
943
 
     * @param spanCondition specifies the containment condition
944
 
     * @return the start of the trailing substring according to the spanCondition;
945
 
     *         the string length if the end of the string does not fit the spanCondition
946
 
     * @stable ICU 3.8
947
 
     * @see USetSpanCondition
948
 
     */
949
 
    int32_t spanBackUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const;
950
 
 
951
 
    /**
952
 
     * Implement UnicodeMatcher::matches()
953
 
     * @stable ICU 2.4
954
 
     */
955
 
    virtual UMatchDegree matches(const Replaceable& text,
956
 
                         int32_t& offset,
957
 
                         int32_t limit,
958
 
                         UBool incremental);
959
 
 
960
 
private:
961
 
    /**
962
 
     * Returns the longest match for s in text at the given position.
963
 
     * If limit > start then match forward from start+1 to limit
964
 
     * matching all characters except s.charAt(0).  If limit < start,
965
 
     * go backward starting from start-1 matching all characters
966
 
     * except s.charAt(s.length()-1).  This method assumes that the
967
 
     * first character, text.charAt(start), matches s, so it does not
968
 
     * check it.
969
 
     * @param text the text to match
970
 
     * @param start the first character to match.  In the forward
971
 
     * direction, text.charAt(start) is matched against s.charAt(0).
972
 
     * In the reverse direction, it is matched against
973
 
     * s.charAt(s.length()-1).
974
 
     * @param limit the limit offset for matching, either last+1 in
975
 
     * the forward direction, or last-1 in the reverse direction,
976
 
     * where last is the index of the last character to match.
977
 
     * @return If part of s matches up to the limit, return |limit -
978
 
     * start|.  If all of s matches before reaching the limit, return
979
 
     * s.length().  If there is a mismatch between s and text, return
980
 
     * 0
981
 
     */
982
 
    static int32_t matchRest(const Replaceable& text,
983
 
                             int32_t start, int32_t limit,
984
 
                             const UnicodeString& s);
985
 
 
986
 
    /**
987
 
     * Returns the smallest value i such that c < list[i].  Caller
988
 
     * must ensure that c is a legal value or this method will enter
989
 
     * an infinite loop.  This method performs a binary search.
990
 
     * @param c a character in the range MIN_VALUE..MAX_VALUE
991
 
     * inclusive
992
 
     * @return the smallest integer i in the range 0..len-1,
993
 
     * inclusive, such that c < list[i]
994
 
     */
995
 
    int32_t findCodePoint(UChar32 c) const;
996
 
 
997
 
public:
998
 
 
999
 
    /**
1000
 
     * Implementation of UnicodeMatcher API.  Union the set of all
1001
 
     * characters that may be matched by this object into the given
1002
 
     * set.
1003
 
     * @param toUnionTo the set into which to union the source characters
1004
 
     * @stable ICU 2.4
1005
 
     */
1006
 
    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const;
1007
 
 
1008
 
    /**
1009
 
     * Returns the index of the given character within this set, where
1010
 
     * the set is ordered by ascending code point.  If the character
1011
 
     * is not in this set, return -1.  The inverse of this method is
1012
 
     * <code>charAt()</code>.
1013
 
     * @return an index from 0..size()-1, or -1
1014
 
     * @stable ICU 2.4
1015
 
     */
1016
 
    int32_t indexOf(UChar32 c) const;
1017
 
 
1018
 
    /**
1019
 
     * Returns the character at the given index within this set, where
1020
 
     * the set is ordered by ascending code point.  If the index is
1021
 
     * out of range, return (UChar32)-1.  The inverse of this method is
1022
 
     * <code>indexOf()</code>.
1023
 
     * @param index an index from 0..size()-1
1024
 
     * @return the character at the given index, or (UChar32)-1.
1025
 
     * @stable ICU 2.4
1026
 
     */
1027
 
    UChar32 charAt(int32_t index) const;
1028
 
 
1029
 
    /**
1030
 
     * Adds the specified range to this set if it is not already
1031
 
     * present.  If this set already contains the specified range,
1032
 
     * the call leaves this set unchanged.  If <code>end > start</code>
1033
 
     * then an empty range is added, leaving the set unchanged.
1034
 
     * This is equivalent to a boolean logic OR, or a set UNION.
1035
 
     * A frozen set will not be modified.
1036
 
     *
1037
 
     * @param start first character, inclusive, of range to be added
1038
 
     * to this set.
1039
 
     * @param end last character, inclusive, of range to be added
1040
 
     * to this set.
1041
 
     * @stable ICU 2.0
1042
 
     */
1043
 
    virtual UnicodeSet& add(UChar32 start, UChar32 end);
1044
 
 
1045
 
    /**
1046
 
     * Adds the specified character to this set if it is not already
1047
 
     * present.  If this set already contains the specified character,
1048
 
     * the call leaves this set unchanged.
1049
 
     * A frozen set will not be modified.
1050
 
     * @stable ICU 2.0
1051
 
     */
1052
 
    UnicodeSet& add(UChar32 c);
1053
 
 
1054
 
    /**
1055
 
     * Adds the specified multicharacter to this set if it is not already
1056
 
     * present.  If this set already contains the multicharacter,
1057
 
     * the call leaves this set unchanged.
1058
 
     * Thus "ch" => {"ch"}
1059
 
     * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
1060
 
     * A frozen set will not be modified.
1061
 
     * @param s the source string
1062
 
     * @return this object, for chaining
1063
 
     * @stable ICU 2.4
1064
 
     */
1065
 
    UnicodeSet& add(const UnicodeString& s);
1066
 
 
1067
 
 private:
1068
 
    /**
1069
 
     * @return a code point IF the string consists of a single one.
1070
 
     * otherwise returns -1.
1071
 
     * @param s string to test
1072
 
     */
1073
 
    static int32_t getSingleCP(const UnicodeString& s);
1074
 
 
1075
 
    void _add(const UnicodeString& s);
1076
 
 
1077
 
 public:
1078
 
    /**
1079
 
     * Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"}
1080
 
     * If this set already any particular character, it has no effect on that character.
1081
 
     * A frozen set will not be modified.
1082
 
     * @param s the source string
1083
 
     * @return this object, for chaining
1084
 
     * @stable ICU 2.4
1085
 
     */
1086
 
    UnicodeSet& addAll(const UnicodeString& s);
1087
 
 
1088
 
    /**
1089
 
     * Retains EACH of the characters in this string. Note: "ch" == {"c", "h"}
1090
 
     * If this set already any particular character, it has no effect on that character.
1091
 
     * A frozen set will not be modified.
1092
 
     * @param s the source string
1093
 
     * @return this object, for chaining
1094
 
     * @stable ICU 2.4
1095
 
     */
1096
 
    UnicodeSet& retainAll(const UnicodeString& s);
1097
 
 
1098
 
    /**
1099
 
     * Complement EACH of the characters in this string. Note: "ch" == {"c", "h"}
1100
 
     * If this set already any particular character, it has no effect on that character.
1101
 
     * A frozen set will not be modified.
1102
 
     * @param s the source string
1103
 
     * @return this object, for chaining
1104
 
     * @stable ICU 2.4
1105
 
     */
1106
 
    UnicodeSet& complementAll(const UnicodeString& s);
1107
 
 
1108
 
    /**
1109
 
     * Remove EACH of the characters in this string. Note: "ch" == {"c", "h"}
1110
 
     * If this set already any particular character, it has no effect on that character.
1111
 
     * A frozen set will not be modified.
1112
 
     * @param s the source string
1113
 
     * @return this object, for chaining
1114
 
     * @stable ICU 2.4
1115
 
     */
1116
 
    UnicodeSet& removeAll(const UnicodeString& s);
1117
 
 
1118
 
    /**
1119
 
     * Makes a set from a multicharacter string. Thus "ch" => {"ch"}
1120
 
     * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
1121
 
     * @param s the source string
1122
 
     * @return a newly created set containing the given string.
1123
 
     * The caller owns the return object and is responsible for deleting it.
1124
 
     * @stable ICU 2.4
1125
 
     */
1126
 
    static UnicodeSet* U_EXPORT2 createFrom(const UnicodeString& s);
1127
 
 
1128
 
 
1129
 
    /**
1130
 
     * Makes a set from each of the characters in the string. Thus "ch" => {"c", "h"}
1131
 
     * @param s the source string
1132
 
     * @return a newly created set containing the given characters
1133
 
     * The caller owns the return object and is responsible for deleting it.
1134
 
     * @stable ICU 2.4
1135
 
     */
1136
 
    static UnicodeSet* U_EXPORT2 createFromAll(const UnicodeString& s);
1137
 
 
1138
 
    /**
1139
 
     * Retain only the elements in this set that are contained in the
1140
 
     * specified range.  If <code>end > start</code> then an empty range is
1141
 
     * retained, leaving the set empty.  This is equivalent to
1142
 
     * a boolean logic AND, or a set INTERSECTION.
1143
 
     * A frozen set will not be modified.
1144
 
     *
1145
 
     * @param start first character, inclusive, of range to be retained
1146
 
     * to this set.
1147
 
     * @param end last character, inclusive, of range to be retained
1148
 
     * to this set.
1149
 
     * @stable ICU 2.0
1150
 
     */
1151
 
    virtual UnicodeSet& retain(UChar32 start, UChar32 end);
1152
 
 
1153
 
 
1154
 
    /**
1155
 
     * Retain the specified character from this set if it is present.
1156
 
     * A frozen set will not be modified.
1157
 
     * @stable ICU 2.0
1158
 
     */
1159
 
    UnicodeSet& retain(UChar32 c);
1160
 
 
1161
 
    /**
1162
 
     * Removes the specified range from this set if it is present.
1163
 
     * The set will not contain the specified range once the call
1164
 
     * returns.  If <code>end > start</code> then an empty range is
1165
 
     * removed, leaving the set unchanged.
1166
 
     * A frozen set will not be modified.
1167
 
     *
1168
 
     * @param start first character, inclusive, of range to be removed
1169
 
     * from this set.
1170
 
     * @param end last character, inclusive, of range to be removed
1171
 
     * from this set.
1172
 
     * @stable ICU 2.0
1173
 
     */
1174
 
    virtual UnicodeSet& remove(UChar32 start, UChar32 end);
1175
 
 
1176
 
    /**
1177
 
     * Removes the specified character from this set if it is present.
1178
 
     * The set will not contain the specified range once the call
1179
 
     * returns.
1180
 
     * A frozen set will not be modified.
1181
 
     * @stable ICU 2.0
1182
 
     */
1183
 
    UnicodeSet& remove(UChar32 c);
1184
 
 
1185
 
    /**
1186
 
     * Removes the specified string from this set if it is present.
1187
 
     * The set will not contain the specified character once the call
1188
 
     * returns.
1189
 
     * A frozen set will not be modified.
1190
 
     * @param s the source string
1191
 
     * @return this object, for chaining
1192
 
     * @stable ICU 2.4
1193
 
     */
1194
 
    UnicodeSet& remove(const UnicodeString& s);
1195
 
 
1196
 
    /**
1197
 
     * Inverts this set.  This operation modifies this set so that
1198
 
     * its value is its complement.  This is equivalent to
1199
 
     * <code>complement(MIN_VALUE, MAX_VALUE)</code>.
1200
 
     * A frozen set will not be modified.
1201
 
     * @stable ICU 2.0
1202
 
     */
1203
 
    virtual UnicodeSet& complement(void);
1204
 
 
1205
 
    /**
1206
 
     * Complements the specified range in this set.  Any character in
1207
 
     * the range will be removed if it is in this set, or will be
1208
 
     * added if it is not in this set.  If <code>end > start</code>
1209
 
     * then an empty range is complemented, leaving the set unchanged.
1210
 
     * This is equivalent to a boolean logic XOR.
1211
 
     * A frozen set will not be modified.
1212
 
     *
1213
 
     * @param start first character, inclusive, of range to be removed
1214
 
     * from this set.
1215
 
     * @param end last character, inclusive, of range to be removed
1216
 
     * from this set.
1217
 
     * @stable ICU 2.0
1218
 
     */
1219
 
    virtual UnicodeSet& complement(UChar32 start, UChar32 end);
1220
 
 
1221
 
    /**
1222
 
     * Complements the specified character in this set.  The character
1223
 
     * will be removed if it is in this set, or will be added if it is
1224
 
     * not in this set.
1225
 
     * A frozen set will not be modified.
1226
 
     * @stable ICU 2.0
1227
 
     */
1228
 
    UnicodeSet& complement(UChar32 c);
1229
 
 
1230
 
    /**
1231
 
     * Complement the specified string in this set.
1232
 
     * The set will not contain the specified string once the call
1233
 
     * returns.
1234
 
     * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
1235
 
     * A frozen set will not be modified.
1236
 
     * @param s the string to complement
1237
 
     * @return this object, for chaining
1238
 
     * @stable ICU 2.4
1239
 
     */
1240
 
    UnicodeSet& complement(const UnicodeString& s);
1241
 
 
1242
 
    /**
1243
 
     * Adds all of the elements in the specified set to this set if
1244
 
     * they're not already present.  This operation effectively
1245
 
     * modifies this set so that its value is the <i>union</i> of the two
1246
 
     * sets.  The behavior of this operation is unspecified if the specified
1247
 
     * collection is modified while the operation is in progress.
1248
 
     * A frozen set will not be modified.
1249
 
     *
1250
 
     * @param c set whose elements are to be added to this set.
1251
 
     * @see #add(UChar32, UChar32)
1252
 
     * @stable ICU 2.0
1253
 
     */
1254
 
    virtual UnicodeSet& addAll(const UnicodeSet& c);
1255
 
 
1256
 
    /**
1257
 
     * Retains only the elements in this set that are contained in the
1258
 
     * specified set.  In other words, removes from this set all of
1259
 
     * its elements that are not contained in the specified set.  This
1260
 
     * operation effectively modifies this set so that its value is
1261
 
     * the <i>intersection</i> of the two sets.
1262
 
     * A frozen set will not be modified.
1263
 
     *
1264
 
     * @param c set that defines which elements this set will retain.
1265
 
     * @stable ICU 2.0
1266
 
     */
1267
 
    virtual UnicodeSet& retainAll(const UnicodeSet& c);
1268
 
 
1269
 
    /**
1270
 
     * Removes from this set all of its elements that are contained in the
1271
 
     * specified set.  This operation effectively modifies this
1272
 
     * set so that its value is the <i>asymmetric set difference</i> of
1273
 
     * the two sets.
1274
 
     * A frozen set will not be modified.
1275
 
     *
1276
 
     * @param c set that defines which elements will be removed from
1277
 
     *          this set.
1278
 
     * @stable ICU 2.0
1279
 
     */
1280
 
    virtual UnicodeSet& removeAll(const UnicodeSet& c);
1281
 
 
1282
 
    /**
1283
 
     * Complements in this set all elements contained in the specified
1284
 
     * set.  Any character in the other set will be removed if it is
1285
 
     * in this set, or will be added if it is not in this set.
1286
 
     * A frozen set will not be modified.
1287
 
     *
1288
 
     * @param c set that defines which elements will be xor'ed from
1289
 
     *          this set.
1290
 
     * @stable ICU 2.4
1291
 
     */
1292
 
    virtual UnicodeSet& complementAll(const UnicodeSet& c);
1293
 
 
1294
 
    /**
1295
 
     * Removes all of the elements from this set.  This set will be
1296
 
     * empty after this call returns.
1297
 
     * A frozen set will not be modified.
1298
 
     * @stable ICU 2.0
1299
 
     */
1300
 
    virtual UnicodeSet& clear(void);
1301
 
 
1302
 
    /**
1303
 
     * Close this set over the given attribute.  For the attribute
1304
 
     * USET_CASE, the result is to modify this set so that:
1305
 
     *
1306
 
     * 1. For each character or string 'a' in this set, all strings or
1307
 
     * characters 'b' such that foldCase(a) == foldCase(b) are added
1308
 
     * to this set.
1309
 
     *
1310
 
     * 2. For each string 'e' in the resulting set, if e !=
1311
 
     * foldCase(e), 'e' will be removed.
1312
 
     *
1313
 
     * Example: [aq\\u00DF{Bc}{bC}{Fi}] => [aAqQ\\u00DF\\uFB01{ss}{bc}{fi}]
1314
 
     *
1315
 
     * (Here foldCase(x) refers to the operation u_strFoldCase, and a
1316
 
     * == b denotes that the contents are the same, not pointer
1317
 
     * comparison.)
1318
 
     *
1319
 
     * A frozen set will not be modified.
1320
 
     *
1321
 
     * @param attribute bitmask for attributes to close over.
1322
 
     * Currently only the USET_CASE bit is supported.  Any undefined bits
1323
 
     * are ignored.
1324
 
     * @return a reference to this set.
1325
 
     * @stable ICU 4.2
1326
 
     */
1327
 
    UnicodeSet& closeOver(int32_t attribute);
1328
 
 
1329
 
    /**
1330
 
     * Remove all strings from this set.
1331
 
     *
1332
 
     * @return a reference to this set.
1333
 
     * @stable ICU 4.2
1334
 
     */
1335
 
    virtual UnicodeSet &removeAllStrings();
1336
 
 
1337
 
    /**
1338
 
     * Iteration method that returns the number of ranges contained in
1339
 
     * this set.
1340
 
     * @see #getRangeStart
1341
 
     * @see #getRangeEnd
1342
 
     * @stable ICU 2.4
1343
 
     */
1344
 
    virtual int32_t getRangeCount(void) const;
1345
 
 
1346
 
    /**
1347
 
     * Iteration method that returns the first character in the
1348
 
     * specified range of this set.
1349
 
     * @see #getRangeCount
1350
 
     * @see #getRangeEnd
1351
 
     * @stable ICU 2.4
1352
 
     */
1353
 
    virtual UChar32 getRangeStart(int32_t index) const;
1354
 
 
1355
 
    /**
1356
 
     * Iteration method that returns the last character in the
1357
 
     * specified range of this set.
1358
 
     * @see #getRangeStart
1359
 
     * @see #getRangeEnd
1360
 
     * @stable ICU 2.4
1361
 
     */
1362
 
    virtual UChar32 getRangeEnd(int32_t index) const;
1363
 
 
1364
 
    /**
1365
 
     * Serializes this set into an array of 16-bit integers.  Serialization
1366
 
     * (currently) only records the characters in the set; multicharacter
1367
 
     * strings are ignored.
1368
 
     *
1369
 
     * The array has following format (each line is one 16-bit
1370
 
     * integer):
1371
 
     *
1372
 
     *  length     = (n+2*m) | (m!=0?0x8000:0)
1373
 
     *  bmpLength  = n; present if m!=0
1374
 
     *  bmp[0]
1375
 
     *  bmp[1]
1376
 
     *  ...
1377
 
     *  bmp[n-1]
1378
 
     *  supp-high[0]
1379
 
     *  supp-low[0]
1380
 
     *  supp-high[1]
1381
 
     *  supp-low[1]
1382
 
     *  ...
1383
 
     *  supp-high[m-1]
1384
 
     *  supp-low[m-1]
1385
 
     *
1386
 
     * The array starts with a header.  After the header are n bmp
1387
 
     * code points, then m supplementary code points.  Either n or m
1388
 
     * or both may be zero.  n+2*m is always <= 0x7FFF.
1389
 
     *
1390
 
     * If there are no supplementary characters (if m==0) then the
1391
 
     * header is one 16-bit integer, 'length', with value n.
1392
 
     *
1393
 
     * If there are supplementary characters (if m!=0) then the header
1394
 
     * is two 16-bit integers.  The first, 'length', has value
1395
 
     * (n+2*m)|0x8000.  The second, 'bmpLength', has value n.
1396
 
     *
1397
 
     * After the header the code points are stored in ascending order.
1398
 
     * Supplementary code points are stored as most significant 16
1399
 
     * bits followed by least significant 16 bits.
1400
 
     *
1401
 
     * @param dest pointer to buffer of destCapacity 16-bit integers.
1402
 
     * May be NULL only if destCapacity is zero.
1403
 
     * @param destCapacity size of dest, or zero.  Must not be negative.
1404
 
     * @param ec error code.  Will be set to U_INDEX_OUTOFBOUNDS_ERROR
1405
 
     * if n+2*m > 0x7FFF.  Will be set to U_BUFFER_OVERFLOW_ERROR if
1406
 
     * n+2*m+(m!=0?2:1) > destCapacity.
1407
 
     * @return the total length of the serialized format, including
1408
 
     * the header, that is, n+2*m+(m!=0?2:1), or 0 on error other
1409
 
     * than U_BUFFER_OVERFLOW_ERROR.
1410
 
     * @stable ICU 2.4
1411
 
     */
1412
 
    int32_t serialize(uint16_t *dest, int32_t destCapacity, UErrorCode& ec) const;
1413
 
 
1414
 
    /**
1415
 
     * Reallocate this objects internal structures to take up the least
1416
 
     * possible space, without changing this object's value.
1417
 
     * A frozen set will not be modified.
1418
 
     * @stable ICU 2.4
1419
 
     */
1420
 
    virtual UnicodeSet& compact();
1421
 
 
1422
 
    /**
1423
 
     * Return the class ID for this class.  This is useful only for
1424
 
     * comparing to a return value from getDynamicClassID().  For example:
1425
 
     * <pre>
1426
 
     * .      Base* polymorphic_pointer = createPolymorphicObject();
1427
 
     * .      if (polymorphic_pointer->getDynamicClassID() ==
1428
 
     * .          Derived::getStaticClassID()) ...
1429
 
     * </pre>
1430
 
     * @return          The class ID for all objects of this class.
1431
 
     * @stable ICU 2.0
1432
 
     */
1433
 
    static UClassID U_EXPORT2 getStaticClassID(void);
1434
 
 
1435
 
    /**
1436
 
     * Implement UnicodeFunctor API.
1437
 
     *
1438
 
     * @return The class ID for this object. All objects of a given
1439
 
     * class have the same class ID.  Objects of other classes have
1440
 
     * different class IDs.
1441
 
     * @stable ICU 2.4
1442
 
     */
1443
 
    virtual UClassID getDynamicClassID(void) const;
1444
 
 
1445
 
private:
1446
 
 
1447
 
    // Private API for the USet API
1448
 
 
1449
 
    friend class USetAccess;
1450
 
 
1451
 
    int32_t getStringCount() const;
1452
 
 
1453
 
    const UnicodeString* getString(int32_t index) const;
1454
 
 
1455
 
    //----------------------------------------------------------------
1456
 
    // RuleBasedTransliterator support
1457
 
    //----------------------------------------------------------------
1458
 
 
1459
 
private:
1460
 
 
1461
 
    /**
1462
 
     * Returns <tt>true</tt> if this set contains any character whose low byte
1463
 
     * is the given value.  This is used by <tt>RuleBasedTransliterator</tt> for
1464
 
     * indexing.
1465
 
     */
1466
 
    virtual UBool matchesIndexValue(uint8_t v) const;
1467
 
 
1468
 
private:
1469
 
 
1470
 
    //----------------------------------------------------------------
1471
 
    // Implementation: Clone as thawed (see ICU4J Freezable)
1472
 
    //----------------------------------------------------------------
1473
 
 
1474
 
    UnicodeSet(const UnicodeSet& o, UBool /* asThawed */);
1475
 
 
1476
 
    //----------------------------------------------------------------
1477
 
    // Implementation: Pattern parsing
1478
 
    //----------------------------------------------------------------
1479
 
 
1480
 
    void applyPattern(RuleCharacterIterator& chars,
1481
 
                      const SymbolTable* symbols,
1482
 
                      UnicodeString& rebuiltPat,
1483
 
                      uint32_t options,
1484
 
                      UErrorCode& ec);
1485
 
 
1486
 
    //----------------------------------------------------------------
1487
 
    // Implementation: Utility methods
1488
 
    //----------------------------------------------------------------
1489
 
 
1490
 
    void ensureCapacity(int32_t newLen, UErrorCode& ec);
1491
 
 
1492
 
    void ensureBufferCapacity(int32_t newLen, UErrorCode& ec);
1493
 
 
1494
 
    void swapBuffers(void);
1495
 
 
1496
 
    UBool allocateStrings(UErrorCode &status);
1497
 
 
1498
 
    UnicodeString& _toPattern(UnicodeString& result,
1499
 
                              UBool escapeUnprintable) const;
1500
 
 
1501
 
    UnicodeString& _generatePattern(UnicodeString& result,
1502
 
                                    UBool escapeUnprintable) const;
1503
 
 
1504
 
    static void _appendToPat(UnicodeString& buf, const UnicodeString& s, UBool escapeUnprintable);
1505
 
 
1506
 
    static void _appendToPat(UnicodeString& buf, UChar32 c, UBool escapeUnprintable);
1507
 
 
1508
 
    //----------------------------------------------------------------
1509
 
    // Implementation: Fundamental operators
1510
 
    //----------------------------------------------------------------
1511
 
 
1512
 
    void exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity);
1513
 
 
1514
 
    void add(const UChar32* other, int32_t otherLen, int8_t polarity);
1515
 
 
1516
 
    void retain(const UChar32* other, int32_t otherLen, int8_t polarity);
1517
 
 
1518
 
    /**
1519
 
     * Return true if the given position, in the given pattern, appears
1520
 
     * to be the start of a property set pattern [:foo:], \\p{foo}, or
1521
 
     * \\P{foo}, or \\N{name}.
1522
 
     */
1523
 
    static UBool resemblesPropertyPattern(const UnicodeString& pattern,
1524
 
                                          int32_t pos);
1525
 
 
1526
 
    static UBool resemblesPropertyPattern(RuleCharacterIterator& chars,
1527
 
                                          int32_t iterOpts);
1528
 
 
1529
 
    /**
1530
 
     * Parse the given property pattern at the given parse position
1531
 
     * and set this UnicodeSet to the result.
1532
 
     *
1533
 
     * The original design document is out of date, but still useful.
1534
 
     * Ignore the property and value names:
1535
 
     * http://source.icu-project.org/repos/icu/icuhtml/trunk/design/unicodeset_properties.html
1536
 
     *
1537
 
     * Recognized syntax:
1538
 
     *
1539
 
     * [:foo:] [:^foo:] - white space not allowed within "[:" or ":]"
1540
 
     * \\p{foo} \\P{foo}  - white space not allowed within "\\p" or "\\P"
1541
 
     * \\N{name}         - white space not allowed within "\\N"
1542
 
     *
1543
 
     * Other than the above restrictions, white space is ignored.  Case
1544
 
     * is ignored except in "\\p" and "\\P" and "\\N".  In 'name' leading
1545
 
     * and trailing space is deleted, and internal runs of whitespace
1546
 
     * are collapsed to a single space.
1547
 
     *
1548
 
     * We support binary properties, enumerated properties, and the
1549
 
     * following non-enumerated properties:
1550
 
     *
1551
 
     *  Numeric_Value
1552
 
     *  Name
1553
 
     *  Unicode_1_Name
1554
 
     *
1555
 
     * @param pattern the pattern string
1556
 
     * @param ppos on entry, the position at which to begin parsing.
1557
 
     * This should be one of the locations marked '^':
1558
 
     *
1559
 
     *   [:blah:]     \\p{blah}     \\P{blah}     \\N{name}
1560
 
     *   ^       %    ^       %    ^       %    ^       %
1561
 
     *
1562
 
     * On return, the position after the last character parsed, that is,
1563
 
     * the locations marked '%'.  If the parse fails, ppos is returned
1564
 
     * unchanged.
1565
 
     * @return a reference to this.
1566
 
     */
1567
 
    UnicodeSet& applyPropertyPattern(const UnicodeString& pattern,
1568
 
                                     ParsePosition& ppos,
1569
 
                                     UErrorCode &ec);
1570
 
 
1571
 
    void applyPropertyPattern(RuleCharacterIterator& chars,
1572
 
                              UnicodeString& rebuiltPat,
1573
 
                              UErrorCode& ec);
1574
 
 
1575
 
    static const UnicodeSet* getInclusions(int32_t src, UErrorCode &status);
1576
 
 
1577
 
    /**
1578
 
     * A filter that returns TRUE if the given code point should be
1579
 
     * included in the UnicodeSet being constructed.
1580
 
     */
1581
 
    typedef UBool (*Filter)(UChar32 codePoint, void* context);
1582
 
 
1583
 
    /**
1584
 
     * Given a filter, set this UnicodeSet to the code points
1585
 
     * contained by that filter.  The filter MUST be
1586
 
     * property-conformant.  That is, if it returns value v for one
1587
 
     * code point, then it must return v for all affiliated code
1588
 
     * points, as defined by the inclusions list.  See
1589
 
     * getInclusions().
1590
 
     * src is a UPropertySource value.
1591
 
     */
1592
 
    void applyFilter(Filter filter,
1593
 
                     void* context,
1594
 
                     int32_t src,
1595
 
                     UErrorCode &status);
1596
 
 
1597
 
    /**
1598
 
     * Set the new pattern to cache.
1599
 
     */
1600
 
    void setPattern(const UnicodeString& newPat);
1601
 
    /**
1602
 
     * Release existing cached pattern.
1603
 
     */
1604
 
    void releasePattern();
1605
 
 
1606
 
    friend class UnicodeSetIterator;
1607
 
};
1608
 
 
1609
 
 
1610
 
 
1611
 
inline UBool UnicodeSet::operator!=(const UnicodeSet& o) const {
1612
 
    return !operator==(o);
1613
 
}
1614
 
 
1615
 
inline UBool UnicodeSet::isFrozen() const {
1616
 
    return (UBool)(bmpSet!=NULL || stringSpan!=NULL);
1617
 
}
1618
 
 
1619
 
inline UBool UnicodeSet::containsSome(UChar32 start, UChar32 end) const {
1620
 
    return !containsNone(start, end);
1621
 
}
1622
 
 
1623
 
inline UBool UnicodeSet::containsSome(const UnicodeSet& s) const {
1624
 
    return !containsNone(s);
1625
 
}
1626
 
 
1627
 
inline UBool UnicodeSet::containsSome(const UnicodeString& s) const {
1628
 
    return !containsNone(s);
1629
 
}
1630
 
 
1631
 
inline UBool UnicodeSet::isBogus() const {
1632
 
    return (UBool)(fFlags & kIsBogus);
1633
 
}
1634
 
 
1635
 
inline UnicodeSet *UnicodeSet::fromUSet(USet *uset) {
1636
 
    return reinterpret_cast<UnicodeSet *>(uset);
1637
 
}
1638
 
 
1639
 
inline const UnicodeSet *UnicodeSet::fromUSet(const USet *uset) {
1640
 
    return reinterpret_cast<const UnicodeSet *>(uset);
1641
 
}
1642
 
 
1643
 
inline USet *UnicodeSet::toUSet() {
1644
 
    return reinterpret_cast<USet *>(this);
1645
 
}
1646
 
 
1647
 
inline const USet *UnicodeSet::toUSet() const {
1648
 
    return reinterpret_cast<const USet *>(this);
1649
 
}
1650
 
 
1651
 
inline int32_t UnicodeSet::span(const UnicodeString &s, int32_t start, USetSpanCondition spanCondition) const {
1652
 
    int32_t sLength=s.length();
1653
 
    if(start<0) {
1654
 
        start=0;
1655
 
    } else if(start>sLength) {
1656
 
        start=sLength;
1657
 
    }
1658
 
    return start+span(s.getBuffer()+start, sLength-start, spanCondition);
1659
 
}
1660
 
 
1661
 
inline int32_t UnicodeSet::spanBack(const UnicodeString &s, int32_t limit, USetSpanCondition spanCondition) const {
1662
 
    int32_t sLength=s.length();
1663
 
    if(limit<0) {
1664
 
        limit=0;
1665
 
    } else if(limit>sLength) {
1666
 
        limit=sLength;
1667
 
    }
1668
 
    return spanBack(s.getBuffer(), limit, spanCondition);
1669
 
}
1670
 
 
1671
 
U_NAMESPACE_END
1672
 
 
1673
 
#endif