← 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/normlzr.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/normlzr.h
1
 
/*
2
 
 ********************************************************************
3
 
 * COPYRIGHT:
4
 
 * Copyright (c) 1996-2010, International Business Machines Corporation and
5
 
 * others. All Rights Reserved.
6
 
 ********************************************************************
7
 
 */
8
 
 
9
 
#ifndef NORMLZR_H
10
 
#define NORMLZR_H
11
 
 
12
 
#include "unicode/utypes.h"
13
 
 
14
 
/**
15
 
 * \file 
16
 
 * \brief C++ API: Unicode Normalization
17
 
 */
18
 
 
19
 
#if !UCONFIG_NO_NORMALIZATION
20
 
 
21
 
#include "unicode/chariter.h"
22
 
#include "unicode/normalizer2.h"
23
 
#include "unicode/unistr.h"
24
 
#include "unicode/unorm.h"
25
 
#include "unicode/uobject.h"
26
 
 
27
 
U_NAMESPACE_BEGIN
28
 
/**
29
 
 * The Normalizer class supports the standard normalization forms described in
30
 
 * <a href="http://www.unicode.org/unicode/reports/tr15/" target="unicode">
31
 
 * Unicode Standard Annex #15: Unicode Normalization Forms</a>.
32
 
 *
33
 
 * Note: This API has been replaced by the Normalizer2 class and is only available
34
 
 * for backward compatibility. This class simply delegates to the Normalizer2 class.
35
 
 * There is one exception: The new API does not provide a replacement for Normalizer::compare().
36
 
 *
37
 
 * The Normalizer class consists of two parts:
38
 
 * - static functions that normalize strings or test if strings are normalized
39
 
 * - a Normalizer object is an iterator that takes any kind of text and
40
 
 *   provides iteration over its normalized form
41
 
 *
42
 
 * The Normalizer class is not suitable for subclassing.
43
 
 *
44
 
 * For basic information about normalization forms and details about the C API
45
 
 * please see the documentation in unorm.h.
46
 
 *
47
 
 * The iterator API with the Normalizer constructors and the non-static functions
48
 
 * use a CharacterIterator as input. It is possible to pass a string which
49
 
 * is then internally wrapped in a CharacterIterator.
50
 
 * The input text is not normalized all at once, but incrementally where needed
51
 
 * (providing efficient random access).
52
 
 * This allows to pass in a large text but spend only a small amount of time
53
 
 * normalizing a small part of that text.
54
 
 * However, if the entire text is normalized, then the iterator will be
55
 
 * slower than normalizing the entire text at once and iterating over the result.
56
 
 * A possible use of the Normalizer iterator is also to report an index into the
57
 
 * original text that is close to where the normalized characters come from.
58
 
 *
59
 
 * <em>Important:</em> The iterator API was cleaned up significantly for ICU 2.0.
60
 
 * The earlier implementation reported the getIndex() inconsistently,
61
 
 * and previous() could not be used after setIndex(), next(), first(), and current().
62
 
 *
63
 
 * Normalizer allows to start normalizing from anywhere in the input text by
64
 
 * calling setIndexOnly(), first(), or last().
65
 
 * Without calling any of these, the iterator will start at the beginning of the text.
66
 
 *
67
 
 * At any time, next() returns the next normalized code point (UChar32),
68
 
 * with post-increment semantics (like CharacterIterator::next32PostInc()).
69
 
 * previous() returns the previous normalized code point (UChar32),
70
 
 * with pre-decrement semantics (like CharacterIterator::previous32()).
71
 
 *
72
 
 * current() returns the current code point
73
 
 * (respectively the one at the newly set index) without moving
74
 
 * the getIndex(). Note that if the text at the current position
75
 
 * needs to be normalized, then these functions will do that.
76
 
 * (This is why current() is not const.)
77
 
 * It is more efficient to call setIndexOnly() instead, which does not
78
 
 * normalize.
79
 
 *
80
 
 * getIndex() always refers to the position in the input text where the normalized
81
 
 * code points are returned from. It does not always change with each returned
82
 
 * code point.
83
 
 * The code point that is returned from any of the functions
84
 
 * corresponds to text at or after getIndex(), according to the
85
 
 * function's iteration semantics (post-increment or pre-decrement).
86
 
 *
87
 
 * next() returns a code point from at or after the getIndex()
88
 
 * from before the next() call. After the next() call, the getIndex()
89
 
 * might have moved to where the next code point will be returned from
90
 
 * (from a next() or current() call).
91
 
 * This is semantically equivalent to array access with array[index++]
92
 
 * (post-increment semantics).
93
 
 *
94
 
 * previous() returns a code point from at or after the getIndex()
95
 
 * from after the previous() call.
96
 
 * This is semantically equivalent to array access with array[--index]
97
 
 * (pre-decrement semantics).
98
 
 *
99
 
 * Internally, the Normalizer iterator normalizes a small piece of text
100
 
 * starting at the getIndex() and ending at a following "safe" index.
101
 
 * The normalized results is stored in an internal string buffer, and
102
 
 * the code points are iterated from there.
103
 
 * With multiple iteration calls, this is repeated until the next piece
104
 
 * of text needs to be normalized, and the getIndex() needs to be moved.
105
 
 *
106
 
 * The following "safe" index, the internal buffer, and the secondary
107
 
 * iteration index into that buffer are not exposed on the API.
108
 
 * This also means that it is currently not practical to return to
109
 
 * a particular, arbitrary position in the text because one would need to
110
 
 * know, and be able to set, in addition to the getIndex(), at least also the
111
 
 * current index into the internal buffer.
112
 
 * It is currently only possible to observe when getIndex() changes
113
 
 * (with careful consideration of the iteration semantics),
114
 
 * at which time the internal index will be 0.
115
 
 * For example, if getIndex() is different after next() than before it,
116
 
 * then the internal index is 0 and one can return to this getIndex()
117
 
 * later with setIndexOnly().
118
 
 *
119
 
 * Note: While the setIndex() and getIndex() refer to indices in the
120
 
 * underlying Unicode input text, the next() and previous() methods
121
 
 * iterate through characters in the normalized output.
122
 
 * This means that there is not necessarily a one-to-one correspondence
123
 
 * between characters returned by next() and previous() and the indices
124
 
 * passed to and returned from setIndex() and getIndex().
125
 
 * It is for this reason that Normalizer does not implement the CharacterIterator interface.
126
 
 *
127
 
 * @author Laura Werner, Mark Davis, Markus Scherer
128
 
 * @stable ICU 2.0
129
 
 */
