public/common/unicode/utext.h - Issue 18836004: Move ICU headers from public/{common,i18n} to source/{common,i18n}

Unified Diff: public/common/unicode/utext.h

Issue 18836004: Move ICU headers from public/{common,i18n} to source/{common,i18n} (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/icu46.git@master

Patch Set: same as ps #3. retry uploading Created 7 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: public/common/unicode/utext.h

diff --git a/public/common/unicode/utext.h b/public/common/unicode/utext.h

deleted file mode 100644

index 088a5327397fd6cf85eb3412057eff5d90de012f..0000000000000000000000000000000000000000

--- a/public/common/unicode/utext.h

+++ /dev/null

@@ -1,1737 +0,0 @@

-/*

-*******************************************************************************

-* file name: utext.h

-* encoding: US-ASCII

-* 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

- *

- * The Text Access API provides a means to allow text that is stored in alternative

- * formats to work with ICU 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 or non-contiguous

- * UTF-16 strings, to be placed in a UText wrapper and then passed to ICU services.

- *

- * There are three general classes of usage for UText:

- *

- * 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 users are "text providers." These are the

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

- *

- * for (c=utext_next32From(ut, 0); c>=0; c=utext_next32(ut)) {

- * // do whatever with the codepoint c here.

- * }

- * \endcode

- *

- * And here is similar code to iterate in the reverse direction, from the end

- * of the text towards the beginning.

- *

- * \code

- * UChar32 c;

- * UText *ut = whatever();

- * int textLength = utext_nativeLength(ut);

- * for (c=utext_previous32From(ut, textLength); c>=0; c=utext_previous32(ut)) {

- * // do whatever with the codepoint c here.

- * }

- * \endcode

- *

- * Characters and Indexing

- *

- * Indexing into text by UText functions is nearly always in terms of the native

- * 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 move when iterating between characters.

- *

- * All indices supplied to UText functions are pinned to the length of the

- * text. An out-of-bounds index is not considered to be an error, but is

- * adjusted to be in the range 0 <= index <= length of input 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 the interior. This is essentially the same thing as saying that

- * a returned index will always point to a boundary between characters.

- *

- * When a native index is supplied to a UText function, all indices that

- * refer to any part of a multi-unit character representation are considered

- * to be equivalent. In the case of multi-unit characters, an incoming index

- * will be logically normalized to refer to the start of the character.

- *

- * It is possible to test whether a native index is on a code point boundary

- * by doing a utext_setNativeIndex() followed by a utext_getNativeIndex().

- * If 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.

- *

- * 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 is a programming error and

- * will produce undefined results or NULL pointer exceptions.

- *

- * The UText_Open family of functions can either open an existing (closed)

- * UText, or heap allocate a new UText. Here is sample code for creating

- * a stack-allocated UText.

- *

- * \code

- * char *s = whatever(); // A utf-8 string

- * U_ErrorCode status = U_ZERO_ERROR;

- * UText ut = UTEXT_INITIALIZER;

- * utext_openUTF8(ut, s, -1, &status);

- * if (U_FAILURE(status)) {

- * // error handling

- * } else {

- * // work with the UText

- * }

- * \endcode

- *

- * Any existing UText passed to an open function _must_ have been initialized,

- * either by the UTEXT_INITIALIZER, or by having been originally heap-allocated

- * by an open function. Passing NULL will cause the open function to

- * heap-allocate and fully initialize a new UText.

- *

- */

-#include "unicode/utypes.h"

-#include "unicode/uchar.h"

-#if U_SHOW_CPLUSPLUS_API

-#include "unicode/localpointer.h"

-#include "unicode/rep.h"

-#include "unicode/unistr.h"

-#include "unicode/chariter.h"

-#endif

-U_CDECL_BEGIN

-struct UText;

-typedef struct UText UText; /**< C typedef for struct UText. @stable ICU 3.6 */

-/***************************************************************************************

- *

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

- *

- ****************************************************************************************/

-/**

- * Close function for UText instances.

- * Cleans up, releases any resources being held by an open 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 the UText storage originated with the application, as it would with

- * 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.

- *

- * @param ut The UText to be closed.

- * @return NULL if the UText struct was deleted by the close. If the UText struct

- * was originally provided by the caller to the open function, it is

- * returned by this function, and may be safely used again in

- * a subsequent utext_open.

- *

- * @stable ICU 3.4

- */

-U_STABLE UText * U_EXPORT2

-utext_close(UText *ut);

-#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

-/**

- * Open a read-only UText implementation for UTF-8 strings.

- *

- * \htmlonly

- * Any invalid UTF-8 in the input will be handled in this way:

- * a sequence of bytes that has the form of a truncated, but otherwise valid,

- * UTF-8 sequence will be replaced by a single unicode replacement character, \uFFFD.

- * Any other illegal bytes will each be replaced by a \uFFFD.

- * \endhtmlonly

- *

- * @param ut Pointer to a UText struct. If NULL, a new UText will be created.

- * 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 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_STABLE UText * U_EXPORT2

-utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status);

-/**

- * Open a read-only UText for UChar * string.

- *

- * @param ut Pointer to a UText struct. If NULL, a new UText will be created.

- * If non-NULL, must refer to an initialized UText struct, which will then

- * be reset to reference the specified UChar string.

- * @param s A UChar (UTF-16) string

- * @param length The number of UChars in the input string, 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_STABLE UText * 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 NULL, a new UText will be created.

- * If non-NULL, must refer to an initialized UText struct, which will then

- * be reset to reference the specified input string.

- * @param s A UnicodeString.

- * @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_STABLE UText * U_EXPORT2

-utext_openUnicodeString(UText *ut, U_NAMESPACE_QUALIFIER UnicodeString *s, UErrorCode *status);

-/**

- * Open a UText for a const UnicodeString. The resulting UText will not be writable.

- *

- * @param ut Pointer to a UText struct. If NULL, a new UText will be created.

- * If non-NULL, must refer to an initialized UText struct, which will then

- * be reset to reference the specified input string.

- * @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_STABLE UText * U_EXPORT2

-utext_openConstUnicodeString(UText *ut, const U_NAMESPACE_QUALIFIER UnicodeString *s, UErrorCode *status);

-/**

- * Open a writable UText implementation for an ICU Replaceable object.

- * @param ut Pointer to a UText struct. If NULL, a new UText will be created.

- * If non-NULL, must refer to an already existing UText, which will then

- * be reset to reference the specified replaceable text.

- * @param rep A Replaceable text object.

- * @param status Errors are returned here.

- * @return Pointer to the UText. If a UText was supplied as input, this

- * will always be used and returned.

- * @see Replaceable

- * @stable ICU 3.4

- */

-U_STABLE UText * U_EXPORT2

-utext_openReplaceable(UText *ut, U_NAMESPACE_QUALIFIER Replaceable *rep, UErrorCode *status);

-/**

- * Open a UText implementation over an ICU CharacterIterator.

- * @param ut Pointer to a UText struct. If NULL, a new UText will be created.

- * If non-NULL, must refer to an already existing UText, which will then

- * be reset to reference the specified replaceable text.

- * @param ci A Character Iterator.

- * @param status Errors are returned here.

- * @return Pointer to the UText. If a UText was supplied as input, this

- * will always be used and returned.

- * @see Replaceable

- * @stable ICU 3.4

- */

-U_STABLE UText * U_EXPORT2

-utext_openCharacterIterator(UText *ut, U_NAMESPACE_QUALIFIER CharacterIterator *ic, UErrorCode *status);

-#endif

-/**

- * Clone a UText. This is much like opening a UText where the source text is itself

- * 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 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 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 string that is not being

- * modified.

- *

- * A shallow clone operation will not fail, barring truly exceptional conditions such

- * as memory allocation failures.

- *

- * Shallow UText clones should be avoided if the UText functions that modify the

- * text are expected to be used, either on the original or the cloned UText.

- * 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 shallow clone made 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 may be safely concurrently accessed by separate threads.

- * This is true for read access only with shallow clones, and for both read and

- * write access with deep clones.

- * It is the responsibility of the Text Provider to ensure that this thread safety

- * constraint is met.

- *

- * @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.

- * @param deep TRUE to request a deep clone, FALSE for a shallow clone.

- * @param readOnly TRUE to request that the cloned UText have read only access to the

- * underlying text.

- * @param status Errors are returned here. For deep clones, U_UNSUPPORTED_ERROR

- * will be returned if the text provider is unable to clone the

- * original text.

- * @return The newly created clone, or NULL if the clone operation failed.

- * @stable ICU 3.4

- */

-U_STABLE UText * U_EXPORT2

-utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status);

