icuSources/common/unicode/uiter.h

   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