130
 
class U_COMMON_API Normalizer : public UObject {
131
 
public:
132
 
  /**
133
 
   * If DONE is returned from an iteration function that returns a code point,
134
 
   * then there are no more normalization results available.
135
 
   * @stable ICU 2.0
136
 
   */
137
 
  enum {
138
 
      DONE=0xffff
139
 
  };
140
 
 
141
 
  // Constructors
142
 
 
143
 
  /**
144
 
   * Creates a new <code>Normalizer</code> object for iterating over the
145
 
   * normalized form of a given string.
146
 
   * <p>
147
 
   * @param str   The string to be normalized.  The normalization
148
 
   *              will start at the beginning of the string.
149
 
   *
150
 
   * @param mode  The normalization mode.
151
 
   * @stable ICU 2.0
152
 
   */
153
 
  Normalizer(const UnicodeString& str, UNormalizationMode mode);
154
 
 
155
 
  /**
156
 
   * Creates a new <code>Normalizer</code> object for iterating over the
157
 
   * normalized form of a given string.
158
 
   * <p>
159
 
   * @param str   The string to be normalized.  The normalization
160
 
   *              will start at the beginning of the string.
161
 
   *
162
 
   * @param length Length of the string, or -1 if NUL-terminated.
163
 
   * @param mode  The normalization mode.
164
 
   * @stable ICU 2.0
165
 
   */
166
 
  Normalizer(const UChar* str, int32_t length, UNormalizationMode mode);
167
 
 
168
 
  /**
169
 
   * Creates a new <code>Normalizer</code> object for iterating over the
170
 
   * normalized form of the given text.
171
 
   * <p>
172
 
   * @param iter  The input text to be normalized.  The normalization
173
 
   *              will start at the beginning of the string.
174
 
   *
175
 
   * @param mode  The normalization mode.
176
 
   * @stable ICU 2.0
177
 
   */
178
 
  Normalizer(const CharacterIterator& iter, UNormalizationMode mode);
179
 
 
180
 
  /**
181
 
   * Copy constructor.
182
 
   * @param copy The object to be copied.
183
 
   * @stable ICU 2.0
184
 
   */
185
 
  Normalizer(const Normalizer& copy);
186
 
 
187
 