-/**

- * Compare two UText objects for equality.

- * UTexts are equal if they are iterating over the same text, and

- * have the same iteration position within the text.

- * If either or both of the parameters are NULL, the comparison is FALSE.

- *

- * @param a The first of the two UTexts to compare.

- * @param b The other UText to be compared.

- * @return TRUE if the two UTexts are equal.

- * @stable ICU 3.6

- */

-U_STABLE UBool U_EXPORT2

-utext_equals(const UText *a, const UText *b);

-/*****************************************************************************

- *

- * Functions to work with the text represeted by a UText wrapper

- *

- *****************************************************************************/

-/**

- * Get the length of the text. Depending on the characteristics

- * of the underlying text representation, this may be expensive.

- * @see utext_isLengthExpensive()

- *

- * @param ut the text to be accessed.

- * @return the length of the text, expressed in native units.

- *

- * @stable ICU 3.4

- */

-U_STABLE int64_t U_EXPORT2

-utext_nativeLength(UText *ut);

-/**

- * Return TRUE if calculating the length of the text could be expensive.

- * Finding the length of NUL terminated strings is considered to be expensive.

- *

- * Note that the value of this function may change

- * 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_STABLE UBool U_EXPORT2

-utext_isLengthExpensive(const UText *ut);

-/**

- * Returns the code point at the requested index,

- * or U_SENTINEL (-1) if it is out of bounds.

- *

- * If the specified index points to the interior of a multi-unit

- * character - one of the trail bytes of a UTF-8 sequence, for example -

- * the complete code point will be returned.

- *

- * The iteration position will be set to the start of the returned code point.

- *

- * This function is roughly equivalent to the the sequence

- * utext_setNativeIndex(index);

- * utext_current32();

- * (There is a subtle difference if the index is out of bounds by being less than zero -

- * utext_setNativeIndex(negative value) sets the index to zero, after which utext_current()

- * 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 accessed. If the index points

- * 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

- */

