← 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/chariter.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/chariter.h
1
 
/*
2
 
********************************************************************
3
 
*
4
 
*   Copyright (C) 1997-2005, International Business Machines
5
 
*   Corporation and others.  All Rights Reserved.
6
 
*
7
 
********************************************************************
8
 
*/
9
 
 
10
 
#ifndef CHARITER_H
11
 
#define CHARITER_H
12
 
 
13
 
#include "unicode/utypes.h"
14
 
#include "unicode/uobject.h"
15
 
#include "unicode/unistr.h"
16
 
/**
17
 
 * \file
18
 
 * \brief C++ API: Character Iterator
19
 
 */
20
 
 
21
 
U_NAMESPACE_BEGIN
22
 
/**
23
 
 * Abstract class that defines an API for forward-only iteration
24
 
 * on text objects.
25
 
 * This is a minimal interface for iteration without random access
26
 
 * or backwards iteration. It is especially useful for wrapping
27
 
 * streams with converters into an object for collation or
28
 
 * normalization.
29
 
 *
30
 
 * <p>Characters can be accessed in two ways: as code units or as
31
 
 * code points.
32
 
 * Unicode code points are 21-bit integers and are the scalar values
33
 
 * of Unicode characters. ICU uses the type UChar32 for them.
34
 
 * Unicode code units are the storage units of a given
35
 
 * Unicode/UCS Transformation Format (a character encoding scheme).
36
 
 * With UTF-16, all code points can be represented with either one
37
 
 * or two code units ("surrogates").
38
 
 * String storage is typically based on code units, while properties
39
 
 * of characters are typically determined using code point values.
40
 
 * Some processes may be designed to work with sequences of code units,
41
 
 * or it may be known that all characters that are important to an
42
 
 * algorithm can be represented with single code units.
43
 
 * Other processes will need to use the code point access functions.</p>
44
 
 *
45
 
 * <p>ForwardCharacterIterator provides nextPostInc() to access
46
 
 * a code unit and advance an internal position into the text object,
47
 
 * similar to a <code>return text[position++]</code>.<br>
48
 
 * It provides next32PostInc() to access a code point and advance an internal
49
 
 * position.</p>
50
 
 *
51
 
 * <p>next32PostInc() assumes that the current position is that of
52
 
 * the beginning of a code point, i.e., of its first code unit.
53
 
 * After next32PostInc(), this will be true again.
54
 
 * In general, access to code units and code points in the same
55
 
 * iteration loop should not be mixed. In UTF-16, if the current position
56
 
 * is on a second code unit (Low Surrogate), then only that code unit
57
 
 * is returned even by next32PostInc().</p>
58
 
 *
59
 
 * <p>For iteration with either function, there are two ways to
60
 
 * check for the end of the iteration. When there are no more
61
 
 * characters in the text object:
62
 
 * <ul>
63
 
 * <li>The hasNext() function returns FALSE.</li>
64
 
 * <li>nextPostInc() and next32PostInc() return DONE
65
 
 *     when one attempts to read beyond the end of the text object.</li>
66
 
 * </ul>
67
 
 *
68
 
 * Example:
69
 
 * \code 
70
 
 * void function1(ForwardCharacterIterator &it) {
71
 
 *     UChar32 c;
72
 
 *     while(it.hasNext()) {
73
 
 *         c=it.next32PostInc();
74
 
 *         // use c
75
 
 *     }
76
 
 * }
77
 
 *
78
 
 * void function1(ForwardCharacterIterator &it) {
79
 
 *     UChar c;
80
 
 *     while((c=it.nextPostInc())!=ForwardCharacterIterator::DONE) {
81
 
 *         // use c
82
 
 *      }
83
 
 *  }
84
 
 * \endcode
85
 
 * </p>
86
 
 *
87
 
 * @stable ICU 2.0
88
 
 */
89
 
class U_COMMON_API ForwardCharacterIterator : public UObject {
90
 
public:
91
 
    /**
92
 
     * Value returned by most of ForwardCharacterIterator's functions
93
 
     * when the iterator has reached the limits of its iteration.
94
 
     * @stable ICU 2.0
95
 
     */
96
 
    enum { DONE = 0xffff };
97
 
    
98
 