  /**
188
 
   * Destructor
189
 
   * @stable ICU 2.0
190
 
   */
191
 
  virtual ~Normalizer();
192
 
 
193
 
 
194
 
  //-------------------------------------------------------------------------
195
 
  // Static utility methods
196
 
  //-------------------------------------------------------------------------
197
 
 
198
 
  /**
199
 
   * Normalizes a <code>UnicodeString</code> according to the specified normalization mode.
200
 
   * This is a wrapper for unorm_normalize(), using UnicodeString's.
201
 
   *
202
 
   * The <code>options</code> parameter specifies which optional
203
 
   * <code>Normalizer</code> features are to be enabled for this operation.
204
 
   *
205
 
   * @param source    the input string to be normalized.
206
 
   * @param mode      the normalization mode
207
 
   * @param options   the optional features to be enabled (0 for no options)
208
 
   * @param result    The normalized string (on output).
209
 
   * @param status    The error code.
210
 
   * @stable ICU 2.0
211
 
   */
212
 
  static void U_EXPORT2 normalize(const UnicodeString& source,
213
 
                        UNormalizationMode mode, int32_t options,
214
 
                        UnicodeString& result,
215
 
                        UErrorCode &status);
216
 
 
217
 
  /**
218
 
   * Compose a <code>UnicodeString</code>.
219
 
   * This is equivalent to normalize() with mode UNORM_NFC or UNORM_NFKC.
220
 
   * This is a wrapper for unorm_normalize(), using UnicodeString's.
221
 
   *
222
 
   * The <code>options</code> parameter specifies which optional
223
 
   * <code>Normalizer</code> features are to be enabled for this operation.
224
 
   *
225
 
   * @param source    the string to be composed.
226
 
   * @param compat    Perform compatibility decomposition before composition.
227
 
   *                  If this argument is <code>FALSE</code>, only canonical
228
 
   *                  decomposition will be performed.
229
 
   * @param options   the optional features to be enabled (0 for no options)
230
 
   * @param result    The composed string (on output).
231
 
   * @param status    The error code.
232
 
   * @stable ICU 2.0
233
 
   */
234
 
  static void U_EXPORT2 compose(const UnicodeString& source,
235
 
                      UBool compat, int32_t options,
236
 
                      UnicodeString& result,
237
 
                      UErrorCode &status);
238
 
 
239
 
  /**
240
 
   * Static method to decompose a <code>UnicodeString</code>.
241
 
   * This is equivalent to normalize() with mode UNORM_NFD or UNORM_NFKD.
242
 
   * This is a wrapper for unorm_normalize(), using UnicodeString's.
243
 
   *
244
 
   * The <code>options</code> parameter specifies which optional
245
 
   * <code>Normalizer</code> features are to be enabled for this operation.
246
 
   *
247
 
   * @param source    the string to be decomposed.
248
 
   * @param compat    Perform compatibility decomposition.
249
 
   *                  If this argument is <code>FALSE</code>, only canonical
250
 
   *                  decomposition will be performed.
251
 
   * @param options   the optional features to be enabled (0 for no options)
252
 
   * @param result    The decomposed string (on output).
253
 
   * @param status    The error code.
254
 
   * @stable ICU 2.0
255
 
   */
256
 
  static void U_EXPORT2 decompose(const UnicodeString& source,
257
 
                        UBool compat, int32_t options,
258
 
                        UnicodeString& result,
259
 
                        UErrorCode &status);
260
 
 
261
 
  /**
262
 
   * Performing quick check on a string, to quickly determine if the string is
263
 
   * in a particular normalization format.
264
 
   * This is a wrapper for unorm_quickCheck(), using a UnicodeString.
265
 
   *
266
 
   * Three types of result can be returned UNORM_YES, UNORM_NO or
267
 
   * UNORM_MAYBE. Result UNORM_YES indicates that the argument
268
 
   * string is in the desired normalized format, UNORM_NO determines that
269
 
   * argument string is not in the desired normalized format. A
270
 
   * UNORM_MAYBE result indicates that a more thorough check is required,
271
 
   * the user may have to put the string in its normalized form and compare the
272
 
   * results.
273
 
   * @param source       string for determining if it is in a normalized format
274
 
   * @param mode         normalization format
275
 
   * @param status A reference to a UErrorCode to receive any errors
276
 
   * @return UNORM_YES, UNORM_NO or UNORM_MAYBE
277
 
   *
278
 
   * @see isNormalized
279
 
   * @stable ICU 2.0
280
 
   */
281
 