-U_STABLE UChar32 U_EXPORT2

-utext_char32At(UText *ut, int64_t nativeIndex);

-/**

- *

- * Get the code point at the current iteration position,

- * or U_SENTINEL (-1) if the iteration has reached the end of

- * the input text.

- *

- * @param ut the text to be accessed.

- * @return the Unicode code point at the current iterator position.

- * @stable ICU 3.4

- */

-U_STABLE UChar32 U_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 the text),

- * return U_SENTINEL (-1) and do not advance the index.

- *

- * This is a post-increment operation.

- *

- * An inline macro version of this function, UTEXT_NEXT32(),

- * is available for performance critical use.

- *

- * @param ut the text to be accessed.

- * @return the Unicode code point at the iteration position.

- * @see UTEXT_NEXT32

- * @stable ICU 3.4

- */

-U_STABLE UChar32 U_EXPORT2

-utext_next32(UText *ut);

-/**

- * 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.

- *

- * 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(),

- * is available for performance critical use.

- *

- * @param ut the text to be accessed.

- * @return the previous UChar32 code point, or U_SENTINEL (-1)

- * if the iteration has reached the start of the text.

- * @see UTEXT_PREVIOUS32

- * @stable ICU 3.4

- */

-U_STABLE UChar32 U_EXPORT2

-utext_previous32(UText *ut);

-/**

- * Set the iteration index and return the code point at that index.

- * Leave the iteration index at the start of the following code point.

- *

- * This function is the most efficient and convenient way to

- * 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.

- * @param nativeIndex Iteration index, in the native units of the text provider.

- * @return Code point which starts at or before index,

- * or U_SENTINEL (-1) if it is out of bounds.

- * @stable ICU 3.4

- */

-U_STABLE 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 the iteration position

- * at the start of the returned code point.

- *

- * This function is the most efficient and convenient way to

- * begin a backwards iteration.

- *

- * @param ut the text to be accessed.

- * @param nativeIndex Iteration index in the native units of the text provider.

- * @return Code point preceding the one at the initial index,

- * or U_SENTINEL (-1) if it is out of bounds.

- *

- * @stable ICU 3.4

- */

-U_STABLE UChar32 U_EXPORT2

-utext_previous32From(UText *ut, int64_t nativeIndex);

-/**

- * Get the current iterator position, which can range from 0 to

- * the length of the text.

- * The position is a native index into the input text, in whatever format it

- * may have (possibly UTF-8 for example), and may not always be the same as

- * 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.

- * @return the current index position, in the native units of the text provider.

- * @stable ICU 3.4

- */

-U_STABLE int64_t U_EXPORT2

-utext_getNativeIndex(const UText *ut);

-/**

- * 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 the index is out of range, it will be pinned to be within

- * 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 adjacent character is best done

- * with utext_next32(), utext_previous32() or utext_moveIndex32().

- * Attempting to do direct arithmetic on the index position is

- * complicated by the fact that the size (in native units) of a

- * character depends on the underlying representation of the character

- * (UTF-8, UTF-16, UTF-32, arbitrary codepage), and is not

- * easily knowable.

- *

- * @param ut the text to be accessed.

- * @param nativeIndex the native unit index of the new iteration position.

- * @stable ICU 3.4

- */

-U_STABLE void U_EXPORT2

-utext_setNativeIndex(UText *ut, int64_t nativeIndex);

-/**

- * Move the iterator postion 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.

- *

- * 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().

- * The resulting index value will be in between 0 and length, inclusive.

- *

- * @param ut the text to be accessed.

- * @param delta the signed number of code points to move the iteration position.

- * @return TRUE if the position could be moved the requested number of positions while

- * staying within the range [0 - text length].

- * @stable ICU 3.4

- */

-U_STABLE UBool U_EXPORT2

-utext_moveIndex32(UText *ut, int32_t delta);