    /**
99
 
     * Destructor.  
100
 
     * @stable ICU 2.0
101
 
     */
102
 
    virtual ~ForwardCharacterIterator();
103
 
    
104
 
    /**
105
 
     * Returns true when both iterators refer to the same
106
 
     * character in the same character-storage object.  
107
 
     * @param that The ForwardCharacterIterator to be compared for equality
108
 
     * @return true when both iterators refer to the same
109
 
     * character in the same character-storage object
110
 
     * @stable ICU 2.0
111
 
     */
112
 
    virtual UBool operator==(const ForwardCharacterIterator& that) const = 0;
113
 
    
114
 
    /**
115
 
     * Returns true when the iterators refer to different
116
 
     * text-storage objects, or to different characters in the
117
 
     * same text-storage object.  
118
 
     * @param that The ForwardCharacterIterator to be compared for inequality
119
 
     * @return true when the iterators refer to different
120
 
     * text-storage objects, or to different characters in the
121
 
     * same text-storage object
122
 
     * @stable ICU 2.0
123
 
     */
124
 
    inline UBool operator!=(const ForwardCharacterIterator& that) const;
125
 
    
126
 
    /**
127
 
     * Generates a hash code for this iterator.  
128
 
     * @return the hash code.
129
 
     * @stable ICU 2.0
130
 
     */
131
 
    virtual int32_t hashCode(void) const = 0;
132
 
    
133
 
    /**
134
 
     * Returns a UClassID for this ForwardCharacterIterator ("poor man's
135
 
     * RTTI").<P> Despite the fact that this function is public,
136
 
     * DO NOT CONSIDER IT PART OF CHARACTERITERATOR'S API! 
137
 
     * @return a UClassID for this ForwardCharacterIterator 
138
 
     * @stable ICU 2.0
139
 
     */
140
 
    virtual UClassID getDynamicClassID(void) const = 0;
141
 
    
142
 
    /**
143
 
     * Gets the current code unit for returning and advances to the next code unit
144
 
     * in the iteration range
145
 
     * (toward endIndex()).  If there are
146
 
     * no more code units to return, returns DONE.
147
 
     * @return the current code unit.
148
 
     * @stable ICU 2.0
149
 
     */
150
 
    virtual UChar         nextPostInc(void) = 0;
151
 
    
152
 
    /**
153
 
     * Gets the current code point for returning and advances to the next code point
154
 
     * in the iteration range
155
 
     * (toward endIndex()).  If there are
156
 
     * no more code points to return, returns DONE.
157
 
     * @return the current code point.
158
 
     * @stable ICU 2.0
159
 
     */
160
 
    virtual UChar32       next32PostInc(void) = 0;
161
 
    
162
 
    /**
163
 
     * Returns FALSE if there are no more code units or code points
164
 
     * at or after the current position in the iteration range.
165
 
     * This is used with nextPostInc() or next32PostInc() in forward
166
 
     * iteration.
167
 
     * @returns FALSE if there are no more code units or code points
168
 
     * at or after the current position in the iteration range.
169
 
     * @stable ICU 2.0
170
 
     */
171
 
    virtual UBool        hasNext() = 0;
172
 
    
173
 
protected:
174
 
    /** Default constructor to be overridden in the implementing class. @stable ICU 2.0*/
175
 
    ForwardCharacterIterator();
176
 
    
177
 
    /** Copy constructor to be overridden in the implementing class. @stable ICU 2.0*/
178
 
    ForwardCharacterIterator(const ForwardCharacterIterator &other);
179
 
    
180
 
    /**
181
 
     * Assignment operator to be overridden in the implementing class.
182
 
     * @stable ICU 2.0
183
 
     */
184
 
    ForwardCharacterIterator &operator=(const ForwardCharacterIterator&) { return *this; }
185
 
};
186
 
 
187
 