  static inline UNormalizationCheckResult
282
 
  quickCheck(const UnicodeString &source, UNormalizationMode mode, UErrorCode &status);
283
 
 
284
 
  /**
285
 
   * Performing quick check on a string; same as the other version of quickCheck
286
 
   * but takes an extra options parameter like most normalization functions.
287
 
   *
288
 
   * @param source       string for determining if it is in a normalized format
289
 
   * @param mode         normalization format
290
 
   * @param options      the optional features to be enabled (0 for no options)
291
 
   * @param status A reference to a UErrorCode to receive any errors
292
 
   * @return UNORM_YES, UNORM_NO or UNORM_MAYBE
293
 
   *
294
 
   * @see isNormalized
295
 
   * @stable ICU 2.6
296
 
   */
297
 
  static UNormalizationCheckResult
298
 
  quickCheck(const UnicodeString &source, UNormalizationMode mode, int32_t options, UErrorCode &status);
299
 
 
300
 
  /**
301
 
   * Test if a string is in a given normalization form.
302
 
   * This is semantically equivalent to source.equals(normalize(source, mode)) .
303
 
   *
304
 
   * Unlike unorm_quickCheck(), this function returns a definitive result,
305
 
   * never a "maybe".
306
 
   * For NFD, NFKD, and FCD, both functions work exactly the same.
307
 
   * For NFC and NFKC where quickCheck may return "maybe", this function will
308
 
   * perform further tests to arrive at a TRUE/FALSE result.
309
 
   *
310
 
   * @param src        String that is to be tested if it is in a normalization format.
311
 
   * @param mode       Which normalization form to test for.
312
 
   * @param errorCode  ICU error code in/out parameter.
313
 
   *                   Must fulfill U_SUCCESS before the function call.
314
 
   * @return Boolean value indicating whether the source string is in the
315
 
   *         "mode" normalization form.
316
 
   *
317
 
   * @see quickCheck
318
 
   * @stable ICU 2.2
319
 
   */
320
 
  static inline UBool
321
 
  isNormalized(const UnicodeString &src, UNormalizationMode mode, UErrorCode &errorCode);
322
 
 
323
 
  /**
324
 
   * Test if a string is in a given normalization form; same as the other version of isNormalized
325
 
   * but takes an extra options parameter like most normalization functions.
326
 
   *
327
 
   * @param src        String that is to be tested if it is in a normalization format.
328
 
   * @param mode       Which normalization form to test for.
329
 
   * @param options      the optional features to be enabled (0 for no options)
330
 
   * @param errorCode  ICU error code in/out parameter.
331
 
   *                   Must fulfill U_SUCCESS before the function call.
332
 
   * @return Boolean value indicating whether the source string is in the
333
 
   *         "mode" normalization form.
334
 
   *
335
 
   * @see quickCheck
336
 
   * @stable ICU 2.6
337
 
   */
338
 
  static UBool
339
 
  isNormalized(const UnicodeString &src, UNormalizationMode mode, int32_t options, UErrorCode &errorCode);
340
 
 
341
 
  /**
342
 
   * Concatenate normalized strings, making sure that the result is normalized as well.
343
 
   *
344
 
   * If both the left and the right strings are in
345
 
   * the normalization form according to "mode/options",
346
 
   * then the result will be
347
 
   *
348
 
   * \code
349
 
   *     dest=normalize(left+right, mode, options)
350
 
   * \endcode
351
 
   *
352
 
   * For details see unorm_concatenate in unorm.h.
353
 
   *
354
 
   * @param left Left source string.
355
 
   * @param right Right source string.
356
 
   * @param result The output string.
357
 
   * @param mode The normalization mode.
358
 
   * @param options A bit set of normalization options.
359
 
   * @param errorCode ICU error code in/out parameter.
360
 
   *                   Must fulfill U_SUCCESS before the function call.
361
 
   * @return result
362
 
   *
363
 
   * @see unorm_concatenate
364
 
   * @see normalize
365
 
   * @see unorm_next
366
 
   * @see unorm_previous
367
 
   *
368
 
   * @stable ICU 2.1
369
 
   */
370
 
  static UnicodeString &
371
 
  U_EXPORT2 concatenate(UnicodeString &left, UnicodeString &right,
372
 
              UnicodeString &result,
373
 
              UNormalizationMode mode, int32_t options,
374
 
              UErrorCode &errorCode);
375
 
 
376
 