-/**

- * Get the native index of the character preceeding the current position.

- * If the iteration position is already at the start of the text, zero

- * 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_previous(ut)

- * utext_getNativeIndex(ut);

- * \endcode

- *

- * This function is most useful during forwards iteration, where it will get the

- * native index of the character most recently returned from utext_next().

- *

- * @param ut the text to be accessed

- * @return the native index of the character preceeding the current index position,

- * or zero if the current position is at the start of the text.

- * @stable ICU 3.6

- */

-U_STABLE 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 specified in the native indices of the UText provider. These may not necessarily

- * be UTF-16 indices.

- *

- * The size (number of 16 bit UChars) of the data to be extracted is returned. The

- * full number of UChars is returned, even when the extracted text is truncated

- * because the specified buffer size is too small.

- *

- * The extracted string 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.

- *

- * The iteration index is left at the position following the last extracted character.

- *

- * @param ut the UText from which to extract data.

- * @param nativeStart the native index of the first character to extract.\

- * If the specified index is out of range,

- * it will be pinned to to be within 0 <= index <= textLength

- * @param nativeLimit the native string index of the position following the last

- * character to extract. If the specified index is out of range,

- * it will be pinned to to be within 0 <= index <= textLength.

- * nativeLimit must be >= nativeStart.

- * @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 be zero

- * for precomputing the required size.

- * @param status receives any error status.

- * U_BUFFER_OVERFLOW_ERROR: the extracted text was truncated because the

- * buffer was too small. Returns number of UChars for preflighting.

- * @return Number of UChars in the data to be extracted. Does not include a trailing NUL.

- *

- * @stable ICU 3.4

- */

-U_STABLE int32_t U_EXPORT2

-utext_extract(UText *ut,

- int64_t nativeStart, int64_t nativeLimit,

- UChar *dest, int32_t destCapacity,

- UErrorCode *status);

-/**

- * Compare two UTexts (binary order). The comparison begins at each source text's

- * iteration position. The iteration position of each UText will be left following

- * the last character compared.

- *

- * The comparison is done in code point order; unlike u_strCompare, you

- * cannot choose to use code unit order. This is because the characters

- * in a UText are accessed one code point at a time, and may not be from a UTF-16

- * context.

- *

- * This functions works with strings of different explicitly specified lengths

- * unlike the ANSI C-like u_strcmp() and u_memcmp() etc.

- * A length argument of -1 signifies that as much of the string should be used as

- * is necessary to compare with the other string. If both length arguments are -1,

- * the entire remaining portionss of both strings are used.

- *

- * @param s1 First source string.

- * @param length1 Length of first source string in UTF-32 code points.

- *

- * @param s2 Second source string.

- * @param length2 Length of second source string in UTF-32 code points.

- *

- * @return <0 or 0 or >0 as usual for string comparisons

- *

- * @internal ICU 4.4 technology preview

- */

-U_INTERNAL int32_t U_EXPORT2

-utext_compare(UText *s1, int32_t length1,

- UText *s2, int32_t length2);

-/**

- * Compare two UTexts (binary order). The comparison begins at each source text's

- * iteration position. The iteration position of each UText will be left following

- * the last character compared. This method differs from utext_compare in that

- * it accepts native limits rather than lengths for each string.

- *

- * The comparison is done in code point order; unlike u_strCompare, you

- * cannot choose to use code unit order. This is because the characters

- * in a UText are accessed one code point at a time, and may not be from a UTF-16

- * context.

- *

- * This functions works with strings of different explicitly specified lengths

- * unlike the ANSI C-like u_strcmp() and u_memcmp() etc.

- * A limit argument of -1 signifies that as much of the string should be used as

- * is necessary to compare with the other string. If both limit arguments are -1,

- * the entire remaining portionss of both strings are used.

- *

- * @param s1 First source string.

- * @param limit1 Native index of the last character in the first source string to be considered.

- *

- * @param s2 Second source string.

- * @param limit2 Native index of the last character in the second source string to be considered.

- *

- * @return <0 or 0 or >0 as usual for string comparisons

- *

- * @internal ICU 4.4 technology preview

- */

-U_INTERNAL int32_t U_EXPORT2

-utext_compareNativeLimit(UText *s1, int64_t limit1,

- UText *s2, int64_t limit2);