/**
188
 
 * Abstract class that defines an API for iteration
189
 
 * on text objects.
190
 
 * This is an interface for forward and backward iteration
191
 
 * and random access into a text object.
192
 
 *
193
 
 * <p>The API provides backward compatibility to the Java and older ICU
194
 
 * CharacterIterator classes but extends them significantly:
195
 
 * <ol>
196
 
 * <li>CharacterIterator is now a subclass of ForwardCharacterIterator.</li>
197
 
 * <li>While the old API functions provided forward iteration with
198
 
 *     "pre-increment" semantics, the new one also provides functions
199
 
 *     with "post-increment" semantics. They are more efficient and should
200
 
 *     be the preferred iterator functions for new implementations.
201
 
 *     The backward iteration always had "pre-decrement" semantics, which
202
 
 *     are efficient.</li>
203
 
 * <li>Just like ForwardCharacterIterator, it provides access to
204
 
 *     both code units and code points. Code point access versions are available
205
 
 *     for the old and the new iteration semantics.</li>
206
 
 * <li>There are new functions for setting and moving the current position
207
 
 *     without returning a character, for efficiency.</li>
208
 
 * </ol>
209
 
 *
210
 
 * See ForwardCharacterIterator for examples for using the new forward iteration
211
 
 * functions. For backward iteration, there is also a hasPrevious() function
212
 
 * that can be used analogously to hasNext().
213
 
 * The old functions work as before and are shown below.</p>
214
 
 *
215
 
 * <p>Examples for some of the new functions:</p>
216
 
 *
217
 
 * Forward iteration with hasNext():
218
 
 * \code
219
 
 * void forward1(CharacterIterator &it) {
220
 
 *     UChar32 c;
221
 
 *     for(it.setToStart(); it.hasNext();) {
222
 
 *         c=it.next32PostInc();
223
 
 *         // use c
224
 
 *     }
225
 
 *  }
226
 
 * \endcode
227
 
 * Forward iteration more similar to loops with the old forward iteration,
228
 
 * showing a way to convert simple for() loops:
229
 
 * \code
230
 
 * void forward2(CharacterIterator &it) {
231
 
 *     UChar c;
232
 
 *     for(c=it.firstPostInc(); c!=CharacterIterator::DONE; c=it.nextPostInc()) {
233
 
 *          // use c
234
 
 *      }
235
 
 * }
236
 
 * \endcode
237
 
 * Backward iteration with setToEnd() and hasPrevious():
238
 
 * \code
239
 
 *  void backward1(CharacterIterator &it) {
240
 
 *      UChar32 c;
241
 
 *      for(it.setToEnd(); it.hasPrevious();) {
242
 
 *         c=it.previous32();
243
 
 *          // use c
244
 
 *      }
245
 
 *  }
246
 
 * \endcode
247
 
 * Backward iteration with a more traditional for() loop:
248
 
 * \code
249
 
 * void backward2(CharacterIterator &it) {
250
 
 *     UChar c;
251
 
 *     for(c=it.last(); c!=CharacterIterator::DONE; c=it.previous()) {
252
 
 *         // use c
253
 
 *      }
254
 
 *  }
255
 
 * \endcode
256
 
 *
257
 
 * Example for random access:
258
 
 * \code
259
 
 *  void random(CharacterIterator &it) {
260
 
 *      // set to the third code point from the beginning
261
 
 *      it.move32(3, CharacterIterator::kStart);
262
 
 *      // get a code point from here without moving the position
263
 
 *      UChar32 c=it.current32();
264
 
 *      // get the position
265
 
 *      int32_t pos=it.getIndex();
266
 
 *      // get the previous code unit
267
 
 *      UChar u=it.previous();
268
 
 *      // move back one more code unit
269
 
 *      it.move(-1, CharacterIterator::kCurrent);
270
 
 *      // set the position back to where it was
271
 
 *      // and read the same code point c and move beyond it
272
 
 *      it.setIndex(pos);
273
 
 *      if(c!=it.next32PostInc()) {
274
 
 *          exit(1); // CharacterIterator inconsistent
275
 
 *      }
276
 
 *  }
277
 
 * \endcode
278
 
 *
279
 
 * <p>Examples, especially for the old API:</p>
280
 
 *
281
 
 * Function processing characters, in this example simple output
282
 
 * <pre>
283
 
 * \code
284
 
 *  void processChar( UChar c )
285
 
 *  {
286
 
 *      cout << " " << c;
287
 
 *  }
288
 
 * \endcode
289
 
 * </pre>
290
 
 * Traverse the text from start to finish
291
 
 * <pre> 
292
 
 * \code
293
 
 *  void traverseForward(CharacterIterator& iter)
294
 
 *  {
295
 
 *      for(UChar c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
296
 
 *          processChar(c);
297
 
 *      }
298
 
 *  }
299
 
 * \endcode
300
 
 * </pre>
301
 
 * Traverse the text backwards, from end to start
302
 
 * <pre>
303
 
 * \code
304
 
 *  void traverseBackward(CharacterIterator& iter)
305
 
 *  {
306
 
 *      for(UChar c = iter.last(); c != CharacterIterator.DONE; c = iter.previous()) {
307
 
 *          processChar(c);
308
 
 *      }
309
 
 *  }
310
 
 * \endcode
311
 
 * </pre>
312
 
 * Traverse both forward and backward from a given position in the text. 
313
 
 * Calls to notBoundary() in this example represents some additional stopping criteria.
314
 
 * <pre>
315
 
 * \code
316
 
 * void traverseOut(CharacterIterator& iter, int32_t pos)
317
 
 * {
318
 
 *      UChar c;
319
 
 *      for (c = iter.setIndex(pos);
320
 
 *      c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
321
 
 *          c = iter.next()) {}
322
 
 *      int32_t end = iter.getIndex();
323
 
 *      for (c = iter.setIndex(pos);
324
 
 *          c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
325
 
 *          c = iter.previous()) {}
326
 
 *      int32_t start = iter.getIndex() + 1;
327
 
 *  
328
 
 *      cout << "start: " << start << " end: " << end << endl;
329
 
 *      for (c = iter.setIndex(start); iter.getIndex() < end; c = iter.next() ) {
330
 
 *          processChar(c);
331
 
 *     }
332
 
 *  }
333
 
 * \endcode
334
 
 * </pre>
335
 
 * Creating a StringCharacterIterator and calling the test functions
336
 
 * <pre>
337
 
 * \code
338
 
 *  void CharacterIterator_Example( void )
339
 
 *   {
340
 
 *       cout << endl << "===== CharacterIterator_Example: =====" << endl;
341
 
 *       UnicodeString text("Ein kleiner Satz.");
342
 
 *       StringCharacterIterator iterator(text);
343
 
 *       cout << "----- traverseForward: -----------" << endl;
344
 
 *       traverseForward( iterator );
345
 
 *       cout << endl << endl << "----- traverseBackward: ----------" << endl;
346
 
 *       traverseBackward( iterator );
347
 
 *       cout << endl << endl << "----- traverseOut: ---------------" << endl;
348
 
 *       traverseOut( iterator, 7 );
349
 
 *       cout << endl << endl << "-----" << endl;
350
 
 *   }
351
 
 * \endcode
352
 
 * </pre>
353
 
 *
354
 
 * @stable ICU 2.0
355
 
 */