  /**
377
 
   * Compare two strings for canonical equivalence.
378
 
   * Further options include case-insensitive comparison and
379
 
   * code point order (as opposed to code unit order).
380
 
   *
381
 
   * Canonical equivalence between two strings is defined as their normalized
382
 
   * forms (NFD or NFC) being identical.
383
 
   * This function compares strings incrementally instead of normalizing
384
 
   * (and optionally case-folding) both strings entirely,
385
 
   * improving performance significantly.
386
 
   *
387
 
   * Bulk normalization is only necessary if the strings do not fulfill the FCD
388
 
   * conditions. Only in this case, and only if the strings are relatively long,
389
 
   * is memory allocated temporarily.
390
 
   * For FCD strings and short non-FCD strings there is no memory allocation.
391
 
   *
392
 
   * Semantically, this is equivalent to
393
 
   *   strcmp[CodePointOrder](NFD(foldCase(s1)), NFD(foldCase(s2)))
394
 
   * where code point order and foldCase are all optional.
395
 
   *
396
 
   * UAX 21 2.5 Caseless Matching specifies that for a canonical caseless match
397
 
   * the case folding must be performed first, then the normalization.
398
 
   *
399
 
   * @param s1 First source string.
400
 
   * @param s2 Second source string.
401
 
   *
402
 
   * @param options A bit set of options:
403
 
   *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
404
 
   *     Case-sensitive comparison in code unit order, and the input strings
405
 
   *     are quick-checked for FCD.
406
 
   *
407
 
   *   - UNORM_INPUT_IS_FCD
408
 
   *     Set if the caller knows that both s1 and s2 fulfill the FCD conditions.
409
 
   *     If not set, the function will quickCheck for FCD
410
 
   *     and normalize if necessary.
411
 
   *
412
 
   *   - U_COMPARE_CODE_POINT_ORDER
413
 
   *     Set to choose code point order instead of code unit order
414
 
   *     (see u_strCompare for details).
415
 
   *
416
 
   *   - U_COMPARE_IGNORE_CASE
417
 
   *     Set to compare strings case-insensitively using case folding,
418
 
   *     instead of case-sensitively.
419
 
   *     If set, then the following case folding options are used.
420
 
   *
421
 
   *   - Options as used with case-insensitive comparisons, currently:
422
 
   *
423
 
   *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
424
 
   *    (see u_strCaseCompare for details)
425
 
   *
426
 
   *   - regular normalization options shifted left by UNORM_COMPARE_NORM_OPTIONS_SHIFT
427
 
   *
428
 
   * @param errorCode ICU error code in/out parameter.
429
 
   *                  Must fulfill U_SUCCESS before the function call.
430
 
   * @return <0 or 0 or >0 as usual for string comparisons
431
 
   *
432
 
   * @see unorm_compare
433
 
   * @see normalize
434
 
   * @see UNORM_FCD
435
 
   * @see u_strCompare
436
 
   * @see u_strCaseCompare
437
 
   *
438
 
   * @stable ICU 2.2
439
 
   */
440
 
  static inline int32_t
441
 
  compare(const UnicodeString &s1, const UnicodeString &s2,
442
 
          uint32_t options,
443
 
          UErrorCode &errorCode);
444
 
 
445
 
  //-------------------------------------------------------------------------
446
 
  // Iteration API
447
 
  //-------------------------------------------------------------------------
448
 
 
449
 
  /**
450
 
   * Return the current character in the normalized text.
451
 
   * current() may need to normalize some text at getIndex().
452
 
   * The getIndex() is not changed.
453
 
   *
454
 
   * @return the current normalized code point
455
 
   * @stable ICU 2.0
456
 
   */
457
 
  UChar32              current(void);
458
 
 
459
 
  /**
460
 
   * Return the first character in the normalized text.
461
 
   * This is equivalent to setIndexOnly(startIndex()) followed by next().
462
 
   * (Post-increment semantics.)
463
 
   *
464
 
   * @return the first normalized code point
465
 
   * @stable ICU 2.0
466
 
   */
467
 
  UChar32              first(void);
468
 
 
469
 
  /**
470
 
   * Return the last character in the normalized text.
471
 
   * This is equivalent to setIndexOnly(endIndex()) followed by previous().
472
 
   * (Pre-decrement semantics.)
473
 
   *
474
 
   * @return the last normalized code point
475
 
   * @stable ICU 2.0
476
 
   */
477
 
