Impressum utext.h

// © 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.
*   :  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
**************************************
*   file name:  utext.h
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2004oct06
*   created by: Markus W. Scherer
*/

#ifndef __UTEXT_H__
#define __UTEXT_H__

/**
 * \file
 * \brief C API: Abstract Unicode Text API
 *
 * *
*formats  workwith  services.  ICU normally operates on text that is
 * stored in UTF-16 format, in (UChar *) arrays for the C APIs or as type
 * UnicodeString for C++ APIs.
 *
 * ICU Text Access allows other formats, such as UTF-8*UnicodeString for C++ APIs.
*java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 83
 *
 * There are three general* UTextwrapper and then 
 *
 *     Application Level Use.  This is the simplest usage - applications would
 *     use one of the utext_open() functions on their input text, and pass
 *     the resulting UText to the desired ICU service.
 
 *     Second is usage in ICU Services, such as break iteration, that will need to
      operate on input presented to them as a UText.  These implementations
 *     will  need to use the iteration and related UText functions to gain
 *     access to the actual text.
 *
 *     The third class of UText *access  the text.
 *     UText implementations for the various text storage formats.  An application
 *     or system with a unique text  *     UText implementations for the variousstorage formats.Anapplication
 *     UText provider functions for that format, which will then allow
 *     ICU services to operate on that format.
 *ICU  to operate on that format.
 *
 * <em>Iterating over text</em>
 *
 * Here is sample code for a forward iteration over the contents of a UText
 *
 * \code     ;
 *    UChar32  c;
     UText*ut = whatever();
 *
 *    for (c=utext_next32From(ut, 0 *
 *       // do whatever with the codepoint c here.
 *    *
 * \endcode
 *
 * And here is java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 2
hetext towards beginning
 *
 * \code
 *    UChar32  c;
 *    java.lang.StringIndexOutOfBoundsException: Range [50, 11) out of bounds for length 50
 *     * c
 *    for (c=utext_previous32From(ut, textLength); c>=0; c=utext_previous32(ut*UText    ut *
 *       // do whatever with the codepoint c here.
 *    }
  e
 *
 * <Characters Indexing<em>
 *
 * Indexing into text by UText functions is nearly always in terms of the native
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 78
 * or UTF-32, for example.  When coding to the UText access API, no assumptions
 * can be made regarding the size  * or UTF-,forexample.  When coding to the UText access API, no assumptions
 * 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
= index <=length ofinput text.
 *
 *
 * When an index position is returned from a UText function, it will be
 * 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 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.
 * 
*java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 76
 * by doing a utext_setNativeIndex() followed by a utext_getNativeIndex().
 * If the index is returned unchanged, it was on a code point boundary.  If
 * an adjusted index is returned, the original index referred to the
 * interior of a character.
 *
 * <em>Conventions for *
 *
*java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 81
 * which specifies the UText to be used.  Unless*whichspecifies  UText  used.Unless otherwise noted, the
 * pointer must refer to a valid, open UText.  java.lang.StringIndexOutOfBoundsException: Range [1, 57) out of bounds for length 2
 or pointer is error and
 * will produce undefined results or NULL pointer exceptions.
 * 
 * The UText_Open family of functions can either open an existing (closed)
*UText heapjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * a stack-allocated UText.
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 
 *    char     *s = whatever();  // A utf-8 string 
 *    U_ErrorCode status = U_ZERO_ERROR;
 *    UText    ut = UTEXT_INITIALIZER;
 *    utext_openUTF8(ut, s, -1, &status);
 *    if (U_FAILURE(status)) {
 *//error handling
 *     * eitherby UTEXT_INITIALIZER or by been  heap-
 *        // work with the UText
 *    }
 * \endcode
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
*java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 79
 * either by the UTEXT_INITIALIZER, or by having been originally heap-allocated
 *i ."
 * heap-allocate and java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 *
 */



java.lang.NullPointerException
#include "unicode/uchar.h"
#if   C for creating UText wrappers around various kinds of textstrings.
#include "unicodejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
#include "unicode/rep.h"
#include "unicode/unistr.h"
#include *
#endif


U_CDECL_BEGIN

struct UText;
defforby o.PassingNULLwill theopen to


/***************************************************************************************
 *
 *   C Functions for creating UText wrappers around various kinds of text strings.
 *
 ****************************************************************************************/


/**
 UText instances.
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 66
  * <p>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *   the storage associated with the utext 
  *   If the UText storage originated java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 2
  *   a local or static instance, the storage will not be deleted.
  *
  *   An open UText can be reset to refer to new string by using one of the utext_open()
  *   functions without first closing the UText.  
*
 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 38
   @eturn    NULL if the UTextstruct was close. Ifthe struct
  *  *Anopen *asubsequent utext_openjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  *            returned by this function, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 24
              subsequent utext_open.
  *
  * @stable ICU 3.4
  */
  