-/**

- * Compare two UTexts case-insensitively using full case folding. The comparison

- * begins at each source text's iteration position. The iteration position of each

- * UText will be left following the last character compared.

- *

- * The comparison is done in code point order; this is because the characters

- * in a UText are accessed one code point at a time, and may not be from a UTF-16

- * context.

- *

- * This functions works with strings of different explicitly specified lengths

- * unlike the ANSI C-like u_strcmp() and u_memcmp() etc.

- * A length argument of -1 signifies that as much of the string should be used as

- * is necessary to compare with the other string. If both length arguments are -1,

- * the entire remaining portionss of both strings are used.

- *

- * @param s1 First source string.

- * @param length1 Length of first source string in UTF-32 code points.

- *

- * @param s2 Second source string.

- * @param length2 Length of second source string in UTF-32 code points.

- *

- * @param options A bit set of options:

- * - U_FOLD_CASE_DEFAULT or 0 is used for default options:

- * Comparison in code point order with default case folding.

- *

- * - U_FOLD_CASE_EXCLUDE_SPECIAL_I

- *

- * @param pErrorCode Must be a valid pointer to an error code value,

- * which must not indicate a failure before the function call.

- *

- * @return <0 or 0 or >0 as usual for string comparisons

- *

- * @internal ICU 4.4 technology preview

- */

-U_INTERNAL int32_t U_EXPORT2

-utext_caseCompare(UText *s1, int32_t length1,

- UText *s2, int32_t length2,

- uint32_t options, UErrorCode *pErrorCode);

-/**

- * Compare two UTexts case-insensitively using full case folding. The comparison

- * begins at each source text's iteration position. The iteration position of each

- * UText will be left following the last character compared. This method differs from

- * utext_caseCompare in that it accepts native limits rather than lengths for each

- * string.

- *

- * The comparison is done in code point order; this is because the characters

- * in a UText are accessed one code point at a time, and may not be from a UTF-16

- * context.

- *

- * This functions works with strings of different explicitly specified lengths

- * unlike the ANSI C-like u_strcmp() and u_memcmp() etc.

- * A limit argument of -1 signifies that as much of the string should be used as

- * is necessary to compare with the other string. If both length arguments are -1,

- * the entire remaining portionss of both strings are used.

- *

- * @param s1 First source string.

- * @param limit1 Native index of the last character in the first source string to be considered.

- *

- * @param s2 Second source string.

- * @param limit2 Native index of the last character in the second source string to be considered.

- *

- * @param options A bit set of options:

- * - U_FOLD_CASE_DEFAULT or 0 is used for default options:

- * Comparison in code point order with default case folding.

- *

- * - U_FOLD_CASE_EXCLUDE_SPECIAL_I

- *

- * @param pErrorCode Must be a valid pointer to an error code value,

- * which must not indicate a failure before the function call.

- *

- * @return <0 or 0 or >0 as usual for string comparisons

- *

- * @internal ICU 4.4 technology preview

- */

-U_INTERNAL int32_t U_EXPORT2

-utext_caseCompareNativeLimit(UText *s1, int64_t limit1,

- UText *s2, int64_t limit2,

- uint32_t options, UErrorCode *pErrorCode);

-/************************************************************************************

- *

- * #define inline versions of selected performance-critical text access functions

- * Caution: do not use auto increment++ or decrement-- expressions

- * as parameters to these macros.

- *

- * For most use, where there is no extreme performance constraint, the

- * normal, non-inline functions are a better choice. The resulting code

- * will be smaller, and, if the need ever arises, easier to debug.

- *

- * These are implemented as #defines rather than real functions

- * because there is no fully portable way to do inline functions in plain C.

- *

- ************************************************************************************/

-/**

- * inline version of utext_current32(), for performance-critical situations.

- *

- * Get the code point at the current iteration position of the UText.

- * Returns U_SENTINEL (-1) if the position is at the end of the

- * text.

- *

- * @internal ICU 4.4 technology preview

- */

-#define UTEXT_CURRENT32(ut) \

- ((ut)->chunkOffset < (ut)->chunkLength && ((ut)->chunkContents)[(ut)->chunkOffset]<0xd800 ? \

- ((ut)->chunkContents)[((ut)->chunkOffset)] : utext_current32(ut))

-/**

- * inline version of utext_next32(), for performance-critical situations.

- *

- * Get the code point at the current iteration position of the UText, and

- * advance the position to the first index following the character.

- * This is a post-increment operation.

- * Returns U_SENTINEL (-1) if the position is at the end of the

- * text.

- *

- * @stable ICU 3.4

- */

-#define UTEXT_NEXT32(ut) \

- ((ut)->chunkOffset < (ut)->chunkLength && ((ut)->chunkContents)[(ut)->chunkOffset]<0xd800 ? \

- ((ut)->chunkContents)[((ut)->chunkOffset)++] : utext_next32(ut))

-/**

- * inline version of utext_previous32(), for performance-critical situations.

- *

- * Move the iterator position to the character (code point) whose

- * index precedes the current position, and return that character.

- * This is a pre-decrement operation.

- * Returns U_SENTINEL (-1) if the position is at the start of the text.

- *

- * @stable ICU 3.4

- */

-#define UTEXT_PREVIOUS32(ut) \

- ((ut)->chunkOffset > 0 && \

- (ut)->chunkContents[(ut)->chunkOffset-1] < 0xd800 ? \

- (ut)->chunkContents[--((ut)->chunkOffset)] : utext_previous32(ut))