356
 
class U_COMMON_API CharacterIterator : public ForwardCharacterIterator {
357
 
public:
358
 
    /**
359
 
     * Origin enumeration for the move() and move32() functions.
360
 
     * @stable ICU 2.0
361
 
     */
362
 
    enum EOrigin { kStart, kCurrent, kEnd };
363
 
 
364
 
    /**
365
 
     * Returns a pointer to a new CharacterIterator of the same
366
 
     * concrete class as this one, and referring to the same
367
 
     * character in the same text-storage object as this one.  The
368
 
     * caller is responsible for deleting the new clone.  
369
 
     * @return a pointer to a new CharacterIterator
370
 
     * @stable ICU 2.0
371
 
     */
372
 
    virtual CharacterIterator* clone(void) const = 0;
373
 
 
374
 
    /**
375
 
     * Sets the iterator to refer to the first code unit in its
376
 
     * iteration range, and returns that code unit.
377
 
     * This can be used to begin an iteration with next().
378
 
     * @return the first code unit in its iteration range.
379
 
     * @stable ICU 2.0
380
 
     */
381
 
    virtual UChar         first(void) = 0;
382
 
 
383
 
    /**
384
 
     * Sets the iterator to refer to the first code unit in its
385
 
     * iteration range, returns that code unit, and moves the position
386
 
     * to the second code unit. This is an alternative to setToStart()
387
 
     * for forward iteration with nextPostInc().
388
 
     * @return the first code unit in its iteration range.
389
 
     * @stable ICU 2.0
390
 
     */
391
 
    virtual UChar         firstPostInc(void);
392
 
 
393
 