  UChar32              last(void);
478
 
 
479
 
  /**
480
 
   * Return the next character in the normalized text.
481
 
   * (Post-increment semantics.)
482
 
   * If the end of the text has already been reached, DONE is returned.
483
 
   * The DONE value could be confused with a U+FFFF non-character code point
484
 
   * in the text. If this is possible, you can test getIndex()<endIndex()
485
 
   * before calling next(), or (getIndex()<endIndex() || last()!=DONE)
486
 
   * after calling next(). (Calling last() will change the iterator state!)
487
 
   *
488
 
   * The C API unorm_next() is more efficient and does not have this ambiguity.
489
 
   *
490
 
   * @return the next normalized code point
491
 
   * @stable ICU 2.0
492
 
   */
493
 
  UChar32              next(void);
494
 
 
495
 
  /**
496
 
   * Return the previous character in the normalized text and decrement.
497
 
   * (Pre-decrement semantics.)
498
 
   * If the beginning of the text has already been reached, DONE is returned.
499
 
   * The DONE value could be confused with a U+FFFF non-character code point
500
 
   * in the text. If this is possible, you can test
501
 
   * (getIndex()>startIndex() || first()!=DONE). (Calling first() will change
502
 
   * the iterator state!)
503
 
   *
504
 
   * The C API unorm_previous() is more efficient and does not have this ambiguity.
505
 
   *
506
 
   * @return the previous normalized code point
507
 
   * @stable ICU 2.0
508
 
   */
509
 
  UChar32              previous(void);
510
 
 
511
 
  /**
512
 
   * Set the iteration position in the input text that is being normalized,
513
 
   * without any immediate normalization.
514
 
   * After setIndexOnly(), getIndex() will return the same index that is
515
 
   * specified here.
516
 
   *
517
 
   * @param index the desired index in the input text.
518
 
   * @stable ICU 2.0
519
 
   */
520
 
  void                 setIndexOnly(int32_t index);
521
 
 
522
 
  /**
523
 
   * Reset the index to the beginning of the text.
524
 
   * This is equivalent to setIndexOnly(startIndex)).
525
 
   * @stable ICU 2.0
526
 
   */
527
 
  void                reset(void);
528
 
 
529
 
  /**
530
 
   * Retrieve the current iteration position in the input text that is
531
 
   * being normalized.
532
 
   *
533
 
   * A following call to next() will return a normalized code point from
534
 
   * the input text at or after this index.
535
 
   *
536
 
   * After a call to previous(), getIndex() will point at or before the
537
 
   * position in the input text where the normalized code point
538
 
   * was returned from with previous().
539
 
   *
540
 
   * @return the current index in the input text
541
 
   * @stable ICU 2.0
542
 
   */
543
 
  int32_t            getIndex(void) const;
544
 
 
545
 
  /**
546
 
   * Retrieve the index of the start of the input text. This is the begin index
547
 
   * of the <code>CharacterIterator</code> or the start (i.e. index 0) of the string
548
 
   * over which this <code>Normalizer</code> is iterating.
549
 
   *
550
 
   * @return the smallest index in the input text where the Normalizer operates
551
 
   * @stable ICU 2.0
552
 
   */
553
 
  int32_t            startIndex(void) const;
554
 
 
555
 
  /**
556
 
   * Retrieve the index of the end of the input text. This is the end index
557
 
   * of the <code>CharacterIterator</code> or the length of the string
558
 
   * over which this <code>Normalizer</code> is iterating.
559
 
   * This end index is exclusive, i.e., the Normalizer operates only on characters
560
 
   * before this index.
561
 
   *
562
 
   * @return the first index in the input text where the Normalizer does not operate
563
 
   * @stable ICU 2.0
564
 
   */
565
 
  int32_t            endIndex(void) const;
566
 
 
567
 
  /**
568
 
   * Returns TRUE when both iterators refer to the same character in the same
569
 
   * input text.
570
 
   *
571
 
   * @param that a Normalizer object to compare this one to
572
 
   * @return comparison result
573
 
   * @stable ICU 2.0
574
 
   */
575
 
  UBool        operator==(const Normalizer& that) const;
576
 
 
577
 