-/**

- * inline version of utext_getNativeIndex(), for performance-critical situations.

- *

- * Get the current iterator position, which can range from 0 to

- * the length of the text.

- * The position is a native index into the input text, in whatever format it

- * may have (possibly UTF-8 for example), and may not always be the same as

- * the corresponding UChar (UTF-16) index.

- * The returned position will always be aligned to a code point boundary.

- *

- * @stable ICU 3.6

- */

-#define UTEXT_GETNATIVEINDEX(ut) \

- ((ut)->chunkOffset <= (ut)->nativeIndexingLimit? \

- (ut)->chunkNativeStart+(ut)->chunkOffset : \

- (ut)->pFuncs->mapOffsetToNative(ut))

-/**

- * inline version of utext_setNativeIndex(), for performance-critical situations.

- *

- * 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 the index is out of range, it will be pinned to be within

- * the range of the input text.

- *

- * @stable ICU 3.8

- */

-#define UTEXT_SETNATIVEINDEX(ut, ix) \

- { int64_t __offset = (ix) - (ut)->chunkNativeStart; \

- if (__offset>=0 && __offset<=(int64_t)(ut)->nativeIndexingLimit) { \

- (ut)->chunkOffset=(int32_t)__offset; \

- } else { \

- utext_setNativeIndex((ut), (ix)); } }

-/************************************************************************************

- *

- * 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) with utext_replace() or

- * utext_copy(). For the text to be writable, the text provider must

- * be of a type that supports writing and the UText must not be frozen.

- *

- * Attempting to modify text when utext_isWriteable() is FALSE will fail -

- * the text will not be modified, and an error will be returned from the function

- * that attempted the modification.

- *

- * @param ut the UText to be tested.

- * @return TRUE if the text is modifiable.

- *

- * @see utext_freeze()

- * @see utext_replace()

- * @see utext_copy()

- * @stable ICU 3.4

- *

- */

-U_STABLE UBool U_EXPORT2

-utext_isWritable(const UText *ut);

-/**

- * Test whether there is meta data associated with the text.

- * @see Replaceable::hasMetaData()

- *

- * @param ut The UText to be tested

- * @return TRUE if the underlying text includes meta data.

- * @stable ICU 3.4

- */

-U_STABLE 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 undefined for 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 replaced

- * @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_STABLE int32_t U_EXPORT2

-utext_replace(UText *ut,

- int64_t nativeStart, int64_t nativeLimit,

- const UChar *replacementText, int32_t replacementLength,

- UErrorCode *status);

-/**

- *

- * Copy or move a substring from one position to another within the text,

- * while retaining any metadata associated with the text.

- * This function is used to 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 replace or overwrite any existing text.

- *

- * The iteration position is left following the newly inserted text

- * at the destination position.

- *

- * This function is only available on UText types that support writing,

- * that is, ones where utext_isWritable() returns TRUE.

- *

- * When using this function, there should be only a single UText opened onto the

- * underlying native text string. Behavior after a copy operation

- * on a 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.

- * @param move If TRUE, then the substring is moved, not copied/duplicated.

- * @param status receives any error status. Possible errors include U_NO_WRITE_PERMISSION

- *

- * @stable ICU 3.4

- */

-U_STABLE void U_EXPORT2

-utext_copy(UText *ut,

- 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.

- *

- *

- * Once frozen, a UText can not be unfrozen. The intent is to ensure

- * that a the text underlying a frozen UText wrapper cannot be modified via that UText.

- *

- *

- * Caution: freezing a UText will disable changes made via the specific

- * frozen UText wrapper only; it will not have any effect on the ability to

- * directly modify the text by bypassing the UText. Any such backdoor modifications

- * are always an error while UText access is occuring because the underlying

- * text can get out of sync with UText's buffering.

- *

- *

- * @param ut The UText to be frozen.

- * @see utext_isWritable()

- * @stable ICU 3.6

- */

-U_STABLE void U_EXPORT2

-utext_freeze(UText *ut);

-/**

- * UText provider properties (bit field indexes).

- *

- * @see UText

- * @stable ICU 3.4

- */

-enum {

- /**

- * It is potentially time consuming for the provider to determine the length of the text.

- * @stable ICU 3.4

- */

- UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE = 1,

- /**

- * Text chunks remain valid and usable until the text object is modified or

- * deleted, not just until the next time the access() function is called

- * (which is the default).

- * @stable ICU 3.4

- */

- UTEXT_PROVIDER_STABLE_CHUNKS = 2,

- /**

- * The provider supports modifying the text via the replace() and copy()

- * functions.

- * @see Replaceable

- * @stable ICU 3.4

- */

- UTEXT_PROVIDER_WRITABLE = 3,

- /**

- * There is meta data associated with the text.

- * @see Replaceable::hasMetaData()

- * @stable ICU 3.4

- */

- UTEXT_PROVIDER_HAS_META_DATA = 4,

- /**

- * Text provider owns the text storage.

- * Generally occurs as the result of a deep clone of the UText.

- * When closing the UText, the associated text must

- * also be closed/deleted/freed/ whatever is appropriate.

- * @stable ICU 3.6

- */

- UTEXT_PROVIDER_OWNS_TEXT = 5

-};

-/**

- * Function type declaration for UText.clone().

- *

- * clone a UText. Much like opening a UText where the source text is itself

- * 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 shallow clone replicates only the UText data structures; it does not make

- * a copy of the underlying text. Shallow clones can be used as an efficient way to

- * have multiple iterators active in a single text string that is not being

- * modified.

- *

- * A shallow 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.

- * 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.

- * @param src The UText to be cloned.

- * @param deep TRUE to request a deep clone, FALSE for a shallow clone.

- * @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

- */

-typedef UText * U_CALLCONV

-UTextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status);

