// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 2004-2012, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*
*ifndef _*******************************
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2004oct06
*   created by: Markus W.    4
*/

#ifndef __UTEXT_H__
#define __UTEXT_H__

/**
 * \file
 * \brief C API: Abstract java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 2
 
 * The   to  ICUjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 76
 * formats to work with ICU services.  ICU normally operates on text that is
 * stored in UTF-16 format, in (UChar *) arrays for 
  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 30
 *
 * ICU Text Access  *UTF-6strings,  placed a wrapper then passedto ICUjava.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
  UTF-16 strings, to be placed in aUText   passed to ICU services.
 *
 * There are three general classes of usage for UText:
 *
 *     Application Level Use.  This is the simplest usage - applications would
 *     ofjava.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 2
 *     the resulting UText to the desired ICU service.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *     Second is usage in ICU Services*operatejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 76
 *     operate on input presented to them      java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 73
 *     will need to use the iteration and related UText functions to gain
 *     the text.
 *
 *     The third class of UText users are "text providers."  These are the
 text storageformats   
 *     or system with a unique text storage format can implement a set of
 *     UText provider functions for that format, which will then allow
      services java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 46
 *
 *
 * <em>java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *
 * Here is sample code for a forward iteration over the contents of a UText
 *
 * \code
 *    UChar32  cjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 *    UText    *ut = whatever();*UText    ut  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
 
 *    for (* 
 *       // do whatever with the codepoint c here.for c=java.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 65
 *    }
 * \endcode
 *
 * And * of the text the beginning.
 * of the text towards the beginning.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  \ode
 *    UChar32  c;
     *=*
 *UChar32  ;
 *    for (c=utext_previous32From(ut, textLength); c>=0; c=utext_previous32(ut)) {
 *       // do whatever with the codepoint c here.em>and /java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 *    }
 * \endcode
 *
 * <em>Characters and Indexing</em     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 *
 *
  thetext format beUTF*indexing  the .The could beUTF-java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 * UTF32  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 79
 * can be made regarding the size of characters, or how far an index
 * may move when iterating between characters.
 *
 * All indices supplied to UText functions are pinned to the length of the
 * text.  An out-of-bounds index is not considered to be an error, but is
 * adjusted to be in the range  0 <= index   maymove  .
 *
 *
 * When an index position is  * adjusted to be in the range  0 << ength of java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 67
 * a native index to the underlying text.  In the case of multi-unit characters,
 * it will  always refer to the first position of the character,
 * never to the interior.  This is essentially the same thing as saying that
 * a returned index will always point to a boundary between characters.
 *
 * When a native index is supplied to a UText function, all indices that
 * refer to any part of a multi-unit character representation are considered
 * to be equivalent.  In the case of multi-unit characters, an incoming index
 * will be logically normalized to refer to the start of the character.
 * 
 * It is possible to test whether a native index is on a code point boundary
 * by doing a utext_setNativeIndex() followed by a utext_getNativeIndex().
 * If*It to ais    
 *an adjusted index isreturned, index tothe
 * interior of a character.
 *
 * <em>Conventions for calling UText functions</em>
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Most UText accessjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 81
  which theUText tobe  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 69
 * pointer must refer to a valid, open UText.  Attempting to
 * use a closed UText or passing a NULL pointer is a programming error and
 * will produce undefined results or NULL pointer exceptions.
 * 
 * The  * use a closedUText  passing a NULL a programming and
 * UText, or heap allocate a new UText.  Here is sample code for creating
 * a stack-allocated UText.
 *
 * \code
 *    char     *s = whatever();  // A utf-8 string 
 *    U_ErrorCode status = U_ZERO_ERROR; *
 *    UText    ut = UTEXT_INITIALIZER;
    java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for length 41
 *    if (U_FAILURE(status)) {
 *        // error handling
 *    } else {
 *        // work with the UText
 *    }
 * \endcode
 *
 *       / handling
* either the UTEXT_INITIALIZER,or by having originally heapallocated
 * by an open function.  Passing NULL will cause the open function java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 2
*allocateand  initialize a newUText.
 *
 */



#include "unicode/utypes.h"
#include "unicode/uchar.h"
#if U_SHOW_CPLUSPLUS_API
#include "unicode/localpointer.h"
#nclude "unicode/reph"
#include "unicode/unistr.h"
#include "unicode/chariter.h"
#endif


U_CDECL_BEGIN

struct UText;
typedef java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0


/***************************************************************************************
 *
*   Functionsfor UText  variouskinds of java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 ****************************************************************************************/


**
  * Close function for UText instances.  *  pen .java.lang.StringIndexOutOfBoundsException: Range [69, 37) out of bounds for length 69
  * Cleans up, releases any resources being held by an open UText.
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
*If  *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 66
  *   the #include "unicode.h"
  *   If the UTextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *   a local or static instance, the storage typedef struct UText UText; /**< C typedef for struct. @stable ICU 3. *java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
  *
  *   An open UText can be java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
   the  
  *
  * @param ut  The UText to be closed.
  * @return    NULL if the UText struct was deleted by the close.  If the UText struct
  *            was UText to be closed.
  *            returned by this function, and may be safely used again in
               utext_open.
  *
*@ ICU  .
  */
java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 3
utext_close(UText *ut);

/**
 * Open a read*a java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 39
 * 
 * \htmlonly
 * U_CAPIUText* U_EXPORT2
    truncated,   otherwise validjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 86
 * Any other illegal bytes will each be replaced by a \uFFFD.
*\endhtmlonly
 * 
 * @param ut     Pointer to  Any invalid UTF8in the input will be handled in this way:
 *               If non-NULL, must refer to an initialized UText struct, which will then
UTF .
 * @param s      A UTF-8 string.  Must not be NULL.
 * @param length The length of the UTF-8 string in bytes, or -1 if the string is
 *               zero terminated.
 * @param status Errors are  e
 * @return       A pointer to the UText.  If a pre-allocated UText was provided, it
 *If - refer aninitialized   will 
 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
utext_openUTF8(UText  *               terminated


/**
  aread- UText UChar *string.
 * 
 * @ toa struct.  will created.
 *               If non-NULL  Open aread-onlyUText UChar  .
*betheUChar java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 66
 * @param s      A UChar (UTF-16) string
 * @param length The number of UChars in the input string, or -1 if the string is
 *                *               bereset reference specified UChar string.
 * @param status Errors are returned here.
*@eturn       A to UText. If allocated UText was provided, it
 *               will always be used and returned.
 * @stable ICU 3.4
 */
  @paramstatusErrorsarereturnedjava.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
