Impressum utext.h

Interaktion und
PortierbarkeitC

// © 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.
*
*******************************************************************************
* file name: utext.h
*encoding: UTF-8
* tab size: 8 (not used)
* indentation:4
*
* created on: 2004oct06
* created by: Markus W. Scherer
*/

# _***************************************
#define __UTEXT_H__

/**
* \file
* \brief C API: Abstract Unicode Text API
*
* The Text Access API provides a means to allow text that is stored in alternative
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
* 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 or non-contiguous
- tobe in UText and passed ICU services.
*
* There are three general *UTF-16 strings, to be placed in a UText wrapper and then passed to ICU services.
*
* Application java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2
* use one of the utext_open() functions on their input text, and pass
* the resulting UText to the desired ICU useone *
*
* Second is usage in ICU Services, such*
* operate on input presented to them as a UText. These implementations
* will need to use the iteration and related UText functions to gain
* totheactual
*
* The third class of UText users are *access to actual text.
* UText implementations for the various text storage formats. An application
* or system with a unique text storage format can implement a set of
* UText provider functions for that format, which will then allow
* ICU services to operate on that format.
*
*
* Iterating over text
*
* Here is sample code for a forward iteration over the contents of a UText

* \code
* UChar32 c;
* UText *ut = whatever();
*
* (utext_next32From(ut, 0); c>=0; c=utext_next32(ut)) {
* // do whatever with the codepoint c here.
* }
* \endcode
*
**
* of the text towards the beginning.
*
* \code
 UChar32 cjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
* UText *ut = whatever();
* int textLength = utext_nativeLength(ut);
* for (c=utext_previous32From(ut, textLength); c>*\ndcode
* // do whatever with the codepoint c here.java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
*}
* \endcode
*
* Characters and Indexing
*
 *indexing of underlying storage. The storage could UTF ofunderlying text storage storage format 8
* indexing of the underlying text storage. The storage format could be UTF-8
* or UTF-32, for example. When coding to the UText access API, no assumptions
* can be made regarding the size of characters, or how far an index
*may wheniterating between charactersjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
*
* All indices supplied to UText functions are pinned to the length of the
* text. An out-of-bounds index is not java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 2
* adjusted to be in the range 0 <= index <= length of input text.
*
*
* When an index position is returned from a UText function, it will be
* a toto the java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 76
* 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 It is possible to test whether a native index is on a code point boundary
*
 It is possible test whether native index on acodepointboundary
 ,the original index referred java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
* If the index is returned unchanged, it was on a code point boundary. If
*Most UText access functions have as functions have as their first parameter a (UText *) pointer,
* interior of a character.
*
* Conventions for calling UText functions
*
* Most UText access functions have as their first parameter a (UText *) pointer,
* which specifies the UText to be used. Unless otherwise noted, the
* pointer must refer to a valid, open UText. Attempting to
* use a closed UText or passing a NULL pointer * UText,or
* will produce *\code
*
* The UText_Open family of functions can either * utext_openUTF8(ut, s, -1, &status);
* UText, or heap allocate a new UText. Here java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 2
* a stack-allocated UText.
*
* \code
* char *s = whatever(); // A utf-8 string
* U_ErrorCode status = *
* UText ut Any existing UText passed to an open function _must_ heap- fully java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
* utext_openUTF8(utjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
* // error handling
* } else {
* // work with the UText
* }
* \endcode
*
* Any java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
* either by /
 anpenfunction NULL will cause the function java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
* heap-allocate and fully initialize a new UText.
*
*/

#include "unicode/utypes. ****************java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "unicode/uchar.h"
#if * Close function for
#include " If the UText Cleans up, releases any resources being held by an open UText.
#include "unicode/rep.h"
/unistr
#include "unicode/chariter.h"
#endif

U_CDECL_BEGIN

UTextstable 3./

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

/**
 * Close function for UText instances.
 * Cleans up, * functions withoutfirst closing the UText.
 * 
 * If the UText was originally allocated by one of the utext_open functions,
 * the storage associated with the utext will also be freed.
 * If java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 **@NULLthe was deleted by the . UText
 *
 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 88
 * functions stable 3.
 *
 * @param ut The UText to be closed.
 * @return NULL if the UText struct was *
 * a sequence of bytes that has the form ,
 * *aread- * UTF-8 sequence will be replaced by a singlereplacement ,\uFFFD
 * a subsequent utext_open.

 * @stable ICU 3.4
 */