-/**

- * Function type declaration for UText.nativeLength().

- *

- * @param ut the UText to get the length of.

- * @return the length, in the native units of the original text string.

- * @see UText

- * @stable ICU 3.4

- */

-typedef int64_t U_CALLCONV

-UTextNativeLength(UText *ut);

-/**

- * Function type declaration for UText.access(). Get the description of the text chunk

- * containing the text at a requested native index. The UText's iteration

- * 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.

- *

- * @param ut the UText being accessed.

- * @param nativeIndex Requested index of the text to be accessed.

- * @param forward If TRUE, then the returned chunk must contain text

- * starting from the index, so that start<=index<limit.

- * If FALSE, then the returned chunk must contain text

- * before the index, so that start<index<=limit.

- * @return True if the requested index could be accessed. The chunk

- * will contain the requested text.

- * False value if a chunk cannot be accessed

- * (the requested index is out of bounds).

- *

- * @see UText

- * @stable ICU 3.4

- */

-typedef UBool U_CALLCONV

-UTextAccess(UText *ut, int64_t nativeIndex, UBool forward);

-/**

- * Function type declaration for UText.extract().

- *

- * Extract text from a UText into a UChar buffer. The range of text to be extracted

- * is specified in the native indices of the UText provider. These may not necessarily

- * be UTF-16 indices.

- *

- * The size (number of 16 bit UChars) in the data to be extracted 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 which to extract data.

- * @param nativeStart the native index of the first characer to extract.

- * @param nativeLimit the native string index of the position following the last

- * character to extract.

- * @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 be zero

- * for precomputing the required size.

- * @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 include a trailing NUL.

- *

- * @stable ICU 3.4

- */

-typedef int32_t U_CALLCONV

-UTextExtract(UText *ut,

- int64_t nativeStart, int64_t nativeLimit,

- UChar *dest, int32_t destCapacity,

- UErrorCode *status);

-/**

- * Function type declaration for UText.replace().

- *

- * 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 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 to be operated on.

- * @param nativeStart the index of the start of the region to be replaced

- * @param nativeLimit the index of the character following the region to be replaced.

- * @param replacementText pointer to the replacement text

- * @param replacmentLength length of the replacement text in UChars, 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

- */

-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().

- *

- * 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 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 replace or overwrite any existing text.

- *

- * 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

- * 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.

- * @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. Possible errors include U_NO_WRITE_PERMISSION

- *

- * @stable ICU 3.4

- */

-typedef void U_CALLCONV

-UTextCopy(UText *ut,

- int64_t nativeStart, int64_t nativeLimit,

- int64_t nativeDest,

- UBool move,

- UErrorCode *status);

-/**

- * Function type declaration for UText.mapOffsetToNative().

- * Map from the current UChar offset within the current text chunk to

- * the corresponding native index in the original source text.

- *

- * This is required only for text providers that do not use native UTF-16 indexes.

- *

- * @param ut the UText.

- * @return Absolute (native) index corresponding to chunkOffset in the current chunk.

- * The returned native index should always be to 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 offset within a text chunk.

- * Behavior is undefined if the native index does not fall within the

- * current chunk.

- *

- * This function is required only for text providers that do not use native UTF-16 indexes.

- *

- * @param ut The UText containing the text chunk.

- * @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 int32_t U_CALLCONV

-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 is closed.

- *

- * 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.

- *

- * Most UText provider implementations do not need to implement this function.

- *

- * @param ut A UText object to be closed.

- *

- * @stable ICU 3.4

- */

-typedef void U_CALLCONV

-UTextClose(UText *ut);

-/**

- * (public) Function 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 {

- /**

- * (public) Function table size, sizeof(UTextFuncs)

- * Intended for use should the table grow to accomodate added

- * functions in the future, to allow tests for older format

- * function tables that do not contain the extensions.

- *

- * Fields are placed for optimal alignment on

- * 32/64/128-bit-pointer machines, by normally grouping together

- * 4 32-bit fields,

- * 4 pointers,

- * 2 64-bit fields

- * in sequence.

- * @stable ICU 3.6

- */