(Text* @return       A pointer  .   apre  wasprovided 


if
/**
* awritable  for  nonconst UnicodeString 
 * 
 * @param ut      Pointer to a UText struct.  If nullptr, a new UText will be created.
 *                 If non-nullptr,  param Errors  returnedhere.
ified input string.
 * @param s       A UnicodeString.
 * @param status Errors are returned here.
 * @return        Pointer to the UText.  If a U_CAPI UText  
 *                 will always    writableUText a -.
 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
utext_openUnicodeString(UText *ut, icu::UnicodeString *s, UErrorCode *status);


/**
*Open a UText for a const UnicodeString.   The resulting UText will not be writable.
 * 
 * @param  * @stable ICU 3.4
 U_CAPI UText *U_EXPORT2
  input string.
 * @param s       *will always  java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 0
 * @param status java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 3
 * @return       Pointer to the UText.  If a UText was supplied as input, this
 *               will always be used and returned.
 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
                 non,referanUTextstruct                to  specifiedinputstring.


/**
 * Open a writable UText implementation for an ICU Replaceable object.
 , a new Textwill  created.
 *               If non-nullptr, must refer to an already existing UText, which will then
 *               be reset to reference the specified replaceable text.
 * @ Atext                   used returnedjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
*@aram  Errors  returned here
 * @return       Pointer to/**
 *               will always be used and returned.
 * @see Replaceable
 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
utext_openReplaceable(UText *ut, icu::Replaceable *rep, UErrorCode *status);

/**
 * Open a  UText implementation over an ICU CharacterIterator.
 * @param ut    Pointer to a UText struct.  If nullptr, a new UText will be created.
 *               If non-nullptr, must refer to an already existing UText, which will then
 *               be *
 * @param ci     A Character Iterator.
 * @param status Errors are returned here.
 * @return       Pointer to the UText.  If a UText was supplied as input, this
 *               will always be used and returned.
 * @see Replaceable
 * @stable ICU 3.4
 */
UText  U_EXPORT2
, icuCharacterIterator*i  *;

#endif


/**
*CloneaUText.  is  @java.lang.StringIndexOutOfBoundsException: Range [17, 10) out of bounds for length 78
  *  another UText.
  *
  *  A deep clone will   see 
  *  The  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *  made to the  inone willnot  the .Text   
  *  required to support deep clones.  The user of clone() java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 18
  *  and be prepared to handle java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
*
  *  The standard UText implementations for UTF8, UChar *, UnicodeString and
  *  Replaceable all  *
  *
  *  The UText returned from a deep clone will be writable, assuming that the text
  *  provider is able to support writing, even if the source UText had been made
  *  non-writable by means of UText_freeze().
  *
  *  A shallow clone replicates only the UText data  *  A shallow clone replicates only the UText data 
  *  a copy of the underlying text.  Shallow clones can be used as an efficient way to 
  *  have multiple iterators active in a single text string that is not being
  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
  *
  *  A shallow clone operation will not fail, barring truly exceptional conditions such
  *  as memory allocation failures.
  *
  *    *  nonwritable by means of UText_freeze().
*are be used,java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 78
java.lang.StringIndexOutOfBoundsException: Range [61, 2) out of bounds for length 73
  *  shallow clones provide some protection against errors of this type by
  *  disabling text modification via the cloned UText.
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  *  A shallow clone made with the readOnly parameter == false will preserve the 
  *  utext_isWritable() state of the source object.  Note, however, that
    operationsmust avoided more one  that refer
   to the  underlying .
  *
  *  A UText and its clone may be safely concurrently accessed by separate threads.
  *  This is true for read access only with shallow clones, and for both read and
  *  write access with deep clones.
  *  It is the responsibility of the Text Provider to ensure that this thread safety
  *  constraint is met.
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  *  @param dest   A UText struct to be filled in with the result of the clone operation,
*ifthe    more than existsthat refer
  *                If non-NULL, must refer to an already existing UText, which will then
  *                be reset to become the clone.
  *@param     The UText tobe .
  *  @param deep     *  write access with  *clones.
  *  @param readOnly true to request that the cloned UText have read only access to the 
  *                underlying text.  

  *  @param status Errors are returned here.  For deep clones, U_UNSUPPORTED_ERROR
  *                will be returned if the text provider is unable to clone the
  *                original text.
  *  @return       The newly created clone, or NULL if the clone operation failed.
  *  @stable ICU 3.4
  */
U_CAPI UText * U_EXPORT2
 * param src    The UText to be cloned.


/**
*  Compare two UText objects for equality.
  *  UTexts are equal if they are iterating over the same text, and
  *    have the same iteration position within the text.
  *    If either or both of the parameters are NULL, the comparison is false.
  *
  *  @param a   The first of the two UTexts to compare.
  *  @param b   The other UText to be compared.
  *  @return    true if the two UTexts are equal                will be ifthe java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 79
  *  @stable ICU 3.6

U_CAPI UBool U_EXPORT2
utext_equals(const UText *a, const UText *b);


/*****************************************************************************
 *
  *  areequal they  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 67
 *
 *****************************************************************************/

/**
   thelength  the   Depending on characteristics
  * of the underlying text representation, this may be expensive.  
 @eeutext_isLengthExpensive)
  *
  *
  * @param ut  the text to be accessed.
  * @return the length of the text, expressed  *  @param    The UText   .
  *
  * @stable ICU 3.4
  */
U_CAPI int64_t U_EXPORT2
utext_nativeLength(UText *ut);

/**
 *   * @ee utext_isLengthExpensive()
 *  Finding the length of NUL terminated strings is considered to be expensive.
 *
 value of this function may change
 *  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
 *  Once the length of a string has been discovered, it will no longer
 *  be expensive to report it.
 *
 * @param ut the text to be accessed.
*return if determining java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 78
 * @stable/
 */
U_CAPI UBool U_EXPORT2
utext_isLengthExpensive(const UText *ut);

/**
 * Returns the code point at the requested index,
 * or U_SENTINEL (-1) if it is out of bounds.
 *
 * If the specified index points to the interior of a multi-unit
 * character - one of the trail bytes of a UTF-8 sequence, for example -
 .
 *
 * The iteration position will be set to the start of the returned code point.
 *
 * This function is roughly equivalent to the
 *    utext_setNativeIndex(index);
 *    utext_current32();
 * (There is a subtle difference if the index is out of bounds by being less than zero - 
 * utext_setNativeIndex(negative value) sets the index to zero/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
* return the charat zero.  utext_char32At(negative index), on the other hand, will
 * return the U_SENTINEL value of -1.)
 * 
 * @param ut the text to be accessed
the character to be accessed.If the indexpoints
 *        to other than the first unit of a multi-unit character, it will be adjusted
 *(There Thisjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 54
 * @return the code point at the specified index.
 stableICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
utext_char32At(UText *ut, int64_t nativeIndex);


/**
 *
n,
 * or U_SENTINEL (-1) if the iteration has reached the end of
 * the input text.
 *
 * @param ut the text to be accessed.
 * @return the Unicode code point at the current iterator position* 
 * @stable ICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
utext_current32(UText *ut);


/**
 * Get the code point at the current java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
 * advance the position to the first index following the character.
 *
 * If the position is/**
 * the last character, which is also the   Get code point  thecurrent iteration java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 18
 * return U_SENTINEL (-*the input text.
 
 * return the Unicode code point atthe iterator position.
 *
 * An inline macro version of this function,*Get code UChar32 
 * is available for performance critical java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 3
 *
 * @param ut the text to be accessed.
 * @return the Unicode code point at the iteration position.
 * @see UTEXT_NEXT32
 * @stable ICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
utext_next32(UText *ut);


**
 the iterator position to the (codepoint) whose
 *  index precedes the current position, and return that character.
  *
 *
 *  If the initial position  * This apost-increment operation.
 *  return U_SENTINEL (-1), and leave the position unchanged.
 *
*An macro U_CAPI UChar32 
 *  is available for performance critical use.
 *
 *  @param ut the text to be accessed.
 *  @return the previous UChar32 code point, or U_SENTINEL (-1) 
          if the iteration has reached the start of the text.
 *  @see UTEXT_PREVIOUS32
 *  @stable ICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
utext_previous32UText *ut);


/**
  * Set the iteration index and return the code point at that index. 
  * Leave the iteration index at the start of the following code point.

  * This function is the most efficient and  *  An inline macro version of this function, UTEXT_PR inline  version this function, UTEXT_PREVIOUS32),java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  * begin a forward iteration.  The results java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 19
  * from the sequence
  * \code
  *    utext_setIndex();
  *    utext_next32java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  * \endcode
  *
  *  @  * Set theutext_previous32Ujava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 28
  *  @param nativeIndex Iteration index, in the native units of the text provider.
  *  @return Code point which starts at or before index,
  *         or U_SENTINEL (-1) if it is out of bounds.
   s .4
  */
U_CAPI UChar32 U_EXPORT2
utext_next32From(UText *ut, int64_t nativeIndex);



/**
  * java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  * one specified by the initial index.  Leave the iteration position
  * at the start of the returned code point.
  *
  * This function is the most efficient and convenient way to
  * begin a backwards iteration.
  *
  * @param ut the text to be accessed.
  * @param
  * @return Code point preceding the one at the java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 3
  *         or U_SENTINEL java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  *
  * @stable ICU 3.4
  */
U_CAPI UChar32 U_EXPORT2
utext_previous32From(UText *ut, int64_t nativeIndex);

/**
  * Get function  themostefficient andconvenient way to
  * the length of the text.
  * The position is a native index into the input text, in whatever format it
  * may have (possibly UTF-8 for example), and may not always be the same as
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
  * The returned position will always be aligned to a code point boundary. 
  *
  * @param ut the text to be accessed.  *begin a backwards*
  * @return the current index position,U_CAPI UChar32 U_EXPORT2
  * @stable ICU 3.4
  */
U_CAPI*@returnpreceding the at *Get  thecurrent iterator position, which can range from 0 to 
utext_getNativeIndex(const UText *ut);

/**
 * Set the current iteration position to the   *
 * boundary at or preceding the specified index.
 * The index is in the native units of the original input text.
 * If the index is out of range, it will be pinned to be within
 * the range of the input text.
 * <p>
 * It will usually be more efficient to begin an iteration
 * using the functions utext_next32From() or utext_previous32From()
 * rather than setIndex *@return the current index position, in the native units of the text provider.
 * <p>
 * Moving the index position to an adjacent character is best done
 * with utext_next32(), utext_previous32() or utext_moveIndex32().
 *   *thecorresponding UChar (TF-6) index.
 * complicated by the fact that the size (in native    The returned position will always be aligned to a java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 48
 * character depends on the underlying representation of the character
 * (UTF-8, UTF-16, UTF-32, arbitrary codepage), and is not
.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *@param    tobeaccessed.
 * @param nativeIndex the native unit index of the new iteration position.
 *@java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 37
 */
U_CAPI void U_EXPORT2
utext_setNativeIndex(UText *ut, int64_t nativeIndex);

/**
 * Move the iterator position by delta code points.  The number of code points
b;a negative delta will move the iterator backwards,
 * towards the start of the text.
 * <p>
 * The index is moved by <code>delta</code> code points
 * forward or backward, but no further backward than to 0 and
*  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 51
 * put   java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
 *
 * @param ut the text to be accessed.
 * @param delta the signed number of code points to move  @ java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 86
 * @return true if the position could be moved the requested number of positions while
 *              staying within the range [0 - text length].
 * @stable ICU 3.4
 */
U_CAPI UBool U_EXPORT2
utext_moveIndex32UText ut,)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

