Home | History | Annotate | Download | only in unicode
      1 /*
      2 *******************************************************************************
      3 *
      4 *   Copyright (C) 2002-2011 International Business Machines
      5 *   Corporation and others.  All Rights Reserved.
      6 *
      7 *******************************************************************************
      8 *   file name:  uiter.h
      9 *   encoding:   US-ASCII
     10 *   tab size:   8 (not used)
     11 *   indentation:4
     12 *
     13 *   created on: 2002jan18
     14 *   created by: Markus W. Scherer
     15 */
     16 
     17 #ifndef __UITER_H__
     18 #define __UITER_H__
     19 
     20 /**
     21  * \file
     22  * \brief C API: Unicode Character Iteration
     23  *
     24  * @see UCharIterator
     25  */
     26 
     27 #include "unicode/utypes.h"
     28 
     29 #if U_SHOW_CPLUSPLUS_API
     30     U_NAMESPACE_BEGIN
     31 
     32     class CharacterIterator;
     33     class Replaceable;
     34 
     35     U_NAMESPACE_END
     36 #endif
     37 
     38 U_CDECL_BEGIN
     39 
     40 struct UCharIterator;
     41 typedef struct UCharIterator UCharIterator; /**< C typedef for struct UCharIterator. @stable ICU 2.1 */
     42 
     43 /**
     44  * Origin constants for UCharIterator.getIndex() and UCharIterator.move().
     45  * @see UCharIteratorMove
     46  * @see UCharIterator
     47  * @stable ICU 2.1
     48  */
     49 typedef enum UCharIteratorOrigin {
     50     UITER_START, UITER_CURRENT, UITER_LIMIT, UITER_ZERO, UITER_LENGTH
     51 } UCharIteratorOrigin;
     52 
     53 /** Constants for UCharIterator. @stable ICU 2.6 */
     54 enum {
     55     /**
     56      * Constant value that may be returned by UCharIteratorMove
     57      * indicating that the final UTF-16 index is not known, but that the move succeeded.
     58      * This can occur when moving relative to limit or length, or
     59      * when moving relative to the current index after a setState()
     60      * when the current UTF-16 index is not known.
     61      *
     62      * It would be very inefficient to have to count from the beginning of the text
     63      * just to get the current/limit/length index after moving relative to it.
     64      * The actual index can be determined with getIndex(UITER_CURRENT)
     65      * which will count the UChars if necessary.
     66      *
     67      * @stable ICU 2.6
     68      */
     69     UITER_UNKNOWN_INDEX=-2
     70 };
     71 
     72 
     73 /**
     74  * Constant for UCharIterator getState() indicating an error or
     75  * an unknown state.
     76  * Returned by uiter_getState()/UCharIteratorGetState
     77  * when an error occurs.
     78  * Also, some UCharIterator implementations may not be able to return
     79  * a valid state for each position. This will be clearly documented
     80  * for each such iterator (none of the public ones here).
     81  *
     82  * @stable ICU 2.6
     83  */
     84 #define UITER_NO_STATE ((uint32_t)0xffffffff)
     85 
     86 /**
     87  * Function type declaration for UCharIterator.getIndex().
     88  *
     89  * Gets the current position, or the start or limit of the
     90  * iteration range.
     91  *
     92  * This function may perform slowly for UITER_CURRENT after setState() was called,
     93  * or for UITER_LENGTH, because an iterator implementation may have to count
     94  * UChars if the underlying storage is not UTF-16.
     95  *
     96  * @param iter the UCharIterator structure ("this pointer")
     97  * @param origin get the 0, start, limit, length, or current index
     98  * @return the requested index, or U_SENTINEL in an error condition
     99  *
    100  * @see UCharIteratorOrigin
    101  * @see UCharIterator
    102  * @stable ICU 2.1
    103  */
    104 typedef int32_t U_CALLCONV
    105 UCharIteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin);
    106 
    107 /**
    108  * Function type declaration for UCharIterator.move().
    109  *
    110  * Use iter->move(iter, index, UITER_ZERO) like CharacterIterator::setIndex(index).
    111  *
    112  * Moves the current position relative to the start or limit of the
    113  * iteration range, or relative to the current position itself.
    114  * The movement is expressed in numbers of code units forward
    115  * or backward by specifying a positive or negative delta.
    116  * Out of bounds movement will be pinned to the start or limit.
    117  *
    118  * This function may perform slowly for moving relative to UITER_LENGTH
    119  * because an iterator implementation may have to count the rest of the
    120  * UChars if the native storage is not UTF-16.
    121  *
    122  * When moving relative to the limit or length, or
    123  * relative to the current position after setState() was called,
    124  * move() may return UITER_UNKNOWN_INDEX (-2) to avoid an inefficient
    125  * determination of the actual UTF-16 index.
    126  * The actual index can be determined with getIndex(UITER_CURRENT)
    127  * which will count the UChars if necessary.
    128  * See UITER_UNKNOWN_INDEX for details.
    129  *
    130  * @param iter the UCharIterator structure ("this pointer")
    131  * @param delta can be positive, zero, or negative
    132  * @param origin move relative to the 0, start, limit, length, or current index
    133  * @return the new index, or U_SENTINEL on an error condition,
    134  *         or UITER_UNKNOWN_INDEX when the index is not known.
    135  *
    136  * @see UCharIteratorOrigin
    137  * @see UCharIterator
    138  * @see UITER_UNKNOWN_INDEX
    139  * @stable ICU 2.1
    140  */
    141 typedef int32_t U_CALLCONV
    142 UCharIteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin);
    143 
    144 /**
    145  * Function type declaration for UCharIterator.hasNext().
    146  *
    147  * Check if current() and next() can still
    148  * return another code unit.
    149  *
    150  * @param iter the UCharIterator structure ("this pointer")
    151  * @return boolean value for whether current() and next() can still return another code unit
    152  *
    153  * @see UCharIterator
    154  * @stable ICU 2.1
    155  */
    156 typedef UBool U_CALLCONV
    157 UCharIteratorHasNext(UCharIterator *iter);
    158 
    159 /**
    160  * Function type declaration for UCharIterator.hasPrevious().
    161  *
    162  * Check if previous() can still return another code unit.
    163  *
    164  * @param iter the UCharIterator structure ("this pointer")
    165  * @return boolean value for whether previous() can still return another code unit
    166  *
    167  * @see UCharIterator
    168  * @stable ICU 2.1
    169  */
    170 typedef UBool U_CALLCONV
    171 UCharIteratorHasPrevious(UCharIterator *iter);
    172 
    173 /**
    174  * Function type declaration for UCharIterator.current().
    175  *
    176  * Return the code unit at the current position,
    177  * or U_SENTINEL if there is none (index is at the limit).
    178  *
    179  * @param iter the UCharIterator structure ("this pointer")
    180  * @return the current code unit
    181  *
    182  * @see UCharIterator
    183  * @stable ICU 2.1
    184  */
    185 typedef UChar32 U_CALLCONV
    186 UCharIteratorCurrent(UCharIterator *iter);
    187 
    188 /**
    189  * Function type declaration for UCharIterator.next().
    190  *
    191  * Return the code unit at the current index and increment
    192  * the index (post-increment, like s[i++]),
    193  * or return U_SENTINEL if there is none (index is at the limit).
    194  *
    195  * @param iter the UCharIterator structure ("this pointer")
    196  * @return the current code unit (and post-increment the current index)
    197  *
    198  * @see UCharIterator
    199  * @stable ICU 2.1
    200  */
    201 typedef UChar32 U_CALLCONV
    202 UCharIteratorNext(UCharIterator *iter);
    203 
    204 /**
    205  * Function type declaration for UCharIterator.previous().
    206  *
    207  * Decrement the index and return the code unit from there
    208  * (pre-decrement, like s[--i]),
    209  * or return U_SENTINEL if there is none (index is at the start).
    210  *
    211  * @param iter the UCharIterator structure ("this pointer")
    212  * @return the previous code unit (after pre-decrementing the current index)
    213  *
    214  * @see UCharIterator
    215  * @stable ICU 2.1
    216  */
    217 typedef UChar32 U_CALLCONV
    218 UCharIteratorPrevious(UCharIterator *iter);
    219 
    220 /**
    221  * Function type declaration for UCharIterator.reservedFn().
    222  * Reserved for future use.
    223  *
    224  * @param iter the UCharIterator structure ("this pointer")
    225  * @param something some integer argument
    226  * @return some integer
    227  *
    228  * @see UCharIterator
    229  * @stable ICU 2.1
    230  */
    231 typedef int32_t U_CALLCONV
    232 UCharIteratorReserved(UCharIterator *iter, int32_t something);
    233 
    234 /**
    235  * Function type declaration for UCharIterator.getState().
    236  *
    237  * Get the "state" of the iterator in the form of a single 32-bit word.
    238  * It is recommended that the state value be calculated to be as small as
    239  * is feasible. For strings with limited lengths, fewer than 32 bits may
    240  * be sufficient.
    241  *
    242  * This is used together with setState()/UCharIteratorSetState
    243  * to save and restore the iterator position more efficiently than with
    244  * getIndex()/move().
    245  *
    246  * The iterator state is defined as a uint32_t value because it is designed
    247  * for use in ucol_nextSortKeyPart() which provides 32 bits to store the state
    248  * of the character iterator.
    249  *
    250  * With some UCharIterator implementations (e.g., UTF-8),
    251  * getting and setting the UTF-16 index with existing functions
    252  * (getIndex(UITER_CURRENT) followed by move(pos, UITER_ZERO)) is possible but
    253  * relatively slow because the iterator has to "walk" from a known index
    254  * to the requested one.
    255  * This takes more time the farther it needs to go.
    256  *
    257  * An opaque state value allows an iterator implementation to provide
    258  * an internal index (UTF-8: the source byte array index) for
    259  * fast, constant-time restoration.
    260  *
    261  * After calling setState(), a getIndex(UITER_CURRENT) may be slow because
    262  * the UTF-16 index may not be restored as well, but the iterator can deliver
    263  * the correct text contents and move relative to the current position
    264  * without performance degradation.
    265  *
    266  * Some UCharIterator implementations may not be able to return
    267  * a valid state for each position, in which case they return UITER_NO_STATE instead.
    268  * This will be clearly documented for each such iterator (none of the public ones here).
    269  *
    270  * @param iter the UCharIterator structure ("this pointer")
    271  * @return the state word
    272  *
    273  * @see UCharIterator
    274  * @see UCharIteratorSetState
    275  * @see UITER_NO_STATE
    276  * @stable ICU 2.6
    277  */
    278 typedef uint32_t U_CALLCONV
    279 UCharIteratorGetState(const UCharIterator *iter);
    280 
    281 /**
    282  * Function type declaration for UCharIterator.setState().
    283  *
    284  * Restore the "state" of the iterator using a state word from a getState() call.
    285  * The iterator object need not be the same one as for which getState() was called,
    286  * but it must be of the same type (set up using the same uiter_setXYZ function)
    287  * and it must iterate over the same string
    288  * (binary identical regardless of memory address).
    289  * For more about the state word see UCharIteratorGetState.
    290  *
    291  * After calling setState(), a getIndex(UITER_CURRENT) may be slow because
    292  * the UTF-16 index may not be restored as well, but the iterator can deliver
    293  * the correct text contents and move relative to the current position
    294  * without performance degradation.
    295  *
    296  * @param iter the UCharIterator structure ("this pointer")
    297  * @param state the state word from a getState() call
    298  *              on a same-type, same-string iterator
    299  * @param pErrorCode Must be a valid pointer to an error code value,
    300  *                   which must not indicate a failure before the function call.
    301  *
    302  * @see UCharIterator
    303  * @see UCharIteratorGetState
    304  * @stable ICU 2.6
    305  */
    306 typedef void U_CALLCONV
    307 UCharIteratorSetState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode);
    308 
    309 
    310 /**
    311  * C API for code unit iteration.
    312  * This can be used as a C wrapper around
    313  * CharacterIterator, Replaceable, or implemented using simple strings, etc.
    314  *
    315  * There are two roles for using UCharIterator:
    316  *
    317  * A "provider" sets the necessary function pointers and controls the "protected"
    318  * fields of the UCharIterator structure. A "provider" passes a UCharIterator
    319  * into C APIs that need a UCharIterator as an abstract, flexible string interface.
    320  *
    321  * Implementations of such C APIs are "callers" of UCharIterator functions;
    322  * they only use the "public" function pointers and never access the "protected"
    323  * fields directly.
    324  *
    325  * The current() and next() functions only check the current index against the
    326  * limit, and previous() only checks the current index against the start,
    327  * to see if the iterator already reached the end of the iteration range.
    328  *
    329  * The assumption - in all iterators - is that the index is moved via the API,
    330  * which means it won't go out of bounds, or the index is modified by
    331  * user code that knows enough about the iterator implementation to set valid
    332  * index values.
    333  *
    334  * UCharIterator functions return code unit values 0..0xffff,
    335  * or U_SENTINEL if the iteration bounds are reached.
    336  *
    337  * @stable ICU 2.1
    338  */
    339 struct UCharIterator {
    340     /**
    341      * (protected) Pointer to string or wrapped object or similar.
    342      * Not used by caller.
    343      * @stable ICU 2.1
    344      */
    345     const void *context;
    346 
    347     /**
    348      * (protected) Length of string or similar.
    349      * Not used by caller.
    350      * @stable ICU 2.1
    351      */
    352     int32_t length;
    353 
    354     /**
    355      * (protected) Start index or similar.
    356      * Not used by caller.
    357      * @stable ICU 2.1
    358      */
    359     int32_t start;
    360 
    361     /**
    362      * (protected) Current index or similar.
    363      * Not used by caller.
    364      * @stable ICU 2.1
    365      */
    366     int32_t index;
    367 
    368     /**
    369      * (protected) Limit index or similar.
    370      * Not used by caller.
    371      * @stable ICU 2.1
    372      */
    373     int32_t limit;
    374 
    375     /**
    376      * (protected) Used by UTF-8 iterators and possibly others.
    377      * @stable ICU 2.1
    378      */
    379     int32_t reservedField;
    380 
    381     /**
    382      * (public) Returns the current position or the
    383      * start or limit index of the iteration range.
    384      *
    385      * @see UCharIteratorGetIndex
    386      * @stable ICU 2.1
    387      */
    388     UCharIteratorGetIndex *getIndex;
    389 
    390     /**
    391      * (public) Moves the current position relative to the start or limit of the
    392      * iteration range, or relative to the current position itself.
    393      * The movement is expressed in numbers of code units forward
    394      * or backward by specifying a positive or negative delta.
    395      *
    396      * @see UCharIteratorMove
    397      * @stable ICU 2.1
    398      */
    399     UCharIteratorMove *move;
    400 
    401     /**
    402      * (public) Check if current() and next() can still
    403      * return another code unit.
    404      *
    405      * @see UCharIteratorHasNext
    406      * @stable ICU 2.1
    407      */
    408     UCharIteratorHasNext *hasNext;
    409 
    410     /**
    411      * (public) Check if previous() can still return another code unit.
    412      *
    413      * @see UCharIteratorHasPrevious
    414      * @stable ICU 2.1
    415      */
    416     UCharIteratorHasPrevious *hasPrevious;
    417 
    418     /**
    419      * (public) Return the code unit at the current position,
    420      * or U_SENTINEL if there is none (index is at the limit).
    421      *
    422      * @see UCharIteratorCurrent
    423      * @stable ICU 2.1
    424      */
    425     UCharIteratorCurrent *current;
    426 
    427     /**
    428      * (public) Return the code unit at the current index and increment
    429      * the index (post-increment, like s[i++]),
    430      * or return U_SENTINEL if there is none (index is at the limit).
    431      *
    432      * @see UCharIteratorNext
    433      * @stable ICU 2.1
    434      */
    435     UCharIteratorNext *next;
    436 
    437     /**
    438      * (public) Decrement the index and return the code unit from there
    439      * (pre-decrement, like s[--i]),
    440      * or return U_SENTINEL if there is none (index is at the start).
    441      *
    442      * @see UCharIteratorPrevious
    443      * @stable ICU 2.1
    444      */
    445     UCharIteratorPrevious *previous;
    446 
    447     /**
    448      * (public) Reserved for future use. Currently NULL.
    449      *
    450      * @see UCharIteratorReserved
    451      * @stable ICU 2.1
    452      */
    453     UCharIteratorReserved *reservedFn;
    454 
    455     /**
    456      * (public) Return the state of the iterator, to be restored later with setState().
    457      * This function pointer is NULL if the iterator does not implement it.
    458      *
    459      * @see UCharIteratorGet
    460      * @stable ICU 2.6
    461      */
    462     UCharIteratorGetState *getState;
    463 
    464     /**
    465      * (public) Restore the iterator state from the state word from a call
    466      * to getState().
    467      * This function pointer is NULL if the iterator does not implement it.
    468      *
    469      * @see UCharIteratorSet
    470      * @stable ICU 2.6
    471      */
    472     UCharIteratorSetState *setState;
    473 };
    474 
    475 /**
    476  * Helper function for UCharIterator to get the code point
    477  * at the current index.
    478  *
    479  * Return the code point that includes the code unit at the current position,
    480  * or U_SENTINEL if there is none (index is at the limit).
    481  * If the current code unit is a lead or trail surrogate,
    482  * then the following or preceding surrogate is used to form
    483  * the code point value.
    484  *
    485  * @param iter the UCharIterator structure ("this pointer")
    486  * @return the current code point
    487  *
    488  * @see UCharIterator
    489  * @see U16_GET
    490  * @see UnicodeString::char32At()
    491  * @stable ICU 2.1
    492  */
    493 U_STABLE UChar32 U_EXPORT2
    494 uiter_current32(UCharIterator *iter);
    495 
    496 /**
    497  * Helper function for UCharIterator to get the next code point.
    498  *
    499  * Return the code point at the current index and increment
    500  * the index (post-increment, like s[i++]),
    501  * or return U_SENTINEL if there is none (index is at the limit).
    502  *
    503  * @param iter the UCharIterator structure ("this pointer")
    504  * @return the current code point (and post-increment the current index)
    505  *
    506  * @see UCharIterator
    507  * @see U16_NEXT
    508  * @stable ICU 2.1
    509  */
    510 U_STABLE UChar32 U_EXPORT2
    511 uiter_next32(UCharIterator *iter);
    512 
    513 /**
    514  * Helper function for UCharIterator to get the previous code point.
    515  *
    516  * Decrement the index and return the code point from there
    517  * (pre-decrement, like s[--i]),
    518  * or return U_SENTINEL if there is none (index is at the start).
    519  *
    520  * @param iter the UCharIterator structure ("this pointer")
    521  * @return the previous code point (after pre-decrementing the current index)
    522  *
    523  * @see UCharIterator
    524  * @see U16_PREV
    525  * @stable ICU 2.1
    526  */
    527 U_STABLE UChar32 U_EXPORT2
    528 uiter_previous32(UCharIterator *iter);
    529 
    530 /**
    531  * Get the "state" of the iterator in the form of a single 32-bit word.
    532  * This is a convenience function that calls iter->getState(iter)
    533  * if iter->getState is not NULL;
    534  * if it is NULL or any other error occurs, then UITER_NO_STATE is returned.
    535  *
    536  * Some UCharIterator implementations may not be able to return
    537  * a valid state for each position, in which case they return UITER_NO_STATE instead.
    538  * This will be clearly documented for each such iterator (none of the public ones here).
    539  *
    540  * @param iter the UCharIterator structure ("this pointer")
    541  * @return the state word
    542  *
    543  * @see UCharIterator
    544  * @see UCharIteratorGetState
    545  * @see UITER_NO_STATE
    546  * @stable ICU 2.6
    547  */
    548 U_STABLE uint32_t U_EXPORT2
    549 uiter_getState(const UCharIterator *iter);
    550 
    551 /**
    552  * Restore the "state" of the iterator using a state word from a getState() call.
    553  * This is a convenience function that calls iter->setState(iter, state, pErrorCode)
    554  * if iter->setState is not NULL; if it is NULL, then U_UNSUPPORTED_ERROR is set.
    555  *
    556  * @param iter the UCharIterator structure ("this pointer")
    557  * @param state the state word from a getState() call
    558  *              on a same-type, same-string iterator
    559  * @param pErrorCode Must be a valid pointer to an error code value,
    560  *                   which must not indicate a failure before the function call.
    561  *
    562  * @see UCharIterator
    563  * @see UCharIteratorSetState
    564  * @stable ICU 2.6
    565  */
    566 U_STABLE void U_EXPORT2
    567 uiter_setState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode);
    568 
    569 /**
    570  * Set up a UCharIterator to iterate over a string.
    571  *
    572  * Sets the UCharIterator function pointers for iteration over the string s
    573  * with iteration boundaries start=index=0 and length=limit=string length.
    574  * The "provider" may set the start, index, and limit values at any time
    575  * within the range 0..length.
    576  * The length field will be ignored.
    577  *
    578  * The string pointer s is set into UCharIterator.context without copying
    579  * or reallocating the string contents.
    580  *
    581  * getState() simply returns the current index.
    582  * move() will always return the final index.
    583  *
    584  * @param iter UCharIterator structure to be set for iteration
    585  * @param s String to iterate over
    586  * @param length Length of s, or -1 if NUL-terminated
    587  *
    588  * @see UCharIterator
    589  * @stable ICU 2.1
    590  */
    591 U_STABLE void U_EXPORT2
    592 uiter_setString(UCharIterator *iter, const UChar *s, int32_t length);
    593 
    594 /**
    595  * Set up a UCharIterator to iterate over a UTF-16BE string
    596  * (byte vector with a big-endian pair of bytes per UChar).
    597  *
    598  * Everything works just like with a normal UChar iterator (uiter_setString),
    599  * except that UChars are assembled from byte pairs,
    600  * and that the length argument here indicates an even number of bytes.
    601  *
    602  * getState() simply returns the current index.
    603  * move() will always return the final index.
    604  *
    605  * @param iter UCharIterator structure to be set for iteration
    606  * @param s UTF-16BE string to iterate over
    607  * @param length Length of s as an even number of bytes, or -1 if NUL-terminated
    608  *               (NUL means pair of 0 bytes at even index from s)
    609  *
    610  * @see UCharIterator
    611  * @see uiter_setString
    612  * @stable ICU 2.6
    613  */
    614 U_STABLE void U_EXPORT2
    615 uiter_setUTF16BE(UCharIterator *iter, const char *s, int32_t length);
    616 
    617 /**
    618  * Set up a UCharIterator to iterate over a UTF-8 string.
    619  *
    620  * Sets the UCharIterator function pointers for iteration over the UTF-8 string s
    621  * with UTF-8 iteration boundaries 0 and length.
    622  * The implementation counts the UTF-16 index on the fly and
    623  * lazily evaluates the UTF-16 length of the text.
    624  *
    625  * The start field is used as the UTF-8 offset, the limit field as the UTF-8 length.
    626  * When the reservedField is not 0, then it contains a supplementary code point
    627  * and the UTF-16 index is between the two corresponding surrogates.
    628  * At that point, the UTF-8 index is behind that code point.
    629  *
    630  * The UTF-8 string pointer s is set into UCharIterator.context without copying
    631  * or reallocating the string contents.
    632  *
    633  * getState() returns a state value consisting of
    634  * - the current UTF-8 source byte index (bits 31..1)
    635  * - a flag (bit 0) that indicates whether the UChar position is in the middle
    636  *   of a surrogate pair
    637  *   (from a 4-byte UTF-8 sequence for the corresponding supplementary code point)
    638  *
    639  * getState() cannot also encode the UTF-16 index in the state value.
    640  * move(relative to limit or length), or
    641  * move(relative to current) after setState(), may return UITER_UNKNOWN_INDEX.
    642  *
    643  * @param iter UCharIterator structure to be set for iteration
    644  * @param s UTF-8 string to iterate over
    645  * @param length Length of s in bytes, or -1 if NUL-terminated
    646  *
    647  * @see UCharIterator
    648  * @stable ICU 2.6
    649  */
    650 U_STABLE void U_EXPORT2
    651 uiter_setUTF8(UCharIterator *iter, const char *s, int32_t length);
    652 
    653 #if U_SHOW_CPLUSPLUS_API
    654 
    655 /**
    656  * Set up a UCharIterator to wrap around a C++ CharacterIterator.
    657  *
    658  * Sets the UCharIterator function pointers for iteration using the
    659  * CharacterIterator charIter.
    660  *
    661  * The CharacterIterator pointer charIter is set into UCharIterator.context
    662  * without copying or cloning the CharacterIterator object.
    663  * The other "protected" UCharIterator fields are set to 0 and will be ignored.
    664  * The iteration index and boundaries are controlled by the CharacterIterator.
    665  *
    666  * getState() simply returns the current index.
    667  * move() will always return the final index.
    668  *
    669  * @param iter UCharIterator structure to be set for iteration
    670  * @param charIter CharacterIterator to wrap
    671  *
    672  * @see UCharIterator
    673  * @stable ICU 2.1
    674  */
    675 U_STABLE void U_EXPORT2
    676 uiter_setCharacterIterator(UCharIterator *iter, icu::CharacterIterator *charIter);
    677 
    678 /**
    679  * Set up a UCharIterator to iterate over a C++ Replaceable.
    680  *
    681  * Sets the UCharIterator function pointers for iteration over the
    682  * Replaceable rep with iteration boundaries start=index=0 and
    683  * length=limit=rep->length().
    684  * The "provider" may set the start, index, and limit values at any time
    685  * within the range 0..length=rep->length().
    686  * The length field will be ignored.
    687  *
    688  * The Replaceable pointer rep is set into UCharIterator.context without copying
    689  * or cloning/reallocating the Replaceable object.
    690  *
    691  * getState() simply returns the current index.
    692  * move() will always return the final index.
    693  *
    694  * @param iter UCharIterator structure to be set for iteration
    695  * @param rep Replaceable to iterate over
    696  *
    697  * @see UCharIterator
    698  * @stable ICU 2.1
    699  */
    700 U_STABLE void U_EXPORT2
    701 uiter_setReplaceable(UCharIterator *iter, const icu::Replaceable *rep);
    702 
    703 #endif
    704 
    705 U_CDECL_END
    706 
    707 #endif
    708