U_CAPI UText * U_EXPORT2
utext_close(UText*;

/**
* Open a read-only UText implementation for * UTF-8 sequence will be replaced by a single unicodecharacter,\uFFFD.
*
* \htmlonly
* Any invalid UTF-8 in endhtmlonly
*a sequenceof bytesthathas theform ofa * be reset to reference the specified.
* UTF-8 sequence will be replaced by a single unicode replacement character, \uFFFD.
* Any other illegal bytes will each be replaced by a \uFFFD.
*\ndhtmlonly
*
* @param ut Pointer to a UText struct. If NULL, a new UText will be created.
* nonNULL,must to an initialized UText struct,which then
* be reset to reference the specified UTF-8 string.
* @param s A UTF-8 string. Must *Open only for *java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
* @param length The length of the UTF-8 string in bytes, or -1 if the string is
* zero terminated.
* @param status Errors are returned here.
* @return A pointer to the UText. If a pre-allocated UText was provided, it
* will always be used and returned.
* @stable ICU 3.4
*/
U_CAPI UText * U_EXPORT2
utext_openUTF8(ut,java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 77

/**
* Open a read-only UText rpointer the . apre-java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 83
*
* @param ut Pointer to a java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 3
* If nonutext_openUChars(Text * UText.If -UText provided,it
* be reset to reference the specified UChar string.
* @param st * U_EXPORT2
* @param length The number of java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
* zero terminated.
*@status are returned java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
* @return A pointer*
* will always be used and * be reset to reference the spec
* @stable ICU 3.4
*/
*U_EXPORT2
utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status);

#if U_SHOW_CPLUSPLUS_API
/**
*Open a for nonconst UnicodeString.
*
* @param ut Pointer to a UText * be reset to reference thspecified java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 68
* If
* be reset to java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 86
* @param s A UnicodeString.
* @param status Errors are returned here.
* @return Pointer to the UText. *
 be used and
*@table ICU 3.4
*/
U_CAPI UText * U_EXPORT2
rorCode)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

/**
* Open a UText for a const UnicodeString. The resulting UText will not be writable.
*
* *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*Ifnon-nullptr,must to initialized , which will*bereset referencethe .
* be reset to reference the * @param ut Pointer to a UText struct. If nullptrU be
* @param s A const UnicodeString to be wrapped.
* @param status Errors are returned here.
* @return java.lang.StringIndexOutOfBoundsException: Range [1, 24) out of bounds for length 3
* always be and .
* @stable ICU 3.4
*/
/*
utext_openConstUnicodeString *Openawritable UText implementation for an paramstatusare returned.

/**
* Open a writable UText implementation for an ICU Replaceable object.
* @param ut Pointer to a UText struct. If java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 18
* If non-java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
* the specified replaceable text.
* @param rep A Replaceable text object.
*@status Errors are returned here.
* * @aram are
*willalways be used and returned.
* @see Replaceable
* @stable ICU 3.4
*/
U_CAPI UText * U_EXPORT2
utext_openReplaceable(UText *ut, icu::Replaceable *rep, UErrorCode *status) *@ICU java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

/**
* Open a UText implementation over an ICU CharacterIterator.
 Open a UText implementation over an ICU CharacterIterator.
* If non-nullptr, must refer to an already existing UText, which will then
 reference java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 19
* @param ci A Character Iterator.
* @param status Errors are utext_openCharacterIterator(UText *ut:: *,UErrorCode status)
*@ to java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 78
* will always be used and returned.
*@Replaceable
* @stable ICU 3.4
*/
U_CAPI UText * U_EXPORT2
utext_openCharacterIterator(UText *ut, icu:: * made to the text in one will not affect thetext will affecttheother providersare not

#endif

/**
 * Clone a UText. This is much like opening a UText where@ee
 * another UText.
 *
underlying .
 * The original and cloned UText will
 * 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
java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 42
 *
 * 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 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 * Any such modifications can cause unpredictable behavior. Read Only
 * modified.
 *
 * A shallow clone operation will not fail, barring truly exceptional conditions such
 * * have iterators active asingle text string is being
 *
 * Shallow UText clones should be avoided if the UText functions that modify the
 * text are expected to * same underlyingtext.
 * Any such modifications can cause unpredictable behavior. Read Only
 * shallow clones provide some protection against errors of this type by
 * disabling text modification via the cloned UText.
 *
 *A clonemade with the readOnly parameter == false will preserve the
 * utext_isWritable() state of the source object. Note, however, that
 * write operations must be avoided while more than one UText exists that refer
 * to the same underlying text.
 *
 * A UText and its clone * or NULL clone* write operations must be avoided while oneUText
 * This is true for read access only with shallow clones, and for both read and
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 * 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.
 * @param src The UText to be cloned.
* @deep true request clone false a shallow java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
*@java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 88
 * underlying text.

 * @param status Errors are returned here. For deep clones, U_UNSUPPORTED_ERROR
 bereturned the text provider is unable toclone java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
 * original text.
 * @return The newly created clone, or NULL if the clone operation failed.
 * @stable ICU 3.4
 */
UText
utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status);