    /**
394
 
     * Sets the iterator to refer to the first code point in its
395
 
     * iteration range, and returns that code unit,
396
 
     * This can be used to begin an iteration with next32().
397
 
     * Note that an iteration with next32PostInc(), beginning with,
398
 
     * e.g., setToStart() or firstPostInc(), is more efficient.
399
 
     * @return the first code point in its iteration range.
400
 
     * @stable ICU 2.0
401
 
     */
402
 
    virtual UChar32       first32(void) = 0;
403
 
 
404
 
    /**
405
 
     * Sets the iterator to refer to the first code point in its
406
 
     * iteration range, returns that code point, and moves the position
407
 
     * to the second code point. This is an alternative to setToStart()
408
 
     * for forward iteration with next32PostInc().
409
 
     * @return the first code point in its iteration range.
410
 
     * @stable ICU 2.0
411
 
     */
412
 
    virtual UChar32       first32PostInc(void);
413
 
 
414
 
    /**
415
 
     * Sets the iterator to refer to the first code unit or code point in its
416
 
     * iteration range. This can be used to begin a forward
417
 
     * iteration with nextPostInc() or next32PostInc().
418
 
     * @return the start position of the iteration range
419
 
     * @stable ICU 2.0
420
 
     */
421
 
    inline int32_t    setToStart();
422
 
 
423
 
    /**
424
 
     * Sets the iterator to refer to the last code unit in its
425
 
     * iteration range, and returns that code unit.
426
 
     * This can be used to begin an iteration with previous().
427
 
     * @return the last code unit.
428
 
     * @stable ICU 2.0
429
 
     */
430
 
    virtual UChar         last(void) = 0;
431
 
        
432
 
    /**
433
 
     * Sets the iterator to refer to the last code point in its
434
 
     * iteration range, and returns that code unit.
435
 
     * This can be used to begin an iteration with previous32().
436
 
     * @return the last code point.
437
 
     * @stable ICU 2.0
438
 
     */
439
 
    virtual UChar32       last32(void) = 0;
440
 
 
441
 
    /**
442
 
     * Sets the iterator to the end of its iteration range, just behind
443
 
     * the last code unit or code point. This can be used to begin a backward
444
 
     * iteration with previous() or previous32().
445
 
     * @return the end position of the iteration range
446
 
     * @stable ICU 2.0
447
 
     */
448
 
    inline int32_t    setToEnd();
449
 
 
450
 
    /**
451
 
     * Sets the iterator to refer to the "position"-th code unit
452
 
     * in the text-storage object the iterator refers to, and
453
 
     * returns that code unit.  
454
 
     * @param position the "position"-th code unit in the text-storage object
455
 
     * @return the "position"-th code unit.
456
 
     * @stable ICU 2.0
457
 
     */
458
 
    virtual UChar         setIndex(int32_t position) = 0;
459
 
 
460
 
    /**
461
 
     * Sets the iterator to refer to the beginning of the code point
462
 
     * that contains the "position"-th code unit
463
 
     * in the text-storage object the iterator refers to, and
464
 
     * returns that code point.
465
 
     * The current position is adjusted to the beginning of the code point
466
 
     * (its first code unit).
467
 
     * @param position the "position"-th code unit in the text-storage object
468
 
     * @return the "position"-th code point.
469
 
     * @stable ICU 2.0
470
 
     */
471
 
    virtual UChar32       setIndex32(int32_t position) = 0;
472
 
 
473
 
    /**
474
 
     * Returns the code unit the iterator currently refers to. 
475
 
     * @return the current code unit. 
476
 
     * @stable ICU 2.0
477
 
     */
478
 
    virtual UChar         current(void) const = 0;
479
 
        
480
 
    /**
481
 
     * Returns the code point the iterator currently refers to.  
482
 
     * @return the current code point.
483
 
     * @stable ICU 2.0
484
 
     */
485
 
    virtual UChar32       current32(void) const = 0;
486
 
        
487
 
    /**
488
 
     * Advances to the next code unit in the iteration range
489
 
     * (toward endIndex()), and returns that code unit.  If there are
490
 
     * no more code units to return, returns DONE.
491
 
     * @return the next code unit.
492
 
     * @stable ICU 2.0
493
 
     */
494
 