- int32_t tableSize;

- /**

- * (private) Alignment padding.

- * Do not use, reserved for use by the UText framework only.

- * @internal

- */

- int32_t reserved1, /** @internal */ reserved2, /** @internal */ reserved3;

- /**

- * (public) Function pointer for UTextClone

- *

- * @see UTextClone

- * @stable ICU 3.6

- */

- UTextClone *clone;

- /**

- * (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.6

- */

- UTextAccess *access;

- /**

- * (public) Function pointer for UTextExtract.

- *

- * @see UTextExtract

- * @stable ICU 3.6

- */

- UTextExtract *extract;

- /**

- * (public) Function pointer for UTextReplace.

- *

- * @see UTextReplace

- * @stable ICU 3.6

- */

- UTextReplace *replace;

- /**

- * (public) Function pointer for UTextCopy.

- *

- * @see UTextCopy

- * @stable ICU 3.6

- */

- UTextCopy *copy;

- /**

- * (public) Function pointer for UTextMapOffsetToNative.

- *

- * @see UTextMapOffsetToNative

- * @stable ICU 3.6

- */

- UTextMapOffsetToNative *mapOffsetToNative;

- /**

- * (public) Function pointer for UTextMapNativeIndexToUTF16.

- *

- * @see UTextMapNativeIndexToUTF16

- * @stable ICU 3.6

- */

- UTextMapNativeIndexToUTF16 *mapNativeIndexToUTF16;

- /**

- * (public) Function pointer for UTextClose.

- *

- * @see UTextClose

- * @stable ICU 3.6

- */

- UTextClose *close;

- /**

- * (private) Spare function pointer

- * @internal

- */

- UTextClose *spare1;

- /**

- * (private) Spare function pointer

- * @internal

- */

- UTextClose *spare2;

- /**

- * (private) Spare function 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

- * and the UText provider code that works on specific kinds of

- * text (UTF-8, noncontiguous UTF-16, whatever.)

- *

- * Applications that are using predefined types of text providers

- * to pass text data to ICU services will have no need to view the

- * internals of the UText structs that they open.

- *

- * @stable ICU 3.6

- */

-struct UText {

- /**

- * (private) Magic. Used to help detect when UText functions are handed

- * invalid or unitialized UText structs.

- * 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 must NOT clear

- * the magic field because that would prevent

- * reuse of the UText struct.

- * @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 maintainted by the

- * text provider implementation.

- * @stable ICU 3.4

- */

- int32_t providerProperties;

- /**

- * (public) sizeOfStruct=sizeof(UText)

- * Allows possible backward compatible extension.

- *

- * @stable ICU 3.4

- */

- int32_t sizeOfStruct;

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

- /**

- * (protected) Native index of the first character position following

- * the current chunk.

- * @stable ICU 3.6

- */

- int64_t chunkNativeLimit;

- /**

- * (protected) Size in bytes of the extra space (pExtra).

- * @stable ICU 3.4

- */

- int32_t extraSize;

- /**

- * (protected) The highest chunk offset where native indexing and

- * chunk (UTF-16) indexing correspond. For UTF-16 sources, value

- * will be equal to chunkLength.

- *

- * @stable ICU 3.6

- */

- 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) 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

- */

- int32_t chunkOffset;

- /**

- * (protected) Length the text chunk (UTF-16 buffer), in UChars.

- * @stable ICU 3.6

- */

- int32_t chunkLength;

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

- /**

- * (protected) pointer to a chunk of text in UTF-16 format.

- * May refer either to original storage of the source of the text, or

- * if conversion was required, to a buffer owned by the UText.

- * @stable ICU 3.6

- */

- const UChar *chunkContents;

- /**

- * (public) Pointer to Dispatch table for accessing functions for this UText.

- * @stable ICU 3.6

- */

- const UTextFuncs *pFuncs;

- /**

- * (protected) Pointer to additional space requested by the

- * text provider during the utext_open operation.

- * @stable ICU 3.4

- */

- void *pExtra;

- /**

- * (protected) Pointer to string or text-containin object or similar.

- * This is the source of the text that this UText is wrapping, in a format

- * that is known to the text provider functions.

- * @stable ICU 3.4

- */

- const void *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;

- /**

- * (protected) Pointer fields available for use by the text provider.

- * Not used by UText common code.

- * @stable ICU 3.6

- */

- const void *r;

- /**

- * 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

- */

- 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.

- * @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 for future use by the UText framework

- * 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_STABLE UText * U_EXPORT2

-utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status);

-/**

- * @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

-#endif

« no previous file with comments | « public/common/unicode/usystem.h ('k') | public/common/unicode/utf.h » ('j') | no next file with comments »