/*

*******************************************************************************

*

*   Copyright (C) 2004-2005, International Business Machines

*   Corporation and others.  All Rights Reserved.

*

*******************************************************************************

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

 *

 *

 * <em>Iterating over text</em>

 *

 * Here is sample code for a forward iteration over the contents of a UText

 *

 * \code

 *    UChar32  c;

 *    UText    *ut = whatever();

 *

 *    for (c=utext_next32From(ut, 0); 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

 *

 * <em>Characters and Indexing</em>

 *

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

 *

 */

#include "unicode/utypes.h"

#ifdef XP_CPLUSPLUS

#include "unicode/rep.h"

#include "unicode/unistr.h"

#endif

#ifndef U_HIDE_DRAFT_API

U_CDECL_BEGIN

struct UText;

typedef struct UText UText; /**< C typedef for struct UText. @draft ICU 3.4 */

struct UTextChunk;

typedef struct UTextChunk UTextChunk; /**< C typedef for struct UTextChunk. @draft ICU 3.4 */

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

 *

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

 *

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

/**

  * utext_close    Close function for UText instances.

  *                Cleans up, releases any resources being held by an

  *                open UText.

  * <p/>

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

  *

  * @draft ICU 3.4

  */

U_DRAFT UText * U_EXPORT2

utext_close(UText *ut);

/**

 * 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

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

 * @draft ICU 3.4

 */

U_DRAFT UText * U_EXPORT2

utext_openUTF8(UText *ut, const char *s, int32_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.

 * @draft ICU 3.4

 */

U_DRAFT UText * U_EXPORT2

utext_openUChars(UText *ut, const UChar *s, int32_t length, UErrorCode *status);

#ifdef XP_CPLUSPLUS

/**

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

 * @draft ICU 3.4

 */

U_DRAFT UText * U_EXPORT2

utext_openUnicodeString(UText *ut, 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.

 * @draft ICU 3.4

 */

U_DRAFT UText * U_EXPORT2

utext_openConstUnicodeString(UText *ut, const 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

 * @draft ICU 3.4

 */

U_DRAFT UText * U_EXPORT2

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

#endif

/**

  *  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 will not fail, barring 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

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

  *  @draft ICU 3.4

  */

U_DRAFT UText * U_EXPORT2

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

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

 *

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

  *

  * @draft ICU 3.4

  */

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

 * @draft ICU 3.4

 */

U_DRAFT 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 difference if the index is out of bounds by being less than zero)

 * 

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

 * @draft ICU 3.4

 */

U_DRAFT UChar32 U_EXPORT2

utext_char32At(UText *ut, int32_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.

 * @draft ICU 3.4

 */

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

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

 * text.

 * 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

 * @draft ICU 3.4

 */

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

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

 *  This is a pre-decrement operation.

 *

 * 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

 *  @draft ICU 3.4

 */

U_DRAFT UChar32 U_EXPORT2

utext_previous32(UText *ut);

/**

  * Set the iteration index, access the text for forward iteration,

  * and return the code point starting at or before 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.

  *

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

  * @draft ICU 3.4

  */

U_DRAFT UChar32 U_EXPORT2

utext_next32From(UText *ut, int32_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.

  *

  * @draft ICU 3.4

  */

U_DRAFT UChar32 U_EXPORT2

utext_previous32From(UText *ut, int32_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, and may not always correspond to a UChar (UTF-16) index

  * into the text.  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.

  * @draft ICU 3.4

  */

U_DRAFT int32_t U_EXPORT2

utext_getNativeIndex(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 trimmed to be within

  * the range of the input text.

  * <p/>

  * It will usually be more efficient to begin an iteration

  * using the functions utext_next32From() or utext_previous32From()

  * rather than setIndex().

  * <p/>

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

  * @draft ICU 3.4

  */

U_DRAFT void U_EXPORT2

utext_setNativeIndex(UText *ut, int32_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.

  * <p/>

  * The index is moved by <code>delta</code> code points

  * forward or backward, but no further backward than to 0 and

  * no further forward than to utext_nativeLength().

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

  * <p/>

  * Because the index is kept in the native units of the text provider, the

  * actual numeric amount by which the index moves depends on the

  * underlying text storage representation of the text provider.

  *

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

  * @draft ICU 3.4

  */

U_DRAFT UBool U_EXPORT2

utext_moveIndex32(UText *ut, int32_t delta);

/**

 *

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

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

 * be UTF-16 indices.

 * <p/>

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

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

 *

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

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

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

 *               character to extract.  If the specified limit is greater than the length

 *               of the text, the limit will be trimmed back to the text length.

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