    virtual UChar         next(void) = 0;
495
 
        
496
 
    /**
497
 
     * Advances to the next code point in the iteration range
498
 
     * (toward endIndex()), and returns that code point.  If there are
499
 
     * no more code points to return, returns DONE.
500
 
     * Note that iteration with "pre-increment" semantics is less
501
 
     * efficient than iteration with "post-increment" semantics
502
 
     * that is provided by next32PostInc().
503
 
     * @return the next code point.
504
 
     * @stable ICU 2.0
505
 
     */
506
 
    virtual UChar32       next32(void) = 0;
507
 
        
508
 
    /**
509
 
     * Advances to the previous code unit in the iteration range
510
 
     * (toward startIndex()), and returns that code unit.  If there are
511
 
     * no more code units to return, returns DONE.  
512
 
     * @return the previous code unit.
513
 
     * @stable ICU 2.0
514
 
     */
515
 
    virtual UChar         previous(void) = 0;
516
 
 
517
 
    /**
518
 
     * Advances to the previous code point in the iteration range
519
 
     * (toward startIndex()), and returns that code point.  If there are
520
 
     * no more code points to return, returns DONE. 
521
 
     * @return the previous code point. 
522
 
     * @stable ICU 2.0
523
 
     */
524
 
    virtual UChar32       previous32(void) = 0;
525
 
 
526
 
    /**
527
 
     * Returns FALSE if there are no more code units or code points
528
 
     * before the current position in the iteration range.
529
 
     * This is used with previous() or previous32() in backward
530
 
     * iteration.
531
 
     * @return FALSE if there are no more code units or code points
532
 
     * before the current position in the iteration range, return TRUE otherwise.
533
 
     * @stable ICU 2.0
534
 
     */
535
 
    virtual UBool        hasPrevious() = 0;
536
 
 
537
 
    /**
538
 
     * Returns the numeric index in the underlying text-storage
539
 
     * object of the character returned by first().  Since it's
540
 
     * possible to create an iterator that iterates across only
541
 
     * part of a text-storage object, this number isn't
542
 
     * necessarily 0.  
543
 
     * @returns the numeric index in the underlying text-storage
544
 
     * object of the character returned by first().
545
 
     * @stable ICU 2.0
546
 
     */
547
 
    inline int32_t       startIndex(void) const;
548
 
        
549
 
    /**
550
 
     * Returns the numeric index in the underlying text-storage
551
 
     * object of the position immediately BEYOND the character
552
 
     * returned by last().  
553
 
     * @return the numeric index in the underlying text-storage
554
 
     * object of the position immediately BEYOND the character
555
 
     * returned by last().
556
 
     * @stable ICU 2.0
557
 
     */
558
 
    inline int32_t       endIndex(void) const;
559
 
        
560
 
    /**
561
 
     * Returns the numeric index in the underlying text-storage
562
 
     * object of the character the iterator currently refers to
563
 
     * (i.e., the character returned by current()).  
564
 
     * @return the numberic index in the text-storage object of 
565
 
     * the character the iterator currently refers to
566
 
     * @stable ICU 2.0
567
 
     */
568
 
    inline int32_t       getIndex(void) const;
569
 
 
570
 
    /**
571
 
     * Returns the length of the entire text in the underlying
572
 
     * text-storage object.
573
 
     * @return the length of the entire text in the text-storage object
574
 
     * @stable ICU 2.0
575
 
     */
576
 
    inline int32_t           getLength() const;
577
 
 
578
 
    /**
579
 
     * Moves the current position relative to the start or end of the
580
 
     * iteration range, or relative to the current position itself.
581
 
     * The movement is expressed in numbers of code units forward
582
 
     * or backward by specifying a positive or negative delta.
583
 
     * @param delta the position relative to origin. A positive delta means forward;
584
 
     * a negative delta means backward.
585
 
     * @param origin Origin enumeration {kStart, kCurrent, kEnd}
586
 
     * @return the new position
587
 
     * @stable ICU 2.0
588
 
     */
589
 
    virtual int32_t      move(int32_t delta, EOrigin origin) = 0;
590
 
 
591
 