utext_close(*wasoriginally providedofa butvalidjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

/**
  Open a only UText implementation unicode  character \uFFFD.java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
 * 
 * \htmlonly
*invalidUTF- java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 62
 * a sequence utext_closeUText *ut)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 replacement character,  
 * Any other illegal bytes will each be replaced by a \uFFFD.
*\
 * 
 * @param ut     Pointer to   a sequence bytes that  the  a  -8string.
 *               If non-NULL, must refer to an initialized UText struct, which will then
 *               be reset to reference the specified UTF-8 string.
 * @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 .
 * @
 * @return       A pointer to 
 *               will always be used and returned.
 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
utext_openUTF8(UText *ut, constparamut     Pointer  a UText struct  If NULL,anew UText willbe java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82


/**
*a only UText for *string.
 * 
 * @param ut     Pointer to a UText struct                 reset to reference the specified string.
 *               If non-NULL, must refer to an initialized UText struct, which will then
 *                to the java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 66
utext_openUTF8(UText *ut,const char *s, int64_t length, UErrorCode *status);
 * @param length The number of UChars in the input string, or -1 if the string is
 *               zero terminated.
*@param  Errors  returned here.
 tothe  aallocated UText was provided,
 #f U_SHOW_CPLUSPLUS_API
 * @stable ICU Open  UText for a- UnicodeString.
 */
U_EXPORT2
utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status);


#if U_SHOW_CPLUSPLUS_API
/**
 * Open a writable UText for a non-const UnicodeString. 
 * 
 * @param ut      Pointer to a UText struct.  If nullptr, a new UText will be created.
 *                 If non-nullptr, must refer to an initialized UText struct, which will then
e specifiedinput string.
 * @param s       A UnicodeString.
 * @param status Errors are returned here.
 * @return        Pointer to the UText.  If a UText was java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 3
 *                 will always be used and returned.
java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 18
 */
  
