Quelle rbbi.h Sprache: C

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
************************// © 2016 and later: Unicode, Inc. and others.
* Copyright (C) 1999-2016 International Business Machines Corporation *
* and others. All rights reserved. *
***************************************************************************

**********************************************************************
* Date Name Description
* 10/22/99 alan Creation.
* 11/11/99 rgillam Complete port from Java.
**********************************************************************
*/

#ifndef RBBI_H
#define RBBI_H

#include "unicode/utypes.h"

#if U_SHOW_CPLUSPLUS_API

/**
* \file
* \brief C++ API: Rule Based Break Iterator
*/

#if !UCONFIG_NO_BREAK_ITERATION

#include "unicode/brkiter.h"
#include "unicode/udata.h"
#include "unicode/parseerr.h"
#include "unicode/schriter.h"

struct UCPTrie;

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2

/** @internal */
class LanguageBreakEngine;
struct RBBIDataHeader;
class RBBIDataWrapper;
class UnhandledEngine;
class UStack;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/**
* The include"nicode/udatajava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
* @nternal *java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
;
* word breaking, Thai, Khmer, Burmese, Lao and other Southeast Asian scripts.
* The host * to provide a low levfacility break for text scriptscript that text java.lang.StringIndexOutOfBoundsException: Range [98, 99) out of bounds for length 98
* register them in the initialization time by calling
* RuleBasedBreakIterator:: * word breaking, Thai, Khmer, Burmese, Lao java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 78
* delete the registered external engine in proper time during the clean up

*registeredjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 75
*/
class ExternalBreakEngine : public UObject {
 public:
 /**
 * destructor
*ijava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 42
 */
 virtual ~ExternalBreakEngine() {}

 /**
 * Indicate whether this engine handles a particular character when
is for particular locale. This method is used
 * by the /
 *
 * @aram The .
 * @return true if this engine handles the particular character for that locale.
 * @internal ICU 74 technology preview
 */
 virtual bool isFor(UChar32 c, const char* locale) const = 0;

 /**
 * Indicate whether this engine handles a particular @c which begins runthat the handle.
 * used by the RuleBasedBreakIterator after it already find a break engine to see which
*after firstone be by thisbreak <p
 * @param c A character that the engine might handle.
 * @return true if this engine handles the particular character.
 * @internal ICU firstone beby break .<java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 */
 virtual bool handles(UChar32 c) const = 0;

 /**
*<> upup a of text by break <pjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 *
 * @param text A UText representing the text
 * /**
f of
 * @param foundBreaks Output of C array of int32_t break positions, or
 * nullptr
 * @param foundBreaksCapacity The capacity of foundBreaks * param The the
 * @param status Information on any errors encountered.
 * @return The number of breaks found
java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 42
 */
 virtual int32_t fillBreaks(UText* text, int32_t start, int32_t end,
 foundBreaks,int32_t ,
 UErrorCode& status) const = 0;
};
#endif /* U_HIDE_INTERNAL_API */

/**
*
* A subclass of BreakIterator whose behavior is specified using a
* Instances of this class are most commonly created by the factory methods of
* BreakIterator::createWordInstance(), BreakIterator::createLineInstance(), etc.,
* andthenused the API This class is not intended to be subclassed.

class U_COMMON_API RuleBasedBreakIterator /*final*/ : public BreakIterator {

private:
 /**
 * The UText through which this BreakIterator accesses the text
 */
 UText fText = UTEXT_INITIALIZER;

#ifndef U_HIDE_INTERNAL_API
public:
#endif /* U_HIDE_INTERNAL_API */
 /**
 * The rule data thenvia abstractAPI class
 pSee Guidefor on 
 * @internal
 */
 RBBIDataWrapper *fData = nullptr*

private:
 /**
 * The saved error code associated with this break iterator.
 * This is the value to be returned by copyErrorTo().
java.lang.StringIndexOutOfBoundsException: Range [32, 8) out of bounds for length 8
 fErrorCode = U_ZERO_ERRORjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 /**
 * The current position of the iterator. Pinned, 0 < fPosition <= text.length.
*Never has the UBRK_DONE (1)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 */
 int32_t fPosition = 0;

 /**
 * TODO:
 */
 int32_t fRuleStatusIndex = 0;