    /**
592
 
     * Moves the current position relative to the start or end of the
593
 
     * iteration range, or relative to the current position itself.
594
 
     * The movement is expressed in numbers of code points forward
595
 
     * or backward by specifying a positive or negative delta.
596
 
     * @param delta the position relative to origin. A positive delta means forward;
597
 
     * a negative delta means backward.
598
 
     * @param origin Origin enumeration {kStart, kCurrent, kEnd}
599
 
     * @return the new position
600
 
     * @stable ICU 2.0
601
 
     */
602
 
    virtual int32_t      move32(int32_t delta, EOrigin origin) = 0;
603
 
 
604
 
    /**
605
 
     * Copies the text under iteration into the UnicodeString
606
 
     * referred to by "result".  
607
 
     * @param result Receives a copy of the text under iteration.  
608
 
     * @stable ICU 2.0
609
 
     */
610
 
    virtual void            getText(UnicodeString&  result) = 0;
611
 
 
612
 
protected:
613
 
    /**
614
 
     * Empty constructor.
615
 
     * @stable ICU 2.0
616
 
     */
617
 
    CharacterIterator();
618
 
 
619
 
    /**
620
 
     * Constructor, just setting the length field in this base class.
621
 
     * @stable ICU 2.0
622
 
     */
623
 
    CharacterIterator(int32_t length);
624
 
 
625
 
    /**
626
 
     * Constructor, just setting the length and position fields in this base class.
627
 
     * @stable ICU 2.0
628
 
     */
629
 
    CharacterIterator(int32_t length, int32_t position);
630
 
 
631
 
    /**
632
 
     * Constructor, just setting the length, start, end, and position fields in this base class.
633
 
     * @stable ICU 2.0
634
 
     */
635
 
    CharacterIterator(int32_t length, int32_t textBegin, int32_t textEnd, int32_t position);
636
 
  
637
 
    /**
638
 
     * Copy constructor.
639
 
     *
640
 
     * @param that The CharacterIterator to be copied
641
 
     * @stable ICU 2.0
642
 
     */
643
 
    CharacterIterator(const CharacterIterator &that);
644
 
 
645
 
    /**
646
 
     * Assignment operator.  Sets this CharacterIterator to have the same behavior,
647
 
     * as the one passed in.
648
 
     * @param that The CharacterIterator passed in.
649
 
     * @return the newly set CharacterIterator.
650
 
     * @stable ICU 2.0
651
 
     */
652
 
    CharacterIterator &operator=(const CharacterIterator &that);
653
 
 
654
 
    /**
655
 
     * Base class text length field.
656
 
     * Necessary this for correct getText() and hashCode().
657
 
     * @stable ICU 2.0
658
 
     */
659
 
    int32_t textLength;
660
 
 
661
 
    /**
662
 
     * Base class field for the current position.
663
 
     * @stable ICU 2.0
664
 
     */
665
 
    int32_t  pos;
666
 
 
667
 
    /**
668
 
     * Base class field for the start of the iteration range.
669
 
     * @stable ICU 2.0
670
 
     */
671
 
    int32_t  begin;
672
 
 
673
 
    /**
674
 
     * Base class field for the end of the iteration range.
675
 
     * @stable ICU 2.0
676
 
     */
677
 
    int32_t  end;
678
 
};
679
 
 
680
 
inline UBool
681
 
ForwardCharacterIterator::operator!=(const ForwardCharacterIterator& that) const {
682
 
    return !operator==(that);
683
 
}
684
 
 
685
 
inline int32_t
686
 
CharacterIterator::setToStart() {
687
 
    return move(0, kStart);
688
 
}
689
 
 
690
 
inline int32_t
691
 
CharacterIterator::setToEnd() {
692
 
    return move(0, kEnd);
693
 
}
694
 
 
695
 
inline int32_t
696
 
CharacterIterator::startIndex(void) const {
697
 
    return begin;
698
 
}
699
 
 
700
 
inline int32_t
701
 
CharacterIterator::endIndex(void) const {
702
 
    return end;
703
 
}
704
 
 
705
 
inline int32_t
706
 
CharacterIterator::getIndex(void) const {
707
 
    return pos;
708
 
}
709
 
 
710
 
inline int32_t
711
 
CharacterIterator::getLength(void) const {
712
 
    return textLength;
713
 
}
714
 
 
715
 
U_NAMESPACE_END
716
 
#endif