utext_openUnicodeString(UText *ut, icu::*               be reset to reference the specified.


/**
 * Open a UText   @ICU.4
 * 
 * @param ut    Pointer to a UText struct.  If nullptr, a utext_openUnicodeString(UText *ut, icu::UnicodeString *s, UEr *status);
 *               If non-nullptr, must refer to an initialized UText struct, which will then
 beresetjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 66
 * @param s      A const UnicodeString to be wrapped.
 * @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.
 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
utext_openConstUnicodeString(UText *ut, constparam rep     Replaceable textobject *will java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 50


*
  a UText implementation java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 42
 * @param ut    Pointer to a UText struct.  If nullptr, a new UText will be created.
 *               If non-java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
 *               be reset to                be reset to referencespecified replaceable java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 * @ @param java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 42
* pstatus Errors arereturnedhere.
 * @return                       java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 50
 *               will always be used and returned.
 * @see Replaceable
 *stable 3.4
 */
U_CAPI java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
utext_openReplaceable(UText *ut, icu::Replaceable *rep, UErrorCode *status);

/**
*Opena  UText implementationICU CharacterIterator
 * @param ut    Pointer to a UText struct.  If nullptr, a new UText will be created.
 *               If non-*               be reset tothe java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 19
 *               be reset to reference U_CAPI *U_EXPORT2
 * @param ci     A Character Iterator.
 * @param status Errors     Clone a UText.  This ismuch eturnPointerto theUText.  If a UText was supplied as input, this
 * @java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 *               will always be used and returned.
 * see Replaceable
 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
utext_openCharacterIterator(UText *ut, icu::CharacterIterator *ci, UErrorCode *status);

#endif


/**
  *  Clone a UText.  This is much like opening a UText where   *  A deep clone will copy both the UText data structures and thetext.
  *  another UText.
 
  *  A deep clone will copy both the UText data structures *
  *  The original and cloned UText will operate completely independently; modifications
  *  made to the text in one will not affect the other.  Text providers are not
  *  required to support deep clones.  The user of clone() must check the status return
  *  and be prepared to handle failures.
  *
  *  The standard UText implementations for UTF8, UChar *, UnicodeString and
  *  Replaceable all support deep cloning.
  *
  *  The UText returned from   *  modified.
  *  provider is able to support writing, even if the source UText had been made
-java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 45
  *
  *  A shallow clone replicates only the     text are expected to be used either on the original or the cloned UText.
  *  a copy of the underlying text.  Shallow clones can *
*multiple  in  text string that isnot 
  *  modified.
  *
  *  A shallow clone operation will not*write operations mustbe avoided while than oneUText exists thatrefer
  *  as memory allocation failures.
  *
  *  Shallow UText clones should be avoided if the UText functions that modify  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 74
  *  text are expected to be used    shallow  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 81
  *  Any such modifications  can cause unpredictable behavior.  Read Only
  *  *
  *  disabling text modification via the cloned UText.
  *
  *  A shallow clone made with the readOnly parameter == false will preserve the 
  *  utext_isWritable()
 java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 81
  *  to the same underlying text.
  *
  *  A UText and its clone may be safely concurrently accessed by separate threads.
      src    TheUTextto cloned.
    *  write access with deep
  *  It is the responsibility of the Text Provider to ensure that this thread safety
  *  constraint is met.
  *
  *  @param dest   A UText struct to be filled in with the result of the clone operation,
  *                or NULL if the clone function should heap-allocate a new UText struct.
  *                If non-NULL, must refer to an already existing UText, which will then
  *                be reset to become the clone.
 *@java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 42
  *  @param deep   true to  twoobjects java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  *  @param readOnly  *@aram to  adeep ,false for  clone.
  *                underlying text    @param readOnly true to request that the cloned UText have read only access to the 

  *  @param status Errors are returned here.*will  if isunableto the
  *                will be returned if the text provider is unable to clone the
  *                original text.
  *  @return       The newly created clone, U_CAPI *U_EXPORT2
  *  @stable ICU 3.4
  */
U_CAPI U_EXPORT2
utext_clone(UText *dest, const UText *src

  if are iterating over the same text, and
/**
  *  Compare two UText objects for equality.
  *  UTexts ther or  ofthe parameters areNULL java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  *    have the same iteration position within the text.
 java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 35
  *
  *  @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.
*stable ICU 3.6
  */
U_CAPI UBool U_EXPORT2
utext_equals(const UText *a, const UText *b);


/*****************************************************************************
 *
 *   Functions to 
 
 *****************************************************************************/

/**
  * Get the length of the text.  Depending on the characteristics
  * of the underlying text representation, this may be expensive.  
@  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  *
  *
  *@aramut  the   be java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  * @return the length of the text, expressed in native units.
  *
  * @stable ICU 3.4
  */

utext_nativeLength(UText *ut);

/**
 *  Return true if calculating the length of java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 3
 *  Finding the length of NUL terminated strings is considered to be java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 49
 *
 *  Note that the *
 *  as the result of other operations on a UText.
 *  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 true if determining the length of the text could be time consuming.
 * @stable ICU 3.4
 */
U_CAPI UBool U_EXPORT2
utext_isLengthExpensive(const UText *ut);

/**
 * Returns the code point at the requested index,
 *   will t java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 89
 *
 * If the specified index * the complete code point will be.
*      of UTF8sequence,for  
 * the complete code point will be returned.
 *
 * The iteration position will be set to the start of the returned code point.
 *
 * unction roughly equivalent to  sequence
 *     utext_setNativeIndexvalue the index zero which )
 *    utext_current32();
 * (There is a subtle difference if the index is out*return U_SENTINELvaluejava.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 38
 (egative   the indexn,
 * will return the char at zero.  utext_char32At(negative index), on the other hand, will
 * return the U_SENTINEL value of -1.)
  
 * @param ut the text to be accessed
 * @param nativeIndex the native index of the character to be java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 18
 *        ar32 U_EXPORT2
 *        to the start of the character.
 * @return the code point at the specified index.
 * @stable ICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
UText* )


/***
 *
 *Getthe pointatthe java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 18
 * or U_SENTINEL (-1) if the iteration has reached the end of
  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 18
 *
 *
  @the  current java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 67
 * @stable 
 */
U_CAPI UChar32U_EXPORT2
utext_current32(UText *ut);


/**
 * Get the code point at the current iteration position of the UText, and
 * advance the position to the first index following the character.
 *
 * If the position is at the end of the text (the index following
 * the last character, which is also the length of/*java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return U_SENTINEL (-1) and do not advance the index. 
 *
Thisis  operation
 *
 * An inline macro version of this function, UTEXT_NEXT32(), 
 * is available for performance critical use.
 *
 * @param ut the text to be accessed   Aninline versionjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    iterator position to the character (code point) whose
 * @see UTEXT_NEXT32
 * @stable ICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
* thejava.lang.StringIndexOutOfBoundsException: Range [32, 28) out of bounds for length 63


/**
 *  Move the iterator position to the character (code point) whose
 *  index precedes the current position, and(java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 28
 *  This is a pre-decrement operation.
 *
 *If theinitial is  startof  (ndex  0)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 *  return U_SENTINEL (-1), and  *
 *
 *  An macro  of function, (, 
 *  is available for performance critical use.
 *
*  @aram ut the textto 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_previous32Textut;


/**
  *   Leave the iterationindex at thestart fthe following point.
  * Leave the iteration index at the start of the following code point.
  *
  * This function is the most efficient and convenient way to
  * begin a forward iteration.  The results are identical to the those
  * from the sequence
  *
  *    utext_setIndex();
  *    utext_next32();
  * \endcode
  *
  *  @param ut the text to be accessed.
  *  @param nativeIndex Iteration index, in the native units of the text provider.
*@eturn point  startsator  java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
unds.
  * @stable ICU 3.4
  */
U_CAPI UChar32 U_EXPORT2
utext_next32From(Text ut int64_tnativeIndex)



/**
  * Set the iteration index, and return the code point preceding the
  * one specified by the initial index.  Leave the iteration position  *         U_SENTINEL(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * at the start of the returned code point.
  *
*This  is the  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 61
  * begin a backwards iteration.
  *
  *@aram  the  tobe .
  * @param nativeIndex Iteration index in the native units of the text provider.
  * @return Code point preceding the one at  *the  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  *         or U_SENTINEL (-1) if it is out of bounds.
*
  * @stable ICU 3.4
  */
U_CAPIjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 24
utext_previous32From(UText   @aramjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 19

/**
   java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 65
  * 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
  * the corresponding UChar (UTF-16) index.
  * The returned position will always be aligned to a code point boundary. 
  *
  * @param ut the text to be accessed.
   returnjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 81
  * @stable ICU 3.4
  */
U_CAPI int64_t U_EXPORT2
utext_getNativeIndex(const UText *ut);

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * Set the current iteration position to the nearest code point
 * boundary at or preceding the specified index.
 * The index is in the native units of the original input text.
 * If   @aramthe toaccessed
 * the range of the input text.
 * <p>
   willusuallybemore   begin
 * using the functions utext_next32From() or utext_previous32From()
 * rather than setIndex().
 * <p>
 * Moving the index position to an adjacent character is best done
 * with  * easily knowable
 * Attempting to do direct arithmetic on the index*
 * complicated by the fact that the size (in native units) of a
 * character  *@utthetextto  .
 * (UTF-8, UTF-16, UTF-32, arbitrary codepage), and is not
 * easily knowable.
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
ut the text to be accessed.
 * @param nativeIndex the native unit index of the new iteration position.
 * @stable ICU 3.4
 */
U_CAPI void java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 53

/**
 * Move the iterator position by delta code points.  The number of code points
 * is a signed number; 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
 * no further forward than to utext_nativeLength().
  *nofurtherforward than to utext_nativeLength().
 *
 * @aram  thetext to be accessed.
 * @param delta the signed number of code points to move the iteration position.
 *@eturntrue if the position could be moved the requested number of positions while
 *              staying within the range [0 - text length].
 * @ * @stable the factthat size inative units) of a
 */
U_CAPI UBool U_EXPORT2
utext_moveIndex32(UText * int32_t delta);

/**
 * Get *
 * If the iteration position is already at the start of  @aram  the  be accessed.
 * is returned.
 * The value returned is the same as that obtained from the following sequence,
 * but without the side effect of changing the iteration position.
 *   
 * \code
 *    UText  *ut = whatever;
 *      /
*utext_previousut)
 *    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 8
 * \endcode
 *towards  the start the.
 p>
 *   native  * The index is moved<codedelta<code>codepoints
 
 * @param ut the text to be accessed
 * @return the native index of the character preceding the current index position,
             c isat  start the text.
*@ICU 36
 */
U_CAPI int64_t U_EXPORT2
 *         or zero if theorzero if thecurrent position is at the start of the text.


/**
 *
 * Extract text from a UText into a UChar buffer.  The range of text to be extracted
 * @34
 * /
 * <p>
*size   it  data to extractedreturned.The
*full of UChars  returned, evenwhen java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 79
 toosmalljava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 * <p>
 * The extracted string will (if you are a user) / must (if you are a text provider)
 * be NUL-terminated if there is sufficient space in the destination buffer.  This
 * terminating NUL is not included in the returned length.
 * <p>
 * The iteration index is left at the position following the last  * be NUL-terminated if there is sufficient space in the destination.  This
 *
 * @param  ut    the UText from which to extract       .
 * @param  nativeStart the native index of the first character to extract.\
 of 
                 bepinned to be within 0 <= index <= textLength
 * @param  nativeLimit the native string index of the *   native index of the character most recently returutext_next().
 **@the * @param  nativeLimithenative java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 81
 *               it will be pinned to be within 0 <= index <= textLength.
 *               nativeLimit must be >= nativeStart.
 * @param  dest  the UChar (UTF-16) buffer into which the extracted text is placed
pacity   size  ,fjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 85
 *               for precomputing the required size.
 * @param  status receives any error status.
 *         U_BUFFER_OVERFLOW_ERROR: the extracted text was truncated because the 
*buffer wastoo small.Returns  of UCharsforpreflighting.
 * @return Number of UChars in the data to be java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 3
 *
 * @stable ICU 3.4
 */
U_CAPI int32_t U_EXPORT2
*
             int64_t nativeStart, int64_t nativeLimit,
             UChar *dest, int32_t destCapacity,
             UErrorCode  *



/************************************************************************************
 *
*#define  nline versionsofselected performance-critical text access functions
 *          Caution:  do not use auto              int64_tnativeStart,int64_t nativeLimit,
 *                    as parameters to these macros.
 *
 *          For most use,  <>
 *          normal, oninline  a better  The  code
 *          will be smaller, and, if the need ever *  #efine inline versions of selected performance-critical text access functions
 *
 *          These are implemented as #defines rather than real functions
 *          because there is no fully portable way to do inline functions in plain C.
 *
 ************************************************************************************/

#ifndef U_HIDE_INTERNAL_API
/**
 * inline version of utext_current32(), for performance-critical situations.
 *
position  of the .
 * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 * text.
 *
 * @internal ICU 4.4 technology preview
 */
#define UTEXT_CURRENT32(ut)  \
    ((ut)->chunkOffset < (ut)->chunkLength && ((ut)->chunkContents)[(ut)->java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 69
    ((ut)->chunkContents)[((ut)->chunkOffset)] : utext_current32*@aramnativeLimitthe string thepositionfollowing the last
#endif  /* U_HIDE_INTERNAL_API */

/**
 * inline version of utext_next32(), for performance-critical situations.
 *
 * Get the code point at the current iteration position of the*/
 * advance the     (ut->chunkOffset *               native must > ativeStart.
 * This a -increment operation.
 * Returns U_SENTINEL (-1) if the position is at the end of the
 e   utext_next32(,  performance-critical situations.
 *
 * @stable ICU 3.4
 */
#define UTEXT_NEXT32(ut)  \
    ((ut)->chunkOffset < (ut)->chunkLength && ((ut)->chunkContents)[(ut)->chunkOffset]<0xd800 ? \
    ((ut)->chunkContents)[((ut)->chunkOffset)++] : utext_next32(ut))

/**
 2() or java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 77
 *
 *  Move the iterator position to the character (code point) whose
 *  index precedes the current position, and return that character.
 *  This is a pre-decrement operation.
   java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 73
 *
 * @stable ICU 3.4
 */
#define UTEXT_PREVIOUS32(ut)  \
    ((ut)->chunkOffset *
[(->hunkOffset1 <0xd800?\
          (ut)->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 18

/**
  *  inline version of utext_getNativeIndex(), for performance-critical situations.
  *
   Getthe iterator position, which can range java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 47
  *
sition  a nativeindex java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  * may have (possibly UTF-8 for/************************************************************************************
*the corresponding UChar (UTF-) index.
  * The returned position will always be  (t->chunkContents[-- java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 76
  *
  * @stable ICU 3.6
  */
#define UTEXT_GETNATIVEINDEX(ut)                       \
    ((ut)->chunkOffset <= (ut)->nativeIndexingLimit?   \
 java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        (-pFuncs-mapOffsetToNative() java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

/**
  *  inline version of utext_setNativeIndex(), for performance-critical situations.
  *
 b ligned toa  point boundary.
  * 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.
  *
   stableICU .java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  */
#define UTEXT_SETNATIVEINDEX(ut, ix) UPRV_BLOCK_MACRO_BEGIN { \
_= ()-(ut->hunkNativeStart java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    if (__offset>=0 && __   t java.lang.StringIndexOutOfBoundsException: Range [23, 16) out of bounds for length 64
        (ut)->chunkOffset=(int32_t)__offset; \
    } else { \
        utext_setNativeIndex((ut), (ix)); \
       }\
} UPRV_BLOCK_MACRO_END



/************************************************************************************
 *
 *   Functions related to writing or modifying the text.
     ()>chunkContents)((t)>chunkOffset] :utext_current32(ut))
 *   modify a read-only java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 *
 ************************************************************************************/


 *   These will work only with modifiable UTexts.  Attempting toworkonly  iteration positionof theUText,and
 *  Return true if the text can be written (modified) with utext_replace() or
 *    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 63
 *  be of a type that supports writing and the   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 70
 *
 *  Attempting to modify text when java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 3
 *(* java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 75
*  that attempted .
 *
 *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
fthet  
 *
 * @see    utext_freeze()
 * @see    utext_replace()
 * @see    utext_copy()
 *   rjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 42
 *
 */
U_CAPI UBool U_EXPORT2 @    java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 26
utext_isWritable(const UText *ut);


/**
  * Test whether there is meta  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * @see Replaceable::hasMetaData((t->chunkOffset >0& \
  *
  * param ut  UTextjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  * @return true if the java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  * @stable ICU 3.4
  */
U_CAPI UBool U_EXPORT2
utext_hasMetaData(const UText *ut);


/**
 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 64
 *
Leavesthecurrent iteration position at the position following the
*inserted replacement java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
types thatsupport writing,
 * that is, ones where utext_isWritable() returns true.
 *
 * When  *
 * underlying native text string.  Behavior after a replace operation
 * on a  /
fied string.
 *
 * @param ut               the UText representing the text to be operated on.
 * @param nativeStart      the native index of the start of the region to be replaced
 * @param nativeLimit      the native index of the character following the region to be replaced.
 * @param replacementText  pointer to the replacement text
 * @param    boundary at or preceding the specified index.
 * @param status           receives any error status.  Possible errors include
 *                         U_NO_WRITE_PERMISSION
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @return The signed number of (native) storage units by which
xpanded or contracted.
 *
 *     __offset  ix)-ut)>; java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 */
U_CAPI
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
             int64_t nativeStart,
             UChar replacementText int32_treplacementLength,
             UErrorCode *status);



/**
 *
 * Copy or move a substring from one position to another within the  *
 * *
 * 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;
 * it does not  *  utext_copy(). the text to be writable, the text provider must
 *
 * The iteration position is left following the newly inserted text
 * at the destination position.
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
 * This function is only available on*@aramnativeStart    ofthe thejava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 2
  ,where utext_isWritable)returns true.
 *
 * When using this function, there should be only a single UText opened onto the
 * underlying native text string.  Behavior after a copy operation
 * on  *@  UBool 
 *
 *
 * @param ut           The UText representing the text to be operated on.
 * @param nativeStart  The native index  * sReplaceable:hasMetaData(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 * @param nativeLimit          int64_t * @return true if the includes meta data.
 *                     to be copied.
 * @param destIndex    The native destination index tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *                     copied or moved.
 * @param move         If true, then java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 2
 * @param status       receives any error status.  Possible errors include U_NO_WRITE_PERMISSION
 *                       
 * @stable ICU 3 *bymeans   java.lang.StringIndexOutOfBoundsException: Range [39, 36) out of bounds for length 51
 */
U_CAPI void U_EXPORT2
*
* the frozen wrapperbe  that.*underlyingstring.  java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 69
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 28
          UBool move,
          UErrorCode*@ java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 77


/**
  *  <p>
lying
  *  by means of functions operating on this UText.
  *  </p>
  *  <p>
  *  Once frozen, a UText can not be unfrozen.  The intent  @aramutThe UText to frozen
 void 
  *  </p>
  *  <p>
  *  Caution:  freezing a UText will disable changes made@java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 18
   java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 78
   java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 87
  /**
 cansync UText java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
  *  </p>
  *
  *  @param ut  The UText java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
  *  @see   utext_isWritable()
  *  @stable ICU 3.6
  */
U_CAPI void U_EXPORT2
U *)


/**
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 49
 *
  s UText
 * @stable ICU 3.4
 */
enum {
    /**
     * It is potentially time   isjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 22
     */
    UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 75
    /**
     * Text chunks remain valid and usable until the text object isjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     * deleted, not just until the       java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 68
     *       When closing  UText,theassociatedtextmust
     *  @java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 84
     */
    UTEXT_PROVIDER_STABLE_CHUNKS = 2,
    /**
     * The provider supports modifying the text via the replace() and copy()
*java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
     * @see Replaceable
     @.4
     */
    UTEXT_PROVIDER_WRITABLE = 3,
    /**
*ismeta java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 51
     * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * @stable ICU 3.4
     */ 
    UTEXT_PROVIDER_HAS_META_DATA = 4,
    /**
     * Text provider owns the text storage.
  occursjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 68
     *  When closing the UText, the associated text must
     *  also be closed/deleted/freed/ whatever is appropriate.
     * @stable ICU 3.6
     */
java.lang.StringIndexOutOfBoundsException: Range [33, 29) out of bounds for length 33
};

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * Function type declaration for UText.clone().
  *
  *  clone a   *  @param ut java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 39
  *  another UText.
  *
  *  A deep clone will    @ICU36
  *  The original and cloned*java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
*    java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 79
  *  required to support deep clones.  The user of clone() must check the status return
  *  and be prepared to handle failures.
  *
   clone replicatesonly UTextdatastructures doesnotmake
  *  a copy of the  see
  *  have * @stable ICU 3
  *  modified.
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    shallowcloneoperationmust not fail fortruly exceptional conditionssuch
  *  as memory allocation failures.

  *     *@atus returnedhere  deep clones,U_UNSUPPORTED_ERROR
  *  This is true for both shallow and deep clones.
  *  It is the responsibility of the Text Provider to ensure that this thread safety
  *  constraint is met.

  *
       struct   java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 89
  *                or NULL if thetypedef  
  *  @param src    The UText to be cloned.
  *  @param deep   true to request
   .java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 3
  *                should be returned if the text provider is unable to clone the
*originaltext
  *  @     * @stable  3.
*
*stable  .java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  */
typedef UText * U_CALLCONV
UTextClone(UText *dest, const      s java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 38



 *   java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 75
 
 * @param ut the UText to get the length of.
 * @return the length, in the native units of the original text string.
 * @see UText

 */
typedef int64_t U_CALLCONV
UText *)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 * @param ut          the UText being accessed.           java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 47
 * Function type declaration for  *
 *  containing the text at a requested a UText  *@ forward     If   returned must containtext
 *  position will be left at the requested index.  If the index is out
 *  of bounds, the iteration position will be left at the start or end
 *  of the string, as appropriate.
 *
 *  Chunks must begin and end on code point boundaries.  A single code point
 *  comprised of multiple storage units must never span a chunk boundary.
 *
 *
 *typedef UBool*
 * index of  textto be accessed.
 * @param forward     If true, then the returned chunk must contain text
 *                    starting from the index, so that start<=index<*Function declarationfor extract()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
*If ,then returned  mustcontain
 *                    before the index, so that start<index<=limit.
 * @return            True if the requested index java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 6
 *                    will contain the requested text.
*False   achunk be
 *                    ( *<>
 *
*@java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 13
 * @stable ICU 3.4
 */
typedef UBool U_CALLCONV
*java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 59

/**
 * Function type declaration for UText.extract().
 *
  aintoa    text
 **                       java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 46
 *beUTF-16 .
 * <p>
 * The size (number of 16 bit UChars) in the data to be extracted is returned.  The
  whenthe  size isjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 * <p>
 * The extracted string will (if you are a user) / must (if you are a text providerjava.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 74
 * be NUL-terminated if there is sufficient space in the destination buffer.
 *
 * @param  ut            the UText from which to extract data.
 * @param  nativeStart   the native index of the first character to extract.
 *
 *                       character *
 * @param  dest          the UChar (UTF-16) buffer into which the extracted text java.lang.StringIndexOutOfBoundsException: Range [0, 83) out of bounds for length 70
 * @param  destCapacity  The size, in UChars, of the destination java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 2
 *                       for precomputing the required  * underlying native text string.  The function is responsibupdatingthe
 * @param  status        receives any error status.
 *                       If  *taking into account any changes to the underlying string'  @table ICU 3.4
 *                       preflighting.
 * @return Number of UChars in the data.(UText *;
 *
 * @stable ICU 3.4
 */
typedef int32_t U_CALLCONV

             int64_t nativeStart, int64_t nativeLimit,
             UChar *dest, int32_t destCapacity,
             UErrorCode *status);

/**
 * Function type declaration for UText.replace().
 *
 * Replace a range of the original text with a replacement text.
 *
 * Leaves the current iteration position at the position following the *@ uttheUText
 *  newly inserted replacement text.
 *
   function only beimplemented  UText types                        the index,=index<java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 74
*
 * When using this function, there should be only a single UText opened onto   Copyor   substringfromone to java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 73
 * underlying native text string.  The function is responsible for updating the
 * text chunk within the UText to reflect the updated iteration position,
 * 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.
  paramthe    be 
 * @param nativeLimit      the index of the character following the region to be replaced.
 * @param  * The size (number  )inthed  extracted   
 length of replacement text in  - the isNUL java.lang.StringIndexOutOfBoundsException: Index 105 out of bounds for length 105
 * @param status           receives any error status.  Possible errors include
 * * @param stat       any status.Possible java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 96
 *
 * @return The signed number of (native) storage units by which
 *         the length of the text expanded or contracted.
 *
 * @stable ICU 3.4
 */
typedef
UTextReplace(UText *ut,
             int64_t nativeStart, int64_t nativeLimit,
             const UChar *replacementText, int32_t replacmentLength,
             UErrorCode *status);

/**
*java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 46
 *
 * 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: Index 31 out of bounds for length 2
 index java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 59
 *
 * The text to be copied or moved is inserted at destIndex;
 * it does not replace or overwrite any java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 27
 *
 * This function need only be implemented for UText types that support writing.
 *
 * When using this function, there should be only a single UText opened onto the
  native string.The function responsible updating 
 * text chunk within the UText to reflect the updated iteration position,
 * taking into account any changes to the underlying string's structure caused
 * by the replace operation.
 *
 * @param ut           The UText java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 2
 * @param nativeStart  The index of the start of the region to be copied or moved
 * @param nativeLimit  The index of the character following the region to be replaced.
 * @param nativeDest   The destination index to which the source substring is copied or moved.
 * @param move         If true, then the substring is moved, not copied/duplicated.
 * @param status       receives any error status.  param nativeIndexAbsolute (ative)text index,chunk->tart=index=hunk>java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
 *
 * @stable ICU 3.4
 */
typedef void U_CALLCONV
UTextCopy
          int64_t nativeStart, int64_t nativeLimit,
          int64_t nativeDest,
          UBool move,
          UErrorCode *status);

/**
 * Function type declaration for UText.mapOffsetToNative().
*Mapfromjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 69
 *  the corresponding native index in the original source text.
 *
 UTF16indexes.
 *
 * @param ut     the UText.
 * @return Absolute (native) index corresponding to chunkOffset in the current chunk.
 *         The returned native index should always be to a code point boundary.
 
 * @stable ICU 3.4
 */
typedef int64_t U_CALLCONV
UTextMapOffsetToNative(const UText *ut);

/**
 * java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
 * 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  Copy move java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 0
 *
 * @param ut  *   (ublic)Function dispatchtable forUText.
 * @param nativeIndex Absolute (native) text index, chunk->start<=index<=chunk->limit.
 * @return            Chunk-relative UTF-16 offset corresponding to the specified native
 *                    index.
 *
 * @stable ICU 3.4
 */
typedef 
UTextMapNativeIndexToUTF16(const UText *ut, int64_t nativeIndex);


/**
 * Function type declaration for UText.utextClose().
 *
 * A Text Provider close function is only required for provider types that make
 *  allocations in their open function (or other functions) that must be 
 *  cleaned when the UText  underlying native    function  for  the
 *
 * The allocation of the UText struct itself and any "extra" storage
 * associated with the UText is handled by the common UText implementation
 * and does not require provider specific cleanup in a close function.
 *
 * java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 31
 *
 * @param ut A UText object to be closed.
 *
*@stable ICU 34
 */
typedefDo  reserved java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 78
UTextClose(UText *ut);


/**
  *   (public)  Function dispatch table for UText.
  *             Conceptually very much like a C++ Virtual Function Table.
  *     *@seeUTextClone
  *             Each text provider implementation must provide typedef      * @stab ICU .6
  *              actual table that is initialized with the appropriate functions
  *              for the type of java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 7
  *   @stable ICU 3.6
  */
struct UTextFuncs {
    /**
     *   (public)  Function table size, sizeof(UTextFuncs)
*foruseshouldthe java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 78
     *             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,
java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 30
     *             2 64-bit fields
     *             in sequence.
     *   @stable ICU 3.6
     */
    int32_t       tableSize;

    /**
      *   (private)  Alignment padding.
      *              Do not use, reserved for use by the UText framework only.
      *   @internal
      */
    int32_t       reserved1 UTextReplace*eplace;


    /**
     * (public) Function pointer for UTextClone
     *
     * @see UTextClone
     * @stable ICU 3.6
     */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

    /**
     * (public) Function pointer for UTextAccess.
     *
     * @see UTextAccess
     * @stable ICU 3.
     */
    *

    /**
     * (public) Function pointer*
     *
     * @see UTextExtract
     * @table 3
     */
tract

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

    /**
)  pointer for .
     *
     * @see UTextCopy
     * @stable ICU 3.6
     */
    UTextCopy *copy

    /**
         /**
     *
     * @see UTextMapOffsetToNative
     * @stable ICU java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 17
     */
    UTextMapOffsetToNative *mapOffsetToNative;

    /**
     * (public) Function pointer for UTextMapNativeIndexToUTF16.
     *
     * @see UTextMapNativeIndexToUTF16
     * @stable ICU 3.6
     */
    UTextMapNativeIndexToUTF16 *mapNativeIndexToUTF16;

    /**
     * (ublic) Function pointer for UTextClose.
      *
      * @see UTextClose
      * @stable ICU 3.6
      */
    UTextClose  *close;

    
      * (private)  Spare function pointer
      @
      */
    UTextClose       *function tables that do not contain the extensions.
    
    *
      * (private)  Spare function pointer
      * @internal
      */
    UTextClose  *spare2;

    /**
       pointer
      * @internal
      */
    UTextClose  *spare3;

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

 /**
  *   UText struct.  Provides the interface between the generic UText access code
  *                        *              Do not use, reserveduse UText only.
  *                  text  (UTF-8, noncontiguous UTF-16, whatever.)
  *
  *                  Applications 
  *                  to pass text data to ICU services will have no need to view the
   internals of the UTextstructs that they open.
  *
  * @stable ICU 3.6
  */
struct UText {
    /**
     *     (private)  Magic.  Used to help detect when UText functions are handed
     *                        *(private  for the allocation and java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 70
     *                        utext_openXYZ() functions take an initialized,
     *                        but not necessarily open, UText struct as an
     *                        optional fill-in parameter.  This magic field
     *                        is used to check for that initialization.
     *                        Text provider close functions      @ee 
     *                        the magic field because that would prevent
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*@internal
     */
    uint32_t       magic;


    /**
     *     (private)  Flags for managing the allocation and 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.
     *
* *(   
     */
    int32_t         sizeOfStruct      *    willbeequal to
    
    /* ------ 16 byte alignment boundary -----------  */
    

    /**
*java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
      *              the current chunk.
      *  @stable ICU 3.6
      */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    /**
     *   (protected)  Size in bytes of the extra space (pExtra).
     *  @stable ICU 3.4
     */
    int32_t        extraSize;

    /**
      *    (protected) The highest chunk int32_t         chunkOffset;
      *    chunk (UTF-16) indexing correspond.  For UTF-16 sources, value
      *    will be equal to chunkLength.
*
      *    stable ICU 36
      */
    int32_t         nativeIndexingLimit;

    /* ---- 16 byte alignment boundary------ */
    
    /**
     *  (protected) Native index of the first character in the text chunk.
     *  @stable ICU 3.6
     */
    int64_t         chunkNativeStart;

    /**
     *  (protected)      @ee 
     *This the to  that be returned by utext_next32(.
     *  @stable ICU 3.6
     */
    int32_t         chunkOffset;

    /**
     *  (protected) Length the text chunk (UTF-16 buffer), in UChars.
     *  @stable ICU 3.6
     */
    int32_t         chunkLength;

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

    
     *   *  (rotected)  java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 8
     *  May refer either to original storage of the source of the text, or
     *  if conversion was required, to a java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 24
     *  @stable ICU 3.6
     */
    const UChar    *chunkContents;

     /**
      * (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      * @stable ICU 3.6
      */
    const UTextFuncs     *pFuncs;

    /**
     *  (protected)  Pointer to additional space requested by the
     *               text provider during the utext_open operation.
     * @stable ICU 3.4
     */
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 7

    /**
     * (protected) Pointer to string or text-containing object or similar.
     * This is the source of the text that this UText is     java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
     * that is known the text  unctionsjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
     * @stable ICU 3.4
     */
    const void   *context;

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

    /**
     * (protected) Pointer fields available for use by the text provider.
     * Not used by UText common code.
     * @stable ICU 3.6
     */
    const void     *p; 
    /**
     * (protected) Pointer fields available for use by the text provider.
     * Not used by UText common code.
     * @stable ICU 3.6
     */
    const void     *q;
     /**
 text provider.
     * Not used by UText common code.
     * @stable ICU 3.6
      */
    const void     *r;

    /**
      *  Private field reserved for future use by the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      *     itself.  This is not to be touched by the text providers.
      * @internal ICU 3.4
      */
    void           *privP;


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

    /**
      * (protected) Integer field reserved for use by the text provider.
      * Not used by the UText framework, or by the client (user) of the UText.
      * @stable ICU 3.4
      */
    int64_t         a;

    /**
      * (protected) Integer field reserved for use by the text provider.
      * Not used by the UText framework, or by the client (user) of the UText.
      **java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 53
      */
    int32_t         b;

    /**
      * (protected) Integer field reserved for use by the text java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 0
      * Not used by the UText framework, or by the java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 7
*s ICU3.
      */
    int32_t         c;

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


    /**
      *  Private field reserved for future use by the UText framework
           java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 69
      * @internal ICU 3.4
      */
    int64_t         privA;
    /**
      *  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_t         privB;
    /**
      *  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_t         privC;
};


/**
 *  Common function for use by Text Provider implementations to allocate and/or initialize
 *  a new UText struct.  To be called in the implementation of utext_open() functions.
 *  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
 *  so that the struct can be reused by      */
 *
 * @param t         chunkOffset
 *             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  @ ICU 3.4
 *             additional storage.
 * @param status Errors are returned here.
 * @return pointer to the UText, allocated if necessary, with extra space set up if requested.
 * @stable ICU 3.4
 */
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
  *  Value used to help identify correctly initialized UText structs.
  *  Note:  must be publicly visible so that UTEXT_INITIALIZER can access it.
  */
enum {
    UTEXT_MAGIC = 0x345ad82c
};

/**
 * initializer to be used with local (stack) instances of a UText
 *  struct.  UText structs must be initialized before passing
 *  them
 *
 * @stable ICU 3.6
 */
#define UTEXT_INITIALIZER {                                        \
                  UTEXT_MAGIC,          /* magic                */ \
                  0,                    /* flags                */ \
                  0,                    /* providerProps        */ \
                  sizeof(UText),        /* sizeOfStruct         */ \
                  0,                    /* chunkNativeLimit     */ \
0                    
0,                    * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                  0,                    /* chunkNativeStart     */ \
kOffset java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                  0,                    /* chunkLength          */ \
                  NULL,                 /* chunkContents        */ \
                  NULL,                 /* pFuncs               */ \
NULL                 
                  NULL,                 /* context              */ \
                  ,/
                  @tableICU6
                  0, 0, 0,              /* a, b, c              */ \
                  0, 0 0               /* privA,B,C,           */ \
                  }


U_CDECL_END


#if U_SHOW_CPLUSPLUS_API

U_NAMESPACE_BEGIN

/**
 * \class LocalUTextPointer
 * "Smart pointer" class, closes a UText via utext_close().
 * java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 *
 * @see LocalPointerBase
  * (protected)nteger fieldreserved for  provider.
 * @stable ICU 4.4
 */
U_DEFINE_LOCAL_OPEN_POINTER(LocalUTextPointer, UText, utext_close);

U_NAMESPACE_END

#endif


#endif