/**
 * Compare two UText objects for U_CAPI UText* U_EXPORT2
 *UTexts are java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 67
 * have the same iteration position within the text.
r both of parametersare ,the *Get of thetext.Depending the characteristics
 *
 * @param a The first of the two UTexts **@ee utext_isLengthExpensive(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
*bTheother tobecomparedjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 * @return true if the two UTexts are equal.
 * @stable ICU 3.6
 */
U_CAPI UBool U_EXPORT2*
utext_equals(const UText *a, const @ICU36

/*****************************************************************************
*
*
*
*****************************************************************************/

/**
 * Get the length of the*
 * of
* @ java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 35
 *
 *
 * @param ut the text to be accessed.
 * @return * Note that thejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 51
 *
 * @stable ICU 3.4
 */
U_CAPI p texttoaccessed.
utext_nativeLength(UText *ut);

/**
* Return true if calculating the length of the text could be expensive.
* Finding * @return true determiningthe length
*
* Note that the value of this function may change
* as the result java.lang.StringIndexOutOfBoundsException: Range [3, 1) 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 true if determining the * the complete code point will be returned
* @stable ICU 3.4
*/
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 -
 returned
*
* The character-one of the trailbytes a - forexample-
*
* This function is roughly equivalent to the character tobeaccessed thethe
* utext_setNativeIndex(index);
* utext_current32();
 There * is equivalentthe sequence
*(negative value)sets indexto ,after utext_current(
* *@table .4
 the of -1.)
*
* @param ut the text to be accessed
* @param nativeIndex the native index of *utext_setNativeIndexnvalue)setsindexn,
* to other than the first unit of a multi-unit character, it will be adjusted
* to the start of the character.
* @return the code point at the specified index.
* @stable ICU 3.4
*/
ar32
utext_char32At(UText *ut, int64_t nativeIndex);

/**
*
* Get the code point at the current iteration position,
* or U_SENTINEL (-1) if the iteration hasutext_char32At( ut,int64_t nativeIndex)
* 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);

/**
 the java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
* 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, java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 18
* return U_SENTINEL (-1) and do java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
*
* This is a post-java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 0
*
* An * Moveiteratorto character code whose
* is available for performance critical *java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 56
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
* @param ut the text to be accessed.
* @return the Unicode code point at the iteration position.
* @see UTEXT_NEXT32
* @stable ICU 3.4
*/
U_EXPORT2
utext_next32(UText *ut);

/**
*Movethe java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 66
* index precedes the current position, and return that character.
* This is a pre-decrement operation.
*
* If the initial position is at the start of the text (index of 0)
* return U_SENTINEL (-1), and leave the position unchanged.
*
* An inline macro version of this function, UTEXT_PREVIOUS32(),
* the position at the start thetext iof 0
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
* @param ut the text to be accessed.
* @return the previous UChar32 code point, or U_SENTINEL (-1)
 put text to java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
* @see UTEXT_PREVIOUS32
* @stable ICU 3.4
*/
U_CAPI UChar32 U_EXPORT2
utext_previous32(UText *ut);

/**
utext_previous32(Text *)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
*Leave at the o followingcode java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
 *
 * This *@table ICU3.
 * begin a forward iteration. The results are identical to the those
 * from the sequence
 * \code
 * utext_setIndex();
 * utext_next32();
 * \endcode
 *
 * @param ut the text to be accessed.
 * rCode which at before index,
 * @return Code point which starts at or * or U_SENTINEL (-1) if it is out of bo
 * orU*, )
 * @stable ICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
utext_next32From(UText *ut, int64_t nativeIndex);

/**
 * Set the iteration index, and return the code point preceding the
 * one specified by the initial index. Leave * Get the current iterator position, which can range to
 * at the start puttext to accessedjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 *
 * This function is the most efficient and convenient way to
 a *
 *
 * @java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 4
*@aram nativeIndex java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 19
 Code point one * java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 65
 * or U_SENTINEL (-1) if it is out of bounds.
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * @stable ICU 3.4
 */