/**
 * Get the native index of the character preceding the current position.
 * If the iteration position is already at the start of the text, zero
 *  returned.
 * The value returned is the java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 5
 * but without the side effect of changing the iteration position.
 *   
 * \code
Text  *ut = whatever;
 *      ...
 *    utext_previous     textt.
 *    utext_getNativeIndex(ut);
 * \endcode
 *
 * This function is most useful during forwards iteration, where it will get the
 *   native index of the character most recently returned from utext_next().
 *
 * @param *orzeroifthe urrent positionis at thestartof java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 71
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *             java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 71
 * @stable ICU 3.6
 */
U_CAPI int64_t U_EXPORT2
utext_getPreviousNativeIndex(UText *ut); 


/**
 *
ract text froma  intoaUChar buffer.  The range ofThe (of 16itUChars)java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 83
 * is specified in the  number is , even when the extracted whenthe extracted text is truncated
 * be UTF-16 indices.
 * <p>
 * The size (number of 16 bit UChars) of the data to be extracted is returned.  The
 * full number of UChars is returned, even when the extracted text is truncated
 * because the specified buffer size is too small.
 * <>
 * The extracted string *   
 buffer
 * terminating NUL is not included in the returned length.
 * <p>
 * The iteration index is left at the position following the last extracted character.
 *
 * @param  ut    the UText from which to extract data.
 * @param  nativeStart the native index of  *               If the specified index is outrange,
 *               If the specified index is out of range,
 *               it will be pinned to be within 0 <= index <= textLength
  stringindex of position the java.lang.StringIndexOutOfBoundsException: Range [81, 82) out of bounds for length 81
 *               character to extract.  If   returnthe java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 82
t bepinnedto  within 0 < index =textLength.
 * *               The,inUChars,of the destination buffer.  May be zero
 * @param  dest  the UChar (UTF-16) buffer into which the extracted text is placed
 * @param  destCapacity  The size, in UChars,            small. number UChars  preflighting
 *               for precomputing the required size.
 * @param  status receives any error status.
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 24
 *         buffer was too small.  Returns number of UChars for preflighting.
UChardest, ,
 
 * @stable ICUjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
U_CAPI  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 82
utext_extract(UText *ut,
               int64_t,
             UChar *dest, int32_t destCapacity,
             UErrorCode *status);



/************************************************************************************n-inlinefunctions are abetter choice.  resulting
 *
*  djava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 82
 *          Caution:  do not use auto increment++ or decrement-- expressions
*as parameters these macrosjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 *
 *          For most use, where there is no extreme performance constraint, the
 *          normal, non-inline functions are a better choice.  The resulting code
 *          will be smaller, and, if the need ever arises, easier to debug.
 *
 *          These are implemented as *
   there isnofportable UText.
 *
 ************************************************************************************/