  /**
578
 
   * Returns FALSE when both iterators refer to the same character in the same
579
 
   * input text.
580
 
   *
581
 
   * @param that a Normalizer object to compare this one to
582
 
   * @return comparison result
583
 
   * @stable ICU 2.0
584
 
   */
585
 
  inline UBool        operator!=(const Normalizer& that) const;
586
 
 
587
 
  /**
588
 
   * Returns a pointer to a new Normalizer that is a clone of this one.
589
 
   * The caller is responsible for deleting the new clone.
590
 
   * @return a pointer to a new Normalizer
591
 
   * @stable ICU 2.0
592
 
   */
593
 
  Normalizer*        clone(void) const;
594
 
 
595
 
  /**
596
 
   * Generates a hash code for this iterator.
597
 
   *
598
 
   * @return the hash code
599
 
   * @stable ICU 2.0
600
 
   */
601
 
  int32_t                hashCode(void) const;
602
 
 
603
 
  //-------------------------------------------------------------------------
604
 
  // Property access methods
605
 
  //-------------------------------------------------------------------------
606
 
 
607
 
  /**
608
 
   * Set the normalization mode for this object.
609
 
   * <p>
610
 
   * <b>Note:</b>If the normalization mode is changed while iterating
611
 
   * over a string, calls to {@link #next() } and {@link #previous() } may
612
 
   * return previously buffers characters in the old normalization mode
613
 
   * until the iteration is able to re-sync at the next base character.
614
 
   * It is safest to call {@link #setIndexOnly }, {@link #reset() },
615
 
   * {@link #setText }, {@link #first() },
616
 
   * {@link #last() }, etc. after calling <code>setMode</code>.
617
 
   * <p>
618
 
   * @param newMode the new mode for this <code>Normalizer</code>.
619
 
   * @see #getUMode
620
 
   * @stable ICU 2.0
621
 
   */
622
 
  void setMode(UNormalizationMode newMode);
623
 
 
624
 
  /**
625
 
   * Return the normalization mode for this object.
626
 
   *
627
 
   * This is an unusual name because there used to be a getMode() that
628
 
   * returned a different type.
629
 
   *
630
 
   * @return the mode for this <code>Normalizer</code>
631
 
   * @see #setMode
632
 
   * @stable ICU 2.0
633
 
   */
634
 
  UNormalizationMode getUMode(void) const;
635
 
 
636
 
  /**
637
 
   * Set options that affect this <code>Normalizer</code>'s operation.
638
 
   * Options do not change the basic composition or decomposition operation
639
 
   * that is being performed, but they control whether
640
 
   * certain optional portions of the operation are done.
641
 
   * Currently the only available option is obsolete.
642
 
   *
643
 
   * It is possible to specify multiple options that are all turned on or off.
644
 
   *
645
 
   * @param   option  the option(s) whose value is/are to be set.
646
 
   * @param   value   the new setting for the option.  Use <code>TRUE</code> to
647
 
   *                  turn the option(s) on and <code>FALSE</code> to turn it/them off.
648
 
   *
649
 
   * @see #getOption
650
 
   * @stable ICU 2.0
651
 
   */
652
 
  void setOption(int32_t option,
653
 
         UBool value);
654
 
 
655
 
  /**
656
 
   * Determine whether an option is turned on or off.
657
 
   * If multiple options are specified, then the result is TRUE if any
658
 
   * of them are set.
659
 
   * <p>
660
 
   * @param option the option(s) that are to be checked
661
 
   * @return TRUE if any of the option(s) are set
662
 
   * @see #setOption
663
 
   * @stable ICU 2.0
664
 
   */
665
 
  UBool getOption(int32_t option) const;
666
 
 
667
 
  /**
668
 
   * Set the input text over which this <code>Normalizer</code> will iterate.
669
 
   * The iteration position is set to the beginning.
670
 
   *
671
 
   * @param newText a string that replaces the current input text
672
 
   * @param status a UErrorCode
673
 
   * @stable ICU 2.0
674
 
   */
675
 
  void setText(const UnicodeString& newText,
676
 
           UErrorCode &status);
677
 
 
678
 
  /**
679
 
   * Set the input text over which this <code>Normalizer</code> will iterate.
680
 
   * The iteration position is set to the beginning.
681
 
   *
682
 
   * @param newText a CharacterIterator object that replaces the current input text
683
 
   * @param status a UErrorCode
684
 
   * @stable ICU 2.0
685
 
   */
686
 
  void setText(const CharacterIterator& newText,
687
 
           UErrorCode &status);
688
 
 
689
 