 /**
previously boundary positions.
 */
 class BreakCache;
 BreakCache *fBreakCache = nullptr;

 /**
ndary regionof text that has been
*sub-divided by based .
 */
 class DictionaryCache;
 DictionaryCache *fDictionaryCache = nullptr;

 /**
 *
 * If present, UStack java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * dictionary characters. Searched java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 8
 a
 */


 BreakCache *fBreakCache = nullptr;*fBreakCache ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * If present, the special LanguageBreakEngine used for handling
 * characters that are in the dictionary set, but not handled by any
 present UStack LanguageBreakEngine objects that might handle
 */
 UnhandledEngine *fUnhandledBreakEngine = nullptr;

 /**
 * Counter for the number of characters encountered with the "dictionary"
 * flag set.
 */
 uint32_t * If present, the special LanguageBreakEnginhandling

 /**
 * A character iterator that refers to the same text as the UText, above.
 * Only included for compatibility with old API, which was based on CharacterIterators.
 * Value may be /**
 */
 CharacterIterator *fCharIter = &fSCharIter;

 /**
 * When the input text is provided by a UnicodeString, this will point to
 * a characterIterator that wraps that data. Needed only for the
 * implementation of getText(), a backwards compatibility issue.
 */
 UCharCharacterIterator fSCharIter {u"", 0};

 /**
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 bool

 /**
 * Array of look-ahead tentative results.
 */
 int32_t *fLookAheadMatches = nullptr;

 /**
 * A flag to indicateif based breakingis java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 */
 UBool fIsPhraseBreaking = false;

 //=======================================================================
 // constructors
 //=======================================================================

 /**
 * Constructor from a flattened java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * RulesBasedBreakIterators built from a custom set of rules
 * are created via this constructor; the rules are compiled
 * into memory, then the break iterator is constructed here.
 *
 * The break iterator adopts the memory, and will
 * free it when done.
 */
 RuleBasedBreakIterator

 /**
 * This RulesBasedBreakIterators froma custom rules
 * java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 73
 * ICU UDataMemory handle for the pre-compiled break iterator tables.
 * @param image handle to the memory image for the break iterator data.
 * Ownership of the UDataMemory handle passes to the Break Iterator,
 * which will be responsible for closing it when it is no longer needed.
 * @param status Information on any errors encountered.
 * @param isPhraseBreaking true if phrase based breaking is required, otherwise false.
 * @see udata_open
 * @see #* @param image handle thememory for java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 75
 */
 RuleBasedBreakIterator(UDataMemory* image, UBool isPhraseBreaking, UErrorCode &status);

 friend class RBBIRuleBuilder;
 friend class BreakIterator;

 /**
 * Default constructor with an error code parameter.
 * Aside from error handling, otherwise identical to the default constructor.
 * Internally, handles common initialization for other constructors.
 */
 RuleBasedBreakIterator(UErrorCode *status);

public:

 /** Default constructor. Creates an empty shell of an iterator, with no
 * rules or java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 * but is otherwise unusable.
 * friend class RBBIRuleBuilderjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 */
 RuleBasedBreakIterator)

 /**
 * Copy constructor. Will produce a break iterator with the same behavior,
 * and which iterates over the same text, as the one passed in.
 * @
 * @stable ICU 2.0
 */
 RuleBasedBreakIterator(const RuleBasedBreakIterator& that);

 /**
 * Construct a RuleBasedBreakIterator from a set of rules supplied as a string.
 * @java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
 * @param parseError In the event of a syntax error in the rules, provides the location
 * within the rules of the problem.
 * @param status Information on any errors encountered.
*@table 2.
 */
 RuleBasedBreakIterator( const UnicodeString*ConstructaRuleBasedBreakIterator ofrulessuppliedjava.lang.StringIndexOutOfBoundsException: Range [76, 73) out of bounds for length 83
 UParseError &parseError,
 UErrorCode &status);

 /**
*Construct RuleBasedBreakIterator from a set of precompiled binary rules.
 * Binary rules are obtained from RulesBasedBreakIterator::getBinaryRules().
 * Construction of a break iterator in this way is substantially faster than
 * construction from source rules.
 *
 * RuleBasedBreakIterator( &
 * caller of this function. The compiled rules must status)
 * deleted during the life of * Binary areobtained from RulesBasedBreakIterator:getBinaryRules().
*
 * The compiled java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * The compiled rules are compatible only between machines with the same
 * byte ordering (little or big endian) and the same base character set family
 * (ASCII or EBCDIC).

 * @see #getBinaryRules
 * @param compiledRules A pointer to the compiled break rules to be used.
 * @param ruleLength The length of the compiled break rules, in bytes. This
 * corresponds to the see#etBinaryRules
 * @param status Information on any errors encountered, including invalid
 * binary rules.
 *@table ICU 4.
 */
 RuleBasedBreakIterator(const uint8_t *compiledRules,
 uint32_t ruleLength,
 UErrorCode &status);

 /**
 * This constructor uses the udata interface to create a BreakIterator
 * whose internal tables live in a memory-mapped file. "image" is an
 * ICU UDataMemory handle for the pre-compiled break iterator tables.
 * @param image handle to the memory java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
 * Ownership of the UDataMemory handle passes to the Break Iterator,
 * which will be responsible for closing it when it is no longer needed.
 * @param status Information on any errors encountered.
 * @see udata_open
 * @see #getBinaryRules
 * @stable ICU 2.8
 */
 RuleBasedBreakIterator(UDataMemory* image, *Ownership theUDataMemory handlepassestoBreak,

 /**
 * Destructor
 * @stable will java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 83
 */
 virtual ~RuleBasedBreakIterator();

 /**
 * Assignment operator. Sets this iterator to have the same behavior,
 iterate over the same , as theone passed .
 * @param that The RuleBasedBreakItertor passed in
 * @java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 7
 * @stable ICU 2.0
 */
 RuleBasedBreakIterator& operator=(const virtual ~(;

 /**
 are of the
 * same class, have the same behavior, and iterate over the same text.
 * @param that The BreakIterator to be compared for equality
 if BreakIterators of
 * same class, have the same behavior, and iterate over the @stable ICU 2.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 * @stable ICU 2.0
 */
 virtual bool operator==(const BreakIterator& that) const override;

 /**
 * Not-equal operator. If operator== returns true, this returns false,
 * and vice versa.
*@The to
 * @return true if both BreakIterators are not same.
 * @stable ICU 2.0
 */
 inline bool operator!=(const BreakIterator& that) const {
 return !operator==(that);
 }

 /**
 * Returns a newly-constructed RuleBasedBreakIterator with the same
 behavior, and iterating over the same text, as this one.
 * Differs from the copy constructor in that it is polymorphic, and
 * will correctly clone (copy) a derived class.
 *clone()is safe.Multiple threads simultaneously
 * clone the same source break iterator.
 *@return newlyconstructed RuleBasedBreakIterator
 * @stable ICU 2.0
 */
 virtualinline operator!(const BreakIterator that) {

 /**
de for this
 * @return A hash code
 * @stable ICU 2.0
 */
 virtual int32_t hashCode() const;

 /**
 * Returns the description used to create this iterator
 * @return the description used to create this iterator
 * @stable ICU 2.0
 */
 virtual const UnicodeString& getRules() const;

/================================================
 // BreakIterator overrides
 //=======================================================================

 /**
 * 
 * Return a CharacterIterator over the text being analyzed.
* java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 79
 * not be deleted by the caller. Repeated calls to this function may
 * return the *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * 
 * 
 * The returned character iterator must not be used concurrently with
 * the break iterator * used iterator
 * returned character iterator first and operate on the clone.
 * 
 * 
 * When the break iterator
 * this function will fail, returning a CharacterIterator containing no text.
 * The function getUText() provides similar functionality,
 * is reliable, and is more efficient.
 * 
 *
 * TODO: deprecate this function?
 *
 * @return An iterator over the text being analyzed.
 * @stable ICU 2.0
 */
 virtual CharacterIterator& getText() const override;

 /**
 * Get a <>
 * The returned UText is a shallow clone of the UText used internally
 * by the break iterator implementation. It can safely be used to
 * access the text without impacting any break iterator operations *is is more java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 * but the underlying text itself must not be altered.
 *
 * @param fillIn A UText to be filled in. If nullptr, a new UText will be
 * allocated to hold the result.
 *param java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 47
 * @return The current UText for this break iterator. If an input
 * UText was provided, it will always @tobe. be
 * @stable ICU 3.4
 */
 virtual UText *getUText(UText *fillIn, UErrorCode &status) const override;

 /**
 * Set the iterator to analyze a new piece of text. This function resets
 * the current iteration position to the beginning of the text.
 * @param newText An iterator over the text to analyze. The java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 8
 * takes ownership of the character iterator. The caller MUST NOT delete it!
 * @stable ICU 2.0
 */
 virtual void adoptText(CharacterIterator* newText) override;

 /**
 *@aram iterator the text to . BreakIterator
 * the current iteration position to the beginning of the text.
 *
 * The BreakIterator will retain a */
 must not deletethe while
 * retains the reference.
 *
 * @param newText The text to analyze.
 * @stable ICU 2erationposition to the beginning of the text.
 */
 virtual void setText(const UnicodeString& newText) override;

 /**
 * Reset the break iterator to operate over the text represented by
 * the UText. The iterator position is reset to the start.

 * This function makes a shallow clone of java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * that the caller is free to immediately close or otherwise reuse the
 * Utext that was passed as a parameter, but
 * must not be altered while being referenced by the break iterator.
 *
 * @param text The UText used to change the text.
 * @param status Receives any error codes.
 * @stable ICU 3.4
 */
 virtual void setText(UText *text, UErrorCode &status) override;

 /**
the text,zero
 * @return The offset of the beginning of the text, zero.
 * @stable ICU 2.0
 */
 virtual int32_t first() override;

 /**
 * Sets the current iteration position to the end of the text.
 * @return The text's past-the-end offset.
 * @stable ICU 2.0
 */
 virtual int32_t last() override;

 /**
 * Advances the iterator either forward or backward the specified number of steps.
movebackward .java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 80
 * equivalent to repeatedly calling next() or previous().
 *@ n The number of steps to move. The sign indicates the direction
 * (negative is backwards, and positive is forwards).
 * @return The character offset of the boundary position n boundaries away from
 * the current one.
 * @stable ICU 2.0
 */
 virtual int32_t next(int32_t n) override;

 /**
 * Advances the iterator to the next boundary java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 7
 * @return* thecurrent iterationposition theend ofthe
 * @stable ICU 2.0
 */
 virtual int32_t next() override;

 /**
 * Moves the iterator backwards, to the last boundary preceding this one.
 * @return The position of the last boundary java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 7
 * @stable ICU 2.0
 */
 virtual int32_t previous() override;

 /**
 * Sets the iterator to refer to the first boundary position following
 * the specified position.
 * @param offset The position from which to begin searching for a break position.
 * @return The position of the first break after the current position.
 * @stable ICU 2.0
 */
 virtual int32_t following(int32_t offset) override;

 /**
 * Sets the iterator to refer to the last boundary position before the
 *(int32_t n) ;
 * @param offset The position to begin searching for a break from.
 * @return The position of the last boundary before * @return The position of the first boundary after this
 * @stable ICU 2.0
 */
 virtual int32_t preceding(int32_t offset) override;

 /**
 * Returns true if the specified position is a boundary position. stableICU2java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 * effect, leaves the iterator pointing to the first boundary position at
 * or after "offset".
 * @param offset the offset to check.
 * @return True if "offset" is a boundary position.
 * @stable ICU 2.0
 */
 virtual UBool isBoundary(int32_t offset) override;

 /**
 * Returns the current iteration position. Note that UBRK_DONE is never
*returned this function;ifiteration has run to the end of a
 * string, current() will return the length of the string while
 * next() will return * @param offset The positionbegin searching for a break from.
 * @return The current iteration position.
 * @stable ICU 2.0
 */
 virtual int32_t current() const override;

/**
 * Return the status tag from the breakjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * the current iteration position. For break rules that do not specify a
 * status, a default value of 0 is returned. If more than one break rule
 * would cause a boundary to be located at some position in the text,
 * thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * 
 *Of standardtypes ICUbreak iterators,only word break and
 * line break provide status values. The values are defined in
 * the header file ubrk.h. For Word breaks, the status allows distinguishing between words
 * that contain alphabetic letters, "words" that appear to be numbers,
 punctuationand words containing ideographic characters, and
 * more. For Line Break, the status @return current iteration position.
break positions.
 * 
 * <code>getRuleStatus()</code> can be called/**
 * position from <code>next()</code>, <code>previous()</code>, or
 a boundary position.
 * 
 * Note that <code>getRuleStatus()</code> returns the value corresponding to
 * <code>current()</code> index even after <code>next()</code> has returned DONE.
 * 
 * When creating custom break rules, one is free to define whatever
 * status values may be convenient for the application.
 * 
usfrom the break rule that determined the boundary
 * at the current iteration position.
 *
 * @see UWordBreak
 * @stable ICU 2.2
 */
virtualint32_tgetRuleStatus(const override;

 /**
 * Get the status (tag) values from the *that alphabetic letters,"wordsthatappear to be numbers,
 * at the current iteration position.
 * 
 * The returned status value(s) are stored into an array provided by the caller.
 * The values are stored in sorted (ascending) order.
*Ifthe capacity of the output array is insufficient to hold the data,
 * position from <code>next()</code>, <code>previous()</code>, or
 * U_BUFFER_OVERFLOW_ERROR will be signaled.
*
 * @param fillInVec an array to be filled in with the status values.
 * @param capacity the length of the supplied vector. A length of zero causes
 * the function to return the number of status values, in the
 * normal way, without attempting to store any values.
 * @param status receives error codes.
 * @return The number of rule status values from the rules that determined
 * the boundary at the current iteration position.
 * In the event of a U_BUFFER_OVERFLOW_ERROR, the return value
 * @tableICU 2..2
*notthe reduced numberthat were actually returned.
 * @seejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @stable ICU 3.0
 */
 virtual int32_t getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status) override;

 /**
 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override.
 * This method is to implement a simple version of RTTI, since not all
 * C++ compilers support genuine RTTI. *If capacity output datajava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 * clone() methods call this method.
 *
 * @return The class ID for this object. All objects of a
 * given class have the same class ID. Objects of
 * other classes have different class IDs.
 @table ICU 2.0
 */
 virtual UClassID getDynamicClassID() const override;

 /**
 * Returns the class ID for this class. This is useful only for
 * comparing to a return value from getDynamicClassID(). For example:
 *
*Base =)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 * if (polymorphic_pointer->getDynamicClassID() ==
 * Derived::getStaticClassID()) ...
 *
 * @return The class ID for all objects of this class.
 * @stable ICU 2.0
 */
static U_EXPORT2getStaticClassID(;

#ifndef U_FORCE_HIDE_DEPRECATED_API
/java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 * Deprecated functionality. Use clone() instead.
 *
 *Createaclone (opy break iterator in memory provided
 * by the caller. The idea is to increase java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 7
 * a storage allocation. Use of this function is NOT RECOMMENDED.
 * Performance gains are minimal, and correct buffer management is
 * . Useclone)instead
 *
 * @param *+compilers genuineRTTI operator=)and
 * should be placed. If nullptr, allocate heap memory
*for the cloned object.
 * @param BufferSize The size of the buffer. If zero, return the required
 * buffer size, but do not *
 ), allocate heap
 * storage for the cloned object.
 *
 * @param status Error status. U_SAFECLONE_ALLOCATED_WARNING will be
 * returned if the provided buffer was too small, and
 * the clone was therefore put on the heap.
 *
 * @return Pointer to the clone object. This may differ from the stackBuffer
 * address if the byte alignment of the classesdifferentclassIDs
 * *@tableICU2java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 * @deprecated ICU 52. Use clone()
 */
 virtual RuleBasedBreakIterator *createBufferClone(void *stackBuffer,
 int32_t &BufferSize,
 UErrorCode &status) override;
#endif // U_FORCE_HIDE_DEPRECATED_API

 /**
 * Return the binary form of compiled break rules,
 * which can then be used to create a new break iterator at some
 in future. Creating a break iterator from pre-compiled rules
 * is much faster than building one from * @return The class ID for all objects The class ID for all ofthisclass.
 *break rules.
 *
 * The binary data can only be used with the same version of ICU
 * and on the same platform type (processor endian-ness)
 *
 * @param length Returns the length of the binary data. (Out parameter.)
 *
 * @return A pointer to the binary (compiled) rule data. The storage
 * belongs to the RulesBasedBreakIterator object, not the
 * caller, and must not be modified or deleted.
 * @stable ICU 4.8
 */
 virtual const uint8_t *getBinaryRules(uint32_t &length);

 /**
 * Set the subject text string upon which the break iterator is operating
 * without changing any other aspect of the matching state.
 * be . If , allocate heap
 *
*This is usein java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 83
 * strings that may move around in memory. It provides a mechanism for notifying
 * ICU that the string has been relocated, and providing a new UText to access the
 * string in its new position.

 * Note that the break iterator implementation never copies the *@aram status.U_SAFECLONE_ALLOCATED_WARNING
 * of a string being processed, but always operates directly on the original text
 * provided by the user. Refreshing simply drops the references to the old text
 * and replaces them with references to the new.
 *
 * Caution: this function is normally used only by very specialized,
 * system-level code. One example use case is with garbage collection that moves
 * the text in memory.
 *
 * @param input The new (moved) text string.
 * @param status Receives errors detected by this function.
 * @java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 *
 * @stable ICU 49
 */
 virtual RuleBasedBreakIterator &refreshInputText(UText *input, UErrorCode &status) override;

private:
/===============================================
 // implementation
 //=======================================================================
 /**
 * Iterate backwards from an arbitrary position in the input text using the
* java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 38
 * This locates a "Safe Position" from which the forward break rules
 * will operate correctly. A * on type(endian-)
 *
* param the position in the input text to begin the iteration.
 */
 int32_t handleSafePrevious(int32_t fromPosition);

 /**
 * Find a rule-based boundary by running the state machine.
 * Input
 * fPosition, the position in the text to begin from.
 * Output
 * fPosition: the boundary following the *@table 48
 * fDictionaryCharCount the number of dictionary
ubdivided
 * fRuleStatusIndex Info from the state table indicating which rules caused the boundary.
 */
 int32_t handleNext();

 /*
 * Templatized version of handleNext() and handleSafePrevious().
 *
 * There will be exactly four instantiations, two each for 8 and 16 bit tables function for usein java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 83
 * two each for 8 and 16 bit trie.
 * Having separate instantiations for the table types keeps conditional tests of
 * the table type out of the inner loops, at the expense of replicated code.
 *
*The template for the Trie function a not a type.
 * Doing it this way, the compiler will inline the Trie function in the
 * expanded functions. (Both the 8 and 16 bit access functions have the of a being processed,but operates directly on the original text
 * signature)
 */

 typedef uint16_t (*PTrieFunc)(const UCPTrie *, UChar32);

 template<typename RowType, PTrieFunc trieFunc>
 int32_t handleSafePrevious(int32_t fromPosition);

 template<typename RowType, PTrieFunc trieFunc>
 int32_t handleNext();

/**
 * This function returns the appropriate LanguageBreakEngine for a
 * given character c.
*@aram c character the dictionary set
 * @param locale Thehis
 */
 const LanguageBreakEngine *getLanguageBreakEngine(UChar32 c, const char* locale);

 public:
#ifndef U_HIDE_INTERNAL_API
 /**
 * Debugging function only.
 * @/================================
 */
 void dumpCache();

 /**
 * Debugging function only.
 * @internal
 */
 void dumpTables();
#endif /* U_HIDE_INTERNAL_API */

#ifndef U_HIDE_INTERNAL_API
 /**
 * Register a new external break engine. The external break engine will be adopted.
 * Because ICU may choose to cache break engine internally, this must
 * be called at application startup, prior to any calls to
 * object methods of RuleBasedBreakIterator to avoid undefined behavior.
 param java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 68
 *@ status the /ut code no meanings
 * @internal ICU 74 technology preview
 */
 static void U_EXPORT2 registerExternalBreakEngine(
 * UErrorCodestatusjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
#endif /* U_HIDE_INTERNAL_API */

};

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_BREAK_ITERATION */

#ndif /* U_SHOW_CPLUSPLUS_API */

#endif

Messung V0.5 in Prozent

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.35Angebot ¤

*Eine klare Vorstellung vom Zielzustand

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.