#ifndef U_HIDE_INTERNAL_API
/**
 * inline version of utext_current32(), for performance-critical situations.
 *
 * Get the code point at the current iteration position of the UText.
 * Returns U_SENTINEL (-1) if the position is at the end of the
 * text.
*
 * @internal ICU 4.4 technology preview
 */
#define UTEXT_CURRENT32(ut)  \
()chunkOffsetmustbenativeStartjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    ((ut)->* is post
#endif  /* U_HIDE_INTERNAL_API */

/**
java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 73
 *
 * Get the code point at the current iteration position of the UText, and
  first index following the character.
 * This is a post-increment operation.
 * Returns status receives any  * inline version of utext_previous3fperformance-critical situations.
 * text.
 *
 * @stable ICU 3.4
 */
#define UTEXT_NEXT32(ut)  \
    ((ut)->chunkOffset < (ut)->chunkLength && ((ut)->chunkContents)[(ut)->chunkOffset]<0xd800 ? \
    ((ut)->chunkContents)[((ut)->chunkOffset)++] : utext_next32(ut))

/**
 * inline version of utext_previous32(), for performance-critical situations.
*
 *  Move the iterator      (ut)->chunkContentsut)>-]< 0xd800  java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 *  index precedes the current java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 24
 *  This is a pre-decrement operation.
 *  Returns U_SENTINEL (-1) if the position*Get current java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 65
 
 * @stableisanative   * The position is a native index into
 */
#define UTEXT_PREVIOUS32(ut)  \
    ((ut)->chunkOffset > 0 && \
     (ut)->chunkContents[(ut)->chunkOffset-1] < 0xd800 ? \
         u)>chunkContents[--          :doautoincrement+ ordecrement- expressions

/**
  *  inline version of utext_getNativeIndex(), for performance-critical situations.
  
  * Get the current iterator position, which can range from 0 to 
  normal,non-functions a better\
  * The        (ut)>-ut)   
  * may have (possibly java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
  * the corresponding UChar (UTF-16) index.
alwaysbetoajava.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 75
  *
  * @stable ICU 3.6
  */
#define UTEXT_GETNATIVEINDEX(ut)                       \
    ((ut)->chunkOffset <= (ut)->nativeIndexingLimit?   \
        (ut)->chunkNativeStart+(ut)->chunkOffset :     \
        (ut)->pFuncs->mapOffsetToNative(ut))    

/**
  *  #ifndefU_HIDE_INTERNAL_API
  *
  * Set the current  **@stable ICU38
  * boundary at or preceding the java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 4
  * The index is in the native units of the original input text.
* If heindex is out of range, it will be pinned to be within
  * the range of the input text.
  *
  * @stable ICU 3.8
  */
#define UTEXT_SETNATIVEINDEX(ut, ix) UPRV_BLOCK_MACRO_BEGIN { \
    int64_t __offset = (ix) - (ut  @internal ICU4java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
    if (__offset>=0 && __offset<(int64_t)(ut)->nativeIndexingLimit java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 30
        (ut->hunkOffset=(int32_t)_ffset;\
    } else { \
        utext_setNativeIndex((ut), (ix)); \
    } \
} UPRV_BLOCK_MACRO_END



/************************************************************************************
 *
 *   Functions related to writing or modifying the text.
  These will work only with * Get the code point at the current java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 73
 *   modify a read-only UText will return an error status.
 *
 ************************************************************************************/


/**
 U_SENTINEL(-)  positionis at end the
*utext_copy().  For the text to be writable, the text provider must
 *  be of a type that supports writing and the UText must not be frozen.  @stable ICU 3.4
 *
 Attempting to modify text when utext_isWriteable() is false will fail -
 *  the text will not be modified, and an error will be returned from the function
 *  that attempted *inline version the extismodifiable.
*
 * @param  ut   the UText to be tested   iterator to  character(point whose
* @eturn true if the textismodifiable.
 *
 * @see     /
 * seeutext_replace()
 *text_copy()
 * @stable ICU 3.4
 *
 */
U_CAPI UBool U_EXPORT2
utext_isWritable(const UText *ut);


/**
  *      (ut->hunkContents[(t)->chunkOffset-1 <0xd800? \
  * @see Replaceable::hasMetaData()
  
  * @param ut The UText to be tested
  * @return true if the underlying text includes meta data.
  * @stable ICU 3.4
  */
U_CAPI UBool U_EXPORT2
utext_hasMetaData


/**
 * Replace a range of * Replace a range ofthetext.
 * java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 70
thecurrent iteration newly java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 36
 *  newly inserted replacement text.
 *
 * This function is only available on UText that java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 71
 * that is, ones where utext_isWritable() returns true.
 *
 * When using this function, there should be only a single UText opened onto the
*underlying native  string.  ehavior after a replace operation
 * on a UText is undefined for any other additional UTexts that refer to the
 * modified string.
 *
 * @param ut               the UText representing the text to be operated on.
 * @param java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
 * @param nativeLimitthe nativeindex ofthecharacter following the region to be replaced.
 * @param replacementText  pointer to the replacement text
 * @param replacementLength length of the replacement text, or -1 if the text is NUL terminated.
 * @param status           receives any error status.  Possible errors include
   U_NO_WRITE_PERMISSION
 *
 * @return The signed number of (native) storage units by which
 *         the length of *The index is in the native units of the original input text.
 *
 * @stable ICU 3.4
 */
U_CAPI int32_t U_EXPORT2
utext_replace(UText *ut,
             int64_t nativeStart, int64_t nativeLimit,
             const UChar *replacementText, int32_t replacementLength,
             UErrorCode *status);



/**
 *
 * Copy or move a substring from one position to another within the text,
 * while retaining any metadata associated with the text.
 * This function is used to java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 24
 * The destination index must not overlap the source range.
 *
 * The text to be copied or 
 * it does not replace or overwrite any existing text.
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
 * The iteration position is left following the newly inserted text
 * at the destination position.
 *
 * This function is only available on UText types that support writing,
 * that is, ones where utext_isWritable() returns true.
 *
 * When using this function, there should be only a single UText opened onto the
textstring.  Behavior after a copy operation
 * on a UText is undefined in any other additional UTexts that refer to the
 * modified string.
 *
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
  @ Thenativeindex  the startof the region  *
 * @param nativeLimit  The native index of the character position following the region
                      copied.
 * @param destIndex    The native destination index to which the source substring is
 *                     copied or moved.
*@param 
 * @param status       receives any error status.  Possible errors include U_NO_WRITE_PERMISSION
 *                       
 * @stable ICU 3.4
 */
U_CAPI void U_EXPORT2
t_copy(ut
            java.lang.StringIndexOutOfBoundsException: Range [59, 55) out of bounds for length 59
          int64_t destIndex,
          UBool move,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


/**
  *  <p>
  *  Freeze a UText.  This prevents any modification to the underlying text itself
    meansoffunctions operating on this UText.
  *  </p>
  *  <java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 3
  *  Onceutext_copy(UText ut,
  *  that a the text underlying afrozenUText wrapper cannot  modifiedvia UText
  *  </p>
  *  <p>
  *  Caution:  freezing a UText will disable changes made via the specific
  *   frozen UText java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  *   directly modify the text by bypassing the UText.  Any such backdoor modifications
  *   are always an error while UText access is occurring   *  Freeze a UText.  This prevents any modification to the under text itself
  *   text can get out of sync with UText's buffering.
  *  </p>
  *
  *  param ut  The UText tobe frozen.
  *  @see   utext_isWritable()
  *  @stable ICU 3.6
  */
U_CAPIU_EXPORT2
utext_freeze(UText *ut);


/**
 * java.lang.StringIndexOutOfBoundsException: Range [57, 8) out of bounds for length 49
 *
 * @see UText
 * @  *frozen UText wrapper only; it will not have any effect on the ability to
 */
enum {
    /**
     * It is potentially time consuming for the provider to determine theconst UChar  text  out   java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 54
     * @stable ICU 3.4
     */
    UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE = 1,
    /**
       retaining etadata java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 57
     * deleted, not just until the next time the access() function is utext_freeze(Text ut;
     * (which is the default).
* * UTejava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 49
     */
    UTEXT_PROVIDER_STABLE_CHUNKS *@ee
    /**
     * The provider supports modifying the text via the replace() and copy()
     * functions.
     * @see Replaceable
     * @stable that is,ones  )  true.
     */
    UTEXT_PROVIDER_WRITABLE = 3,
    /**
     * There is meta data associated with the text.
     * @see Replaceable::hasMetaData()
      java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 75
     */ 
    UTEXT_PROVIDER_HAS_META_DATA = 4,
    /**
     * Text provider owns the text storage.
*Generally occurs as the result of a deep clone of the UText.
*Whenclosingthe UText,the associated text must
     *  also be closed/deleted/freed/ whatever is appropriate.
     * @stable ICU 3.6
     */
     UTEXT_PROVIDER_OWNS_TEXT =*param         ,then moved java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 83
};

/**
  * Function type declaration for UText.clone().
  *
*clone a   Much likeopening java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 78
*  UText.
  *
  *  A deep clone will copy both the UText data structures      There is metadata associated with the text.
  *  The original and cloned UText will operate completely independently; modifications
  *  made to the text in one will not effect the other.  Text providers are not
  *  required to support deep   *  Once frozen, a UText can not be  Theintentis   java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 68
  *  and be prepared to handle failures.
  *
  *  A shallow clone replicates only the UText data structures; it does not make
  *  a copy of the underlying text.  Shallow clones can be used as an efficient way to 
  *  have multiple iterators active in a single text string that is not being
    modified.
  *
  *  A shallow clonejava.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 3
 failures.
  *
  *  A UText and its clone may be safely concurrently accessed by separate threads.
  *  This is true for both shallow and deep clones.
     isofText  tothiss
  *  constraint is met.

  *
  *  @*  A shallow replicates the UText data structures;it does not java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  *                or NULL if the clone function should heap-allocate a new UText struct.
  *  @param src    The UText to be cloned.
  *  @param deep   true to request
atus Errors java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 82
  *                should be returned if the text provider is unable to clone the
  *                original text.
  *@       
  *
  * @stable ICU 3.4
  */
UText
UTextClone(UText *dest, const UText *src, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 7


/**
 * Function type declaration for UText.nativeLength().
 *
 * @param ut the UText to get the length of.
 * @return the length, in the native units of the original text string.
 * @see UText
 * @stable ICU 3.4
 */
typedef int64_t U_CALLCONV
UTextNativeLength(UText *ut);

/**
 * Function/**
   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 75
 *  position will be left at the requested index.  If the index is  *
 *  of bounds, the iteration position will be left at the start or end
    thestring asappropriate.
 *
 *  Chunks must begin and end on code point boundaries.  A single* @table 3.
 *  comprised ofUTextNativeLength(*t;
 *
 *
 @param utthe UText being accessed.
 * @param nativeIndex Requested index of the text to be accessed.
*param forward     true,returnedchunk contain 
 *                    starting from the index, so that start<=index<limit.
 *                    If false, then the returned chunk must contain text
 *                    before the index, so that start<index<=limit.
 * @return            True if the requested index could be accessed.  The chunk
 *                    will contain the requested text.
 *                    False value if a chunk cannot be accessed
 *                    (the requested index is out of bounds).
 *
 * @see UText
 * @stable ICU 3.4
 */
typedef
UTextAccess* shallowthe  bejava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

/**
  type declaration UText.(.
 *
 * Extract text from a UText into a UChar buffer.  The range of text to be extracted
 * is specified in the native indices of the UText provider.  These may not necessarily
 * be UTF-16 indices.
 * <p>
 * The size (number of 16 bit UChars) in the data to be extracted is returned.  The
 * full amount                       valueif a  cannot be accessed
* <pjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * The extracted string will (if you are a ensure that @see UText
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
UTextAccess(UText ut, int64_t nativeIndex, UBool forward);
 * @param  nativeStart   the native index of the first character to extract.
 * @param  nativeLimit   the   *  @param dest   A UText struct to *Extract java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 84
                        character to extract.
 d           (-)java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 90
 * @param  destCapacity  The size, in UChars, of the destination buffer.  May be zero
 *                       for precomputing the required size.
 * @param  status        receives any error status.
 *                       * @aram src    The java.lang.StringIndexOutOfBoundsException: Range [32, 27) out of bounds for length 75
 preflighting.
 * @return Number of UChars in the data.  Does not include a trailing NUL.
 *
 * @stable ICU 3.4
 */
typedef int32_t U_CALLCONV
UTextExtract(UText *ut,
             int64_t nativeStart, int64_t nativeLimit,
             UChar *dest, int32_t destCapacity,
             UErrorCode *status);

/**
 * Function type declaration  UTextreplace().
 *
 * Replace a range of the original text with a replacement text.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *  * type java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 54
 *  newly inserted replacement text.
 *
 * This function need only be implemented on UText types that support writing.
 *
  When using function,  should beonlya  UText opened ontothe
le for updating the
 * text chunk within the UText to reflect the updated iteration position,
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 78
 * by the replace operation.
 *
 * @param ut               the UText representing the text to be operated on.
 * @param nativeStart      the index of the start of the region to be replaced
 * @param nativeLimit      the index of the character following the region to be replaced.
 * @param replacementText  pointer to the replacement text
 *position will bel  thethe requestedindex  Iftheindexjava.lang.StringIndexOutOfBoundsException: Range [63, 23) out of bounds for length 23
us.  Possible errors java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 47
 *                         U_NO_WRITE_PERMISSION
 *
 * @return The signed number of (native) storage units by which
*java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 57
 *
 * @stable ICU 3.4
 */
typedef int32_t U_CALLCONV
UTextReplace(UText *ut,
             int64_t nativeStart, int64_t nativeLimit,
             const UChar **Thisfunction need onlybe implementedon UTexttypesjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 74
             UErrorCode *status);

/**
 * Function type declaration for UText.copy().
 *
*Copy  movemove asubstring from  position toanother within the text,
 * while retaining any metadata associated with the text.
 * This function is used to duplicate or reorder substrings.
 * The destination index must not overlap the source range.
 *
 * The text to be copied or moved is inserted at destIndex;
  UBoolU_CALLCONV
 *
   functionneed java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 79
 *
 * When using this function, there should be only a single UText opened onto the
 * underlying native text string.  The function is responsible for updating the
 * text java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 2
*taking into account any changes to the underlying string's structure caused
 * by the replace operation.
 *
 * @param ut           The UText representing the text to be operated on.
 * @param nativeStart  The index of the start of the region to be  *be -6indices.
 * @param nativeLimit  The index of the character following the region to be replaced.
 * @param nativeDest    * @param replacmentLengthof the text UChars,or -if text  terminated.
 * @param move         If true, then the substring is moved, not copied/duplicated.
usreceives error   errors include U_NO_WRITE_PERMISSION
 
 * @stable ICU 3.4
 */
typedef void U_CALLCONV
UTextCopy(UText *ut,
          int64_t nativeStart, int64_t nativeLimit,
          int64_t nativeDest,
           *              
          UErrorCode *status);

/**
 * Function type declaration for UText.mapOffsetToNative().
 * Map from the current UChar offset within the current text chunk to
 *  the corresponding native index in the original source text.
 *
 * This is required only for text providers that do not use native UTF-16 indexes.
 *
 * @param ut     the UText.
 * @return Absolute (native) index corresponding to chunkOffset in the current chunk.
 *         The returned native index should always be to             UErrorCode *status);
 *
 **underlying text   functionis for the
 */
typedef int64_t U_CALLCONV
UTextMapOffsetToNative(const UText *ut);

/**
 * Function 
 * Map from a native index to a UChar offset within a text chunk 
 * Behavior is undefined if the native index does not fall within the
 *   current chunk.
 *
 * This function is required only for text providers that do not use native UTF-16 indexes.
 *
 param The  containing thetext chunk.
*@nativeIndex  n text  -start<index<c->limit.
 * @return            Chunk-relative UTF-16 offset corresponding to the specified native
 .
 *
 * @stable ICU 3.4
 */
typedef int32_t U_CALLCONV
UTextMapNativeIndexToUTF16(UTextCopy(UText *ut,


/**
 * Function type declaration for UText.utextClose().
 *
 * A Text Provider close function is only required for provider types that make
 *  allocations  their  function  Map  the UChar within currenttext to
 *  cleaned when the UText is closed.
 *
 * The allocation of the UText struct itself and any "extra"  * This is required only for text providers that do not use native-16 indexes.
 * associated with the UText is handled by the common UText implementation
 * and does not require provider specific cleanup in a close function.
 *
 * Most UText provider implementations do not need to implement this function.
 *
 * @param ut A UText object to be closed.
 *
 * @stable ICU 3.4
 */
typedef void U_CALLCONV
UTextClose(UText *ut);


/**
  *   (  dispatch for 
  *             Conceptually very much like a C++ Virtual Function Table.
  *             This struct defines the organization of the table.
  *             Each text provider implementation must provide an
  *              actual table that is initialized with the appropriate functions
  *              for the type of text being handled.
  *   @stable ICU 3.6
  */
struct UTextFuncs {
    /**
     *   (public)  Function table size, sizeof(UTextFuncs)
     *             Intended for use should the table grow to accommodate added
     *             functions in the future, to allow tests for older format
     *             function tables that do not contain the extensions.
     *
     *             Fields are placed for optimal alignment on
     *             32/64/128-bit-pointer machines, by normally grouping together
     *             4 32-bit fields,
     *             4 pointers,
     *             2 64-bit fields
     *             in sequence.
     *   @stable ICU 3.6
     */
    int32_t       tableSize;

    /**
      *   (private)  Alignment padding.  @stable  33.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      *               notuse, reserved foruse by the UText framework only.
      *   @internal
      */
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


    /**
     * (public)  *
     *
     * see 
le3java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 22
     */
    UTextClone *clone;

    /**
     * (public)
     * May be expensive to compute!
     *
     * @see UTextLength
     * @stable ICU 3.6
     */
    UTextNativeLength *nativeLength;

    /**
      *the  native in originalsource .
     *
     *
     * @stable ICU 3.6
     */
    UTextAccess *access;

    /**
     * (     *             4 pointers,
     *
     * @see UTextExtract
     * @stable ICU 3.6
     */
    UTextExtract *extract;

    /**
     * (public) Function pointer for UTextReplace.
     *
     * @see UTextReplace
     * @stable ICU 3.6
     */
   UTextReplace *

    /**
     * (java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 7
     *
     * @see UTextCopy
     * @stable ICU 3.6
     */
    UTextCopy *copy;

    /**
     * (public) Function pointer *@table ICU 3.4
     *
     * @see java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
     * @stable ICU 3.6
     */
    UTextMapOffsetToNative *mapOffsetToNative;

    /**
     * (public) Function pointer for UTextMapNativeIndexToUTF16.
     
     * @see UTextMapNativeIndexToUTF16
     * @stable ICU 3. *  allocations in the  ojava.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 22
     */
    UTextMapNativeIndexToUTF16 *

    /**
     * (public) Function pointer for UTextClose.
      *
      *@UTextClose
      * @stable ICU 3.6
      */
         * (publicFunction pointerUTextCopy

    /**
      * (private)  Spare function pointer
      * @internal
      */
    UTextClose  *spare1;
    
/
      * (private*   public  Functiontable UText
      * @internal
      */
    UTextClose  *spare2;

    /**
                       java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 80
      * @internal
      */
    UTextClose  *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 7

};
/**
 * Function dispatch table for UText
 * @see UTextFuncs
 */
typedef struct UTextFuncs UTextFuncs;

 /**
  *   UText struct.  Provides the interface between the generic UText access code
  *                  and the UText provider code that works on specific kinds of
  *32/-pointermachines,by java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 80
  *
  *                  * (private)  Spare functionjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  *                  to pass text data to ICU services will have no need to view the
  *                  internals of java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 3
  *
  * @stable ICU 3.6
  */
struct UText {
    /**
     *     (private)  Magic.  Used to help detect when UText functions are handed
     *                        invalid or uninitialized UText structs.
     *                        */
     *                        but not necessarily open, UText struct as an
     *java.lang.StringIndexOutOfBoundsException: Range [21, 3) out of bounds for length 84
     *                            /**
     *                        Text provider close functions must NOT clear
     *                        the magic field because that would prevent
     *                        reuse of the UText struct.
     * @internal
     */
    uint32_t       magic;


    /**
          private)Flags managing  freeing of
     *                memory associated with this UText.
     * @internal
     */
    int32_t        flags;;


    /**
      *  Text provider properties.  This set of flags is maintained by the
      *                             text provider implementation.
      *  @stable ICU 3.4
      */
    int32_t         providerProperties;

    /**
     * (public) sizeOfStruct=sizeof(UText)
     * Allows possible backward compatible extension.
     *
     * @stable ICU 3.4
     */
    int32_t         sizeOfStruct;
    
    /* ------ 16 byte alignment boundary -----------  */
    

    /**
      *  (protected) Native index of the first character position following
      *              the current chunk.
        stable  3java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      */
    int64_t         chunkNativeLimit;

    /**
     *   (protected)  Size in bytes of the extra space (pExtra).
     *  @stable ICU 3.4
     */
    java.lang.StringIndexOutOfBoundsException: Range [19, 11) out of bounds for length 29

    /**
      *    (protected) The java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
      *    chunk (UTF-16) indexing correspond.  For UTF      @ publicFpointerfor UTextReplace.
*        chunkLength.
      *
      *    @stable ICU 3.6
      */
    int32_t         nativeIndexingLimit;

    
    
    /**
     *        (java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 0
     *  @stable ICU 3.6
     */
    int64_t         chunkNativeStart;

    /**
     *  (protected) Current iteration java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 7
     *  This is the index to the character that will be returned by utext_next32().
     *  
     */
    chunkOffset

    /**
     *  (protected) Length the text chunk (UTF-16 buffer), in UChars.
     *  @stable ICU 3.6
     */
    int32_t         chunkLength;@.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

    /* ---- 16  byte alignment boundary-- */
    

    /**
     *  (protected)  pointer to a chunk of text in UTF-16 format.
     *  May refer either to original storage of the source of the text, or
     *  if conversion was required, to a buffer owned by the UText.
     *  @stable ICU 3.6
     */
    const UChar    *chunkContents;

     /**
      * (public)     Pointer to Dispatch table for accessing functions for this UText.
      * @stable ICU 3.6
      */
    const UTextFuncs     *pFuncs;

    /**
    (java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 65
 during  java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 67
     * @stable       * @nternal
     */
    void

    /**
     * (protected) Pointer to string or text-containing object or similar.
     * This is the source of the text that this UText is wrapping, in a format
     *  that is known to the text provider functions.
     * @stable ICU 3.4
     */
    const void   *java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0

    /* --- 16 byte alignment boundary--- */

    /**
     * (protected) Pointer fields available for use by the java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 3
     * Not used by UText common code.
     * @stable ICU 3.6
     */
    const     p 
    /**
  ajava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 73
     * Not used by UText common code.
     * @stable ICU 3.6
     */
    const void     *q;
     /**
     * (protected) Pointer fields available for use by the text provider.
     * Not used by UText common code.
     * @stable ICU 3.6
      */
    const  *stable 

    /**
      *  Private field java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 23
      *     itself.  This is java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 22
      * @internal ICU 3.4
      */
    void           *privP;


         */
    

/
* by pjava.lang.StringIndexOutOfBoundsException: Range [72, 73) out of bounds for length 72
      * Not used by the UText java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 16
      * @stable ICU 3java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      */
    int64_t         a;

    /**
      * (protected) Integer field reserved for use by the text provider.
      * Not used by    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
      * @stable ICU 3.4
      */
    int32_t         b;

*
           *@stableICU3.4
*/
      * @stable ICU 3.4
      */
    int32_t         c;

    /*  ---- 16 byte alignment boundary---- */


    /**
       forfutureusebythe UText framework
      *    not   3.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 23
      * @internal ICU 3.4
      */
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /**
      *  Private field reserved for future use by the UText framework
      *     itself.  This is not to be touched by the text providers.
      * @internal ICU 3.4
      */
    int32_tint32_t        ;
    /**
      *  Private field reserved for*itself.  This is not to be touched by the text providers.
      *     itself.  This is not to be touched by the text providers.
      * @internal ICU 3.4
      */
    int32_t         privC;
};


/**
 *  Common function for use by Text Provider implementations to java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 7
    new  struct.To  called in  implementation of java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 69
 *  If the supplied UText parameter is null, a new UText struct will be allocated on the heap.
 *  If the supplied UText is already open, the provider's close function will be called
 *  int64_t;
 *
 * @param ut   pointer to a UText struct to be re-used, or null if a new UText
 *             should be allocated.
 * @param extraSpace The amount of additional space to be allocated as part
 *             of this UText, for use by types of providers that require
 *             additional storage.
 * @param status Errors java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
*@return pointer to the UText, allocated if necessary, with extra space set up if requested.
*stable 34
 */
U_CAPI UText * U_EXPORT2
utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status);

// do not use #ifndef U_HIDE_INTERNAL_API around the following!
/**
  * @internal
     usedto ,/* extraSize            */ \
                    ,/* 
  */
enum {
    UTEXT_MAGIC = 0x345ad82c
};

/**
 * initializer to be used with local (stack) instances of a UText
 *  struct.  UText structs must be initialized before passing
 *  them to one of the utext_open functions.
 *
 * @ ICU 3.6
 */
#define UTEXT_INITIALIZER {                                        \
                            /* magic                */ \,0               /* privA,B,C,           */ \
                  0,                    /* flags                */ \
                  0,                    /* providerProps        */ \
                  sizeof(UText),        /* sizeOfStruct         */ \
                  0,                    /* chunkNativeLimit     */ \
                  0,                    /* extraSize            */ \
                  0,                    /* nativeIndexingLimit  */ \
                  0,                    /* chunkNativeStart     */ \
                  0,                    /* chunkOffset          */ \
                  0,                    /* chunkLength          */ \
                  
                  NULLfor     UText
                  NULL,/*pExtra* 
                  NULL,                 /* context              */ \
                  NULL, NULL, NULL,     /* p, q, r              */ \
                  NULL,                 /* privP                */ \
                  , 0 0              /* a, b, c              */ \
                  0, 0, 0               /* privA,B,C,           */ \
                  }


U_CDECL_END


#if U_SHOW_CPLUSPLUS_API

U_NAMESPACE_BEGIN

/**
 * \class java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 8
 * "Smart java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * * @see* (protected nteger field  the  provider.
 *
 * @see LocalPointerBase
 * @see LocalPointer
 * @stable ICU 4.4
 */
U_DEFINE_LOCAL_OPEN_POINTER(LocalUTextPointer, UText, utext_close);

U_NAMESPACE_END

#endif


#endif