  /**
690
 
   * Set the input text over which this <code>Normalizer</code> will iterate.
691
 
   * The iteration position is set to the beginning.
692
 
   *
693
 
   * @param newText a string that replaces the current input text
694
 
   * @param length the length of the string, or -1 if NUL-terminated
695
 
   * @param status a UErrorCode
696
 
   * @stable ICU 2.0
697
 
   */
698
 
  void setText(const UChar* newText,
699
 
                    int32_t length,
700
 
            UErrorCode &status);
701
 
  /**
702
 
   * Copies the input text into the UnicodeString argument.
703
 
   *
704
 
   * @param result Receives a copy of the text under iteration.
705
 
   * @stable ICU 2.0
706
 
   */
707
 
  void            getText(UnicodeString&  result);
708
 
 
709
 
  /**
710
 
   * ICU "poor man's RTTI", returns a UClassID for this class.
711
 
   * @returns a UClassID for this class.
712
 
   * @stable ICU 2.2
713
 
   */
714
 
  static UClassID U_EXPORT2 getStaticClassID();
715
 
 
716
 
  /**
717
 
   * ICU "poor man's RTTI", returns a UClassID for the actual class.
718
 
   * @return a UClassID for the actual class.
719
 
   * @stable ICU 2.2
720
 
   */
721
 
  virtual UClassID getDynamicClassID() const;
722
 
 
723
 
private:
724
 
  //-------------------------------------------------------------------------
725
 
  // Private functions
726
 
  //-------------------------------------------------------------------------
727
 
 
728
 
  Normalizer(); // default constructor not implemented
729
 
  Normalizer &operator=(const Normalizer &that); // assignment operator not implemented
730
 
 
731
 
  // Private utility methods for iteration
732
 
  // For documentation, see the source code
733
 
  UBool nextNormalize();
734
 
  UBool previousNormalize();
735
 
 
736
 
  void    init();
737
 
  void    clearBuffer(void);
738
 
 
739
 
  //-------------------------------------------------------------------------
740
 
  // Private data
741
 
  //-------------------------------------------------------------------------
742
 
 
743
 
  FilteredNormalizer2*fFilteredNorm2;  // owned if not NULL
744
 
  const Normalizer2  *fNorm2;  // not owned; may be equal to fFilteredNorm2
745
 
  UNormalizationMode  fUMode;
746
 
  int32_t             fOptions;
747
 
 
748
 
  // The input text and our position in it
749
 
  CharacterIterator  *text;
750
 
 
751
 
  // The normalization buffer is the result of normalization
752
 
  // of the source in [currentIndex..nextIndex[ .
753
 
  int32_t         currentIndex, nextIndex;
754
 
 
755
 
  // A buffer for holding intermediate results
756
 
  UnicodeString       buffer;
757
 
  int32_t         bufferPos;
758
 
};
759
 
 
760
 
//-------------------------------------------------------------------------
761
 
// Inline implementations
762
 
//-------------------------------------------------------------------------
763
 
 
764
 
inline UBool
765
 
Normalizer::operator!= (const Normalizer& other) const
766
 
{ return ! operator==(other); }
767
 
 
768
 
inline UNormalizationCheckResult
769
 
Normalizer::quickCheck(const UnicodeString& source,
770
 
                       UNormalizationMode mode,
771
 
                       UErrorCode &status) {
772
 
    return quickCheck(source, mode, 0, status);
773
 
}
774
 
 
775
 
inline UBool
776
 
Normalizer::isNormalized(const UnicodeString& source,
777
 
                         UNormalizationMode mode,
778
 
                         UErrorCode &status) {
779
 
    return isNormalized(source, mode, 0, status);
780
 
}
781
 
 
782
 
inline int32_t
783
 
Normalizer::compare(const UnicodeString &s1, const UnicodeString &s2,
784
 
                    uint32_t options,
785
 
                    UErrorCode &errorCode) {
786
 
  // all argument checking is done in unorm_compare
787
 
  return unorm_compare(s1.getBuffer(), s1.length(),
788
 
                       s2.getBuffer(), s2.length(),
789
 
                       options,
790
 
                       &errorCode);
791
 
}
792
 
 
793
 
U_NAMESPACE_END
794
 
 
795
 
#endif /* #if !UCONFIG_NO_NORMALIZATION */
796
 
 
797
 
#endif // NORMLZR_H