U_CAPI UChar32 U_EXPORT2
utext_previous32From(UText *ut, *Ifindexisjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 63

/**
 * Get the current iterator position, which can range from 0 to
 * the length of the text.
 * The position is a native index into the java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 4
/**
* U-
*java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 75
 *
* p ut text to be .
 * @return the current index position, in the native units of the text provider*It usually efficientto an iteration
 * @stable ICU 3.4
 */
U_CAPI int64_t *
utext_getNativeIndex(const UText *ut stable java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 37

/**
utext_setNativeIndex(UText *ut, int64_t nativeIndex);
* boundary at or preceding the specified index.
* The index is * is a signed numer java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 73
* If the index is out ofjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
* the range of the input text.
* 
* It will usually be more efficient to begin an iteration
* using the functions utext_next32From() or utext_previous32From()
* rather than setIndex().
* 
* Moving the index position to an be java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
* with utext_next32(), utext_previous32() or utext_moveIndex32().
* Attempting to do direct arithmetic on the index position is
atedby fact the (n java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 63
* character depends on the underlying representation of the character
* (UTF-8, UTF-16, UTF-java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
* easily knowable.

*puttext to java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
* @param nativeIndex the native unit index of the new iteration position.
* @stable ICU 3.4
*/
U_CAPI voidis
utext_setNativeIndex(UText *ut, int64_t java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 8

/**
* Move the iterator position (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
* is * Ujava.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 28
of ext.
*<>
by <code>/ code
* forward or backward, but no further *
* no further forward than to utext_nativeLength().
* The resulting index value will be in between 0 and length, inclusive.
*
* @ @table 3.
* @param delta the signed number of code points to move the java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 24
* @return true java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
* staying within the range [0 - text length].
*@table ICU .
*/
U_CAPItext UText bufferThe range number b )fthe tobe is
utext_moveIndex32(UText *ut, int32_t delta);

/**
* Get the native index of the character preceding the current position.
* If the iteration position is * because the specified buffer size is .
* is returned.
* The value returned is the same as that obtained from the following sequence,
* p

* \code
* UText *ut = whatever;
*..
* utext_previous(ut)
* utext_getNativeIndex(ut);
* \endcode
*
* This function is most useful during *itwill java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 72
ned from java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 76
*
 @aram ut textt string index the following last
*@ thenative index of the character preceding the current index position,
* or * iwill be 0=< java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73
* @stable ICU 3.6
*/
U_CAPI int64_t U_EXPORT2
utext_getPreviousNativeIndex(UText *ut);

/**
*
* Extract text from a UText into a UChar buffer. The range of text to be extracted
* is specifiedutext_extract(UText *t,
* be UTF-16 indices.
* 
* The size (number of 16 bit UChars) of the data to
 ijava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 82
* because the specified buffer size is too small.
* pjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
* 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 to macros.
* terminating NUL is not included in the returned length.
* *********
* The iteration index is left at the position following the last java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
* @ * because is ully ofjava.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69
* java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
* If the specified index is /**
* it will be pinned to be within 0 <= index <= textLength
*@aram native index of the java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 81
* character to extract *
* it will be pinned to be within 0 <= index <= textLength.
Limitbe =java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
* @param dest the UChar (UTF-16) buffer into which the extracted text is placed
* @param destCapacity The size, in UChars, of the destination buffer. May * * inlinversionof )forjava.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73
* for * advance the position to theindex following characterjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
any * inline version of utext_previous32,or java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 77
* U_BUFFER_OVERFLOW_ERROR: the extracted text was truncated because the
* buffer was too small. Returns number of *
* @return Number of UChars in the data to *ReturnsU_SENTINEL (-1) if the position is at the start of the text.
*
* @stable ICU 3.4
*/
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
utext_extract(UText *ut,
 int64_t nativeStart, int64_t nativeLimit,
 UChar *dest, int32_t destCapacity,
 UErrorCode *status);

*
* #define theUChar (16
*Caution do not use + -
* as parameters to these macros.
*
* For most use, where there is no extreme*
 normal inline functionsare a * normal, non-inline functions are a better
* will be smaller, and, if the need ever arises, easier to debug.
*
* These are * The returned position will to codepoint
* because there is no fully portable way to do inline functions in plain C.
*
************************************************************************************/

#
/**
* inline version of utext_current32(), for performance-critical situations.
*
* Get int64_t _offset = (x )c; \
* Returns U_SENTINEL (-1) if the position is at the end of the
* }java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
*
*@ICU java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*/
#define UTEXT_CURRENT32(ut) \
 (( ()c(int32_t_o \
(ut)[(-) :java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 69
#endif /* U_HIDE_INTERNAL_API */

/**
* inline version of utext_next32(), for performance-critical situations.
*
* position the
* advance the position to the first index following the character.
* This is a post-increment operation.
*Returns (1 if the position is the of
* text.
*
*@java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 18
*/
#define UTEXT_NEXT32(ut) \
 ( java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 75
 that themodification

/**
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 77

*Move the iteratorposition the character (ode point)whose
* @trueifthetext java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
* This is a pre-decrement operation.
* * @see text_copy)
*
* @stable ICU 3.4
*/
#define UTEXT_PREVIOUS32(ut) \
 u)> &\
)->hunkContentsu)>-] \
 (ut)->chunkContents[--((ut)*@utThe to be tested

/**
 * inline version of java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 19
 *
 * Get the current iterator position, which
 *the length of the java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 * *Leaves position
 * eaves the iteration newlytext.
 * the corresponding UChar (UTF-16)*
 * The returned position will always be aligned to a code point boundary.
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 textB java.lang.StringIndexOutOfBoundsException: Range [52, 49) out of bounds for length 69
 */
#definejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
 ((ut)->chunkOffset <= (ut)->nativeIndexingLimit? \
 (ut)->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2
 (ut)->pFuncs->mapOffsetToNative(ut))

/**
 * inline version of utext_setNativeIndex(), for performance- * @param nativeLimit the native index of the character following thenative java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 97
 *
 * Set the current *
*java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 49
 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 64
 * If the index is out of range, it will be pinned to be within
 * the range of *
 *
 * @stable ICU 3.8
 */
#define UTEXT_SETNATIVEINDEX(ut, * the length of the text ejava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 57
int64_t__offset=(ix)-(-chunkNativeStart\
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 } else { \
 utext_setNativeIndex((ut), (ix)); \
 } \
} UPRV_BLOCK_MACRO_END

/************************************************************************************const *,
*
* Functions related to writing or modifying the text.
* These will work only with modifiable UTexts. Attempting to
* modify a read-only UText will return an error status.

************************************************************************************/

/**
* Return true if the text can be written (modified) java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 2
For java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 70
* be of a type * underlying native java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 66
*
* Attempting to modify text when utext_isWriteable() is false will fail -
* the * @param * @param ut
* that attempted the modification.
*
* @param ut the UText to be tested.
* *thatis,ones ( .
*to be
* @see utext_freeze()
* @see utext_replace()
* @see utext_copy()
* @stable ICU 3.4
*
*/
U_CAPIU_EXPORT2
utext_isWritable(const UText *ut);

/**
 * Test whether there is meta data associated with the text.
 @ee :hasMetaData()
 *
 *utex(UText *ut,
 underlyingtextjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 59
 * @stable ICU 3.4
 */
U_CAPI UBool U_EXPORT2
utext_hasMetaData(const UText *ut);

/**
* Replace a range of the original text with a replacement text.
*
* Leaves the current iteration position at the position following the
* newly inserted replacement text.
*
* 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
 underlying native text string. Behavior after a replace operation
* on a UText is int64_t destIndex,
* modified string.
*
 @aramut the UText representing the text to be operated on.
* @param nativeStart the native index of the start of the region to be
* @param nativeLimit the native index of the character 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 text expanded or contracted.
*
* stable ICU 3.4
*/
U_CAPI int32_t U_EXPORT2
utext_replace( * directly modifythe text bybypassing the UText. Any such backdoor modifications
 java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 6
 const* text canget outofwith 'sbuffering.
 UErrorCode *status);

/**
*
* Copy or move a substring from one position to another within the text,
* while retaining anymassociated with the text.
* This function is used to duplicate or reorder substrings.
* The destination index must not overlap the source range.
*
* * UText provider properties (bit field indexes).
*/
*
* 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,
* is oneswhere utext_isWritable( returns truejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
*
* * @stable ICU 3.4
* underlying native text string. Behavior after a copy operation
* ona UText is undefined in any other additional UTexts that refer to the
* modified 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 copied or moved
* @param nativeLimit The native index of the character position following the region
* to be copied.
* param destIndex The native destination index to which the source substring is
* copied or moved.
 @ moveIf true then the substringis ,not copied/duplicated.
* @param status receives any error status. Possible errors java.lang.StringIndexOutOfBoundsException: Range [0, 74) out of bounds for length 2
*
* functions.
*/
U_CAPI void aUText.Muchlike a UText where the* stable ICU 3java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
utext_copy(UText *ut another UText
 int64_t nativeStart, int64_t nativeLimit,
 int64_t destIndex,
 UBool move,
 UErrorCode *status);

/**
 * 
 * Freeze a UText. This prevents any modification to the underlying text itself
 * by means of functions operating on this UText.
 * 
 * 
 unfrozen.The intent * Generally occurs as the result of a deep clone of the UText.
 * that a the text underlying a frozen UText wrapper cannot be modified via that UText.
 * 
 * 
 * Caution: *
 UTEXT_PROVIDER_OWNS_TEXT = 5
 * directly modify the text by bypassing the UText. Any such backdoor modifications
 * are always/**
 * * modified.
 * 
 *
 The UText to be frozen.
 * @see * as memory allocationjava.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
*stable .java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 */
U_CAPI void U_EXPORT2
utext_freeze madetothetextin one will not effect the other. Text providers*It the responsibility of the TextProvider ensure that thread afety

/**
* UText provider properties (bit field indexes).
*
*@ UText
.4
*/
enum { *
 /**
 *A clone notexcept for truly java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
*stableatusErrorsarereturned here.For clones U_UNSUPPORTED_ERROR
 */
 UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE = 1,

 @returnThe newly created clone, or NULL if the clone operation failed.
 * deleted, not just until * @paramdestAUText to befilled in withthe result of the clone operation,
 * (which is the default).
UText*U_CALLCONV
 */
 UTEXT_PROVIDER_STABLE_CHUNKS = 2,
 /**
 * The provider supports modifying the text via the replace * @param status Errors are returned here For java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 3
 * functions.
 * text.
ICU34
 */
 UTEXT_PROVIDER_WRITABLE = *@ ICU34
 /**
 * There is meta data associated with the text.
*@eeReplaceable::hasMetaData()
 * @stable ICU 3.4
 */
 UTEXT_PROVIDER_HAS_META_DATA = 4,
 /**
 *containing the text at a requested native index. The UText's iteration
 * Generally occurs as the result of a deep clone of the UText.
 * When closing the UText, the associated text must
 * also *of ,as java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 @ICU 3.
 */
 UTEXT_PROVIDER_OWNS_TEXT = 5
};

/**
 * Function type declaration for UText.clone().
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * clone a UText. Much like opening thenthe java.lang.StringIndexOutOfBoundsException: Range [59, 48) out of bounds for length 72
 * another UText.

 * A deep clone will copy both the UText data structures and the underlying 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 clones. The user of clone() must check the status return
 * and be prepared to handle failures.
 *
 A clone @param nativeIndex Requested java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 65
 * 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.
 false the chunk must text
 * A shallow clone operation must not fail except for truly exceptional conditions such
 * as memory allocation failures.
 *
 * A UText and its clone may be safely concurrently accessed by separate threads.
 * This is true for both shallow and deep clones.
Providerto that @seeUText
 * constraint is met.

 *
be textfrom UText UChar buffer.Therange of text to be extracted
 * or NULL if the clone function should heap-allocate a new UText *@param estthe UChar UTF16 buffer into indices.
 *pThe* full amount is returned, even specified buffer is smaller.
 * @ *
 * @param status Errors are returned here. For deep clones, U_UNSUPPORTED_ERROR
 * should 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
 */
typedefdeclarationfor..
UTextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status);

/**
* Function typedeclaration for UText.nativeLength().
*
* @param ut the UText to get the length of.
* @return the length, in the native*When usingthis function,there shouldbe single UTextopened onto
* @see UText
*sjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 18
*/
typedef int64_t U_CALLCONV
UTextNativeLengthut)

/**
* Function type java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2
* containing the text at a requested native index. The UText's iteration
* eftat therequested index. * position will be left at the requested index. If the index
* of bounds, the iteration position will be * @param status receives any error statjava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 78
* of the string, as appropriate.
*
* Chunks the length of the text expanded or contracted.
* comprised of multiple storage units must never span a chunk boundary.
*
*
* param UText being accessed.
* @param nativeIndex Requested index of the text to be accessed.
* @param forward If true, then the returned chunk must contain text
*startingfrom,so that start<<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
* 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 U_CALLCONV
UTextAccess(UText *ut, int64_t nativeIndex, *This needonly be implemented for UText types that support writing.

/**
* Function type declaration for UText.extract().
*
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 78
*@ nativeStart index of the start ofthe regionto replaced
* UTF- indices.
* 
of16bit UChars atatobe is returned.The
* full amount is returned, even when the specified buffer size is smaller.
* 
* 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.
*
* @param ut the UText from*
* @param nativeStart the native index of the first character to extract.
* @param nativeLimit the native string index of the java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 2
int32_t U_CALLCONV
* @param dest the UChar (UTF-16) java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 30
* @param destCapacity The size, in UChars, of the destination buffer. May be zero
* for precomputing the required *Function type declaration for UText.copy().
* @param status receives any error status.
* If U_BUFFER_OVERFLOW_ERROR: Returns number of UChars for
* preflighting.
* @return Number of UChars in the data. Does not * The destination must not overlap the source range.
*
* @stable ICU 3.4
*/
typedef int32_t U_CALLCONV
UTextExtract(UText *ut,
 int64_t nativeStart, int64_t nativeLimit,
 UChar *dest, int32_t destCapacity,
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 33

/**
* Function type declaration for UText.replace().
*
* Replace a range of the original text with */
*
* Leaves the current iteration position at the position following the
* newly inserted replacement text.
*
* This function need only be implemented on UText types that support writing.
*
* 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 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 *@paramut UText containingthe chunk.
* @param nativeStart the index of the start of the region to be replaced
* @param nativeLimit * index
* @param replacementText pointer to the replacement text
* @param replacmentLength length of the replacement text in UChars, java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 0
* @param status receives any error status. Possible in open function thecurrent offset the chunk java.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69
* U_NO_WRITE_PERMISSION
*
* @return The signed number of (native) storage units by which
* the length of the text expanded or contracted.
*
* @stable ICU 3 *
*/
typedef int32_t U_CALLCONV
UTextReplace(UText *ut,
 int64_t nativeStart, int64_t nativeLimit,
 const UChar *replacementText, int32_t replacmentLength,
 UErrorCode *status);

/**
* Function type declaration for UText.copy().
*
*or a java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
* 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;
* int32_tU_CALLCONV
*
* This function need only java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
*
* When using this functionjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
*underlyingnativetext string.The is responsible updatingthe
* text chunk within the UText to reflect the updated iteration java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 61
* 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 */
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
* @param nativeLimit The index of the character following the region to be replaced.
* @param java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* @java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
* @param status receives any error java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
* @stable ICU 3.4
*/
le .
UTextCopy(UText *ut,
 int64_t nativeStart, int64_t nativeLimit,
 int64_t nativeDest,
 UBool move,
 UErrorCode *status);

/**
* Function type declaration for UText.java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 22
* Map from the current UChar offset within the current text chunk Intended for use should table grow to accommodate added
 corresponding nativeindex the text.
*
* This is required only for text providers that do not use native UTF-16 indexes.
*
* @param ut the UText.
java.lang.StringIndexOutOfBoundsException: Range [19, 6) out of bounds for length 35
* 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);

/**
* Function type declaration for UText.mapIndexToUTF16().
* Map from a native index to a UChar java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 22
* 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-java.lang.StringIndexOutOfBoundsException: Range [0, 82) out of bounds for length 6
*
* @param ut The UText containing the text chunk UTextClone *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* @return Chunk-relative UTF-16 offset corresponding to the specified native
* index.
*
 sjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 18
*/
typedef int32_t U_CALLCONV

/**
* Function type declaration for UText.utextClose().
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
* A Text Provider close function is only required for provider java.lang.StringIndexOutOfBoundsException: Range [0, 69) out of bounds for length 50
ir open function (r * @ICU .6
* UTextEx *extract;

* The allocation java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 7
* associated with the UText is handled by the common UText implementation
* and does not require provider specific cleanup see
*
* Most UText provider implementations do not need to implement this function.
*
* @param ut A UText
*

*/
typedef void*
UTextClose(UText *ut);

/**
 () dispatch table for UText.
 * 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 {
 *pjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 48
 * (public) Function table size, sizeof(java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 23
 * Intended for /**
 * functions in the future,* @internal
 java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 70

 * Fields are placed for optimal java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 41
 * /64128bit-pointer machines,normally java.lang.StringIndexOutOfBoundsException: Range [0, 71) out of bounds for length 8
 * 4 32-bit fields,
 * 4 pointers,
 * 2 64-bit fields
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @stable ICU 3.6
 */
 int32_t tableSize;
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 /**
 * (private) Alignment padding.
 for by the framework .
 * @internal
 */
 int32_t reserved1, /** @internal */ reserved2, /** @internal */ reserved3;

/
 * (public) * ofthe they
 *
 * @see UTextClone
 * @stable java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
 */
 UTextClone *clone;

 /**
 * (public) function pointer java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 /**
 *
*sUTextLength
 * @stable ICU 3.6
 */
 *

 /**

 *
 * @see UTextAccess
 * @stable ICU 3*@ICU .6
 */
 UTextAccess *access;

 /**
 * (public) Function pointer for UTextExtract.
 *

 * @stable ICU int32_t extraSize;
 */
 UTextExtract *extract;

 /**
 public)unction java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 50
 *
 * @see UTextReplace
 * @stable ICU 3.6
 */
 UTextReplace *replace;

 /**
 * (public) Function pointer for UTextCopy.
 *java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 * @see UTextCopy
 * @stable ICU 3.6
 */
 UTextCopy *copy;

 /**
 * (public *
 *
 * @see UTextMapOffsetToNative
 * @stable ICU 3.6
 */
 UTextMapOffsetToNative

 /**
 * (public) Function pointer for UTextMapNativeIndexToUTF16.
 *
*sUTextMapNativeIndexToUTF16
 is index thecharacter thatwill be utext_next32)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
 */
 UTextMapNativeIndexToUTF16 *mapNativeIndexToUTF16;

 /**
 * (public) Function pointer for UTextClose.
 *
 * @see UTextClose
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 UTextClose *close;

 /**
 * (private) Spare * text provider theutext_open operation.
* @
 */
void *pExtra;

 /**
 * (private) Spare function pointer
 * @internal
 */
 UTextClose *spare2;

 /**
 * (private) Spare function pointer
 * @internal
 */
 UTextClose *spare3;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/**
* Function dispatch table for UText
* @see UTextFuncs
*/
typedef struct UTextFuncs UTextFuncs;

/**
 * UText struct const void*p;
 * and the UText provider code that *(protected)Pointer fields vailable for use by the text provider.
 * text (UTF-8, noncontiguous UTF-16, whatever.)
 *
 * Applications that are using predefined types of text providers
 * to pass text data to * thatisknownto textproviderf.
 * internals of the UText structs that they open.
 *
 @ ICU3.6
 */
struct UText {
 /**
 * (private) Magic. Used to help detect when UText functions are handed
 * invalid or uninitialized
 * 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 * (protected) Pointer fields available for use by the
 * the magic field because that would prevent
 * reuse of the UText struct.
 * @internal
 */
 uint32_t magic;

 /**
 * (private /**
 * memory associated *(protected) Integer field reserved for use by thetext providerrovider.
 * @internal
 */
 int32_t flags;

 /**
 * Text provider propertiesjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 * text provider implementation.
 * @stable ICU 3.4
 */
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

 /**
 * (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 * Private field reserved UText framework
 * itself.Thisis not @table 3.
 */
 int64_t chunkNativeLimit;

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

 /**
 * (protected) The highest chunk offset where java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 7
 * chunk (UTF-16) indexing correspond. For UTF-16 sources, value
 * will be equal to chunkLength.
 *
 * @stable ICU 3.6
 */
 int32_t nativeIndexingLimit;*aUText becalledthejava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 86

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

 /**
 * (protected) Native index of the first character in the text chunk.
 * @stable ICU 3.6
 */
 chunkNativeStart

 /**
 * (protected) Current iteration position within the text chunk (UTF-16 buffer).
 * This is the index to the character that will be returned by utext_next32().
 * @stable ICU 3.6
 */
;

 /**
 * (protected) Length the text chunk (UTF- @java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 94
 * @stable ICU 3.6
 */
 int32_t chunkLength;

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


 /**
 * (protected) pointer to a chunk of text in UTF *
 * 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;

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

 /**
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * 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 *context *Value to

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

 /**
 * (protected) Pointer fields available 0, /* chun */ \
 * Not used by UText common code.
 * @stable ICU 3.6
 */
 ,/* pExtra */ \
 /**
 * (protected) Pointer NULL, NULL, NULL * p, q, r */ \
 * Not used by UText common code.
 * @stableUTEXT_MAGIC,
 */
 const/* providerProps */ \
 /**
 * (protected) Pointer fields available for use by the text provider.
 * Not used by UText common code.
 * @stable ICU 3.6
 */
 const void *r;

reserved for future usebytheUText framework
 * itself. /\
 * @internal ICU 3.4
 */
 void *privP

 /* --- 16 byte alignment boundary--- */0 0,0, /* a, b, c */ \


 /**
 * (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;

 /**
 )ntegerfieldreservedfor useby text provider.
 * Not used by the UText framework, or by the client java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 18
 * @stable ICU 3.4
 */
 int32_t b;

 /**
 * (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
 */
 int32_t c;

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

 /**
 * Private field reserved java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 6
 * itself. This is not to be touched by the text providers.
 * @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 the open that is in progress.
*
* @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 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 to one of the utext_open functions.
*
* @stable ICU 3.6
*/
#define UTEXT_INITIALIZER { \
 UTEXT_MAGIC, /* magic */ \
 0, /* flags */ \
 0, /* providerProps */ \
 sizeof(UText), /* sizeOfStruct */ \
 0, /* chunkNativeLimit */ \
 0, /* extraSize */ \
 0, /* nativeIndexingLimit */ \
 0, /* chunkNativeStart */ \
 0, /* chunkOffset */ \
 0, /* chunkLength */ \
 NULL, /* chunkContents */ \
 NULL, /* pFuncs */ \
 NULL, /* pExtra */ \
 NULL, /* context */ \
 NULL, NULL, NULL, /* p, q, r */ \
 NULL, /* privP */ \
 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().
* For most methods see the LocalPointerBase base class.
*
* @see LocalPointerBase
* @see LocalPointer
* @stable ICU 4.4
*/
U_DEFINE_LOCAL_OPEN_POINTER(LocalUTextPointer, UText, utext_close);

U_NAMESPACE_END

#endif

#endif

Messung V0.5 in Prozent

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.154Bemerkung: ¤

*Bot Zugriff

Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.