icuSources/common/rbbi57.h

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 ***************************************************************************
   5 *   Copyright (C) 1999-2016 International Business Machines Corporation   *
   6 *   and others. All rights reserved.                                      *
   7 ***************************************************************************
   8
   9 **********************************************************************
  10 *   Legacy version of RuleBasedBreakIterator from ICU 57,
  11 *   only for use by Apple RuleBasedTokenizer
  12 **********************************************************************
  13 */
  14
  15 #ifndef RBBI57_H
  16 #define RBBI57_H
  17
  18 #include "unicode/utypes.h"
  19
  20 /**
  21  * \file
  22  * \brief C++ API: Rule Based Break Iterator
  23  */
  24
  25 #if !UCONFIG_NO_BREAK_ITERATION
  26
  27 #include "unicode/brkiter.h"
  28 #include "unicode/udata.h"
  29 #include "unicode/parseerr.h"
  30 #include "unicode/schriter.h"
  31 #include "unicode/uchriter.h"
  32 #include "rbbidata57.h"
  33 #include "rbbirb57.h"
  34
  35 struct UTrie;
  36
  37 U_NAMESPACE_BEGIN
  38
  39 /** @internal */
  40 struct RBBIDataHeader57;
  41 class  RuleBasedBreakIteratorTables;
  42 class  BreakIterator;
  43 class  RBBIDataWrapper57;
  44 class  UStack;
  45 class  LanguageBreakEngine;
  46 class  UnhandledEngine;
  47 struct RBBIStateTable;
  48
  49 /**
  50  *
  51  * A subclass of BreakIterator whose behavior is specified using a list of rules.
  52  *
  53  * <p>This class was not intended to be subclassed. The subclassing interface to
  54  * RulesBasedBreakIterator is not part of the ICU API, and may not remain stable.</p>
  55  *
  56  * <p>However, the ICU 57 version <em>was<em> subclassed for the Apple RuleBasedTokenizer.
  57  * So this legacy version of RuleBasedBreakIterator is preserved for that usage,
  58  * since versions of RuleBasedBreakIterator in ICU 58 and later broke that
  59  * subclassing (in ICU 58 it just by changing the access to certain internal fields,
  60  * but in ICU 60 RuleBasedBreakIterator was completely rewritten).</p>
  61  */
  62 class U_COMMON_API RuleBasedBreakIterator57 /*U_FINAL*/ : public BreakIterator {
  63
  64 protected:
  65     /**
  66      * The UText through which this BreakIterator accesses the text
  67      * @internal
  68      */
  69     UText  *fText;
  70
  71     /**
  72      *   A character iterator that refers to the same text as the UText, above.
  73      *   Only included for compatibility with old API, which was based on CharacterIterators.
  74      *   Value may be adopted from outside, or one of fSCharIter or fDCharIter, below.
  75      */
  76     CharacterIterator  *fCharIter;
  77
  78     /**
  79      *   When the input text is provided by a UnicodeString, this will point to
  80      *    a characterIterator that wraps that data.  Needed only for the
  81      *    implementation of getText(), a backwards compatibility issue.
  82      */
  83     StringCharacterIterator *fSCharIter;
  84
  85     /**
  86      *  When the input text is provided by a UText, this
  87      *    dummy CharacterIterator over an empty string will
  88      *    be returned from getText()
  89      */
  90     UCharCharacterIterator *fDCharIter;
  91
  92     /**
  93      * The rule data for this BreakIterator instance
  94      * @internal
  95      */
  96     RBBIDataWrapper57    *fData;
  97
  98     /** Index of the Rule {tag} values for the most recent match.
  99      *  @internal
 100     */
 101     int32_t             fLastRuleStatusIndex;
 102
 103     /**
 104      * Rule tag value valid flag.
 105      * Some iterator operations don't intrinsically set the correct tag value.
 106      * This flag lets us lazily compute the value if we are ever asked for it.
 107      * @internal
 108      */
 109     UBool               fLastStatusIndexValid;
 110
 111     /**
 112      * Counter for the number of characters encountered with the "dictionary"
 113      *   flag set.
 114      * @internal
 115      */
 116     uint32_t            fDictionaryCharCount;
 117
 118     /**
 119      * When a range of characters is divided up using the dictionary, the break
 120      * positions that are discovered are stored here, preventing us from having
 121      * to use either the dictionary or the state table again until the iterator
 122      * leaves this range of text. Has the most impact for line breaking.
 123      * @internal
 124      */
 125     int32_t*            fCachedBreakPositions;
 126
 127     /**
 128      * The number of elements in fCachedBreakPositions
 129      * @internal
 130      */
 131     int32_t             fNumCachedBreakPositions;
 132
 133     /**
 134      * if fCachedBreakPositions is not null, this indicates which item in the
 135      * cache the current iteration position refers to
 136      * @internal
 137      */
 138     int32_t             fPositionInCache;
 139
 140     /**
 141      *
 142      * If present, UStack of LanguageBreakEngine objects that might handle
 143      * dictionary characters. Searched from top to bottom to find an object to
 144      * handle a given character.
 145      * @internal
 146      */
 147     UStack              *fLanguageBreakEngines;
 148
 149     /**
 150      *
 151      * If present, the special LanguageBreakEngine used for handling
 152      * characters that are in the dictionary set, but not handled by any
 153      * LangugageBreakEngine.
 154      * @internal
 155      */
 156     UnhandledEngine     *fUnhandledBreakEngine;
 157
 158     /**
 159      *
 160      * The type of the break iterator, or -1 if it has not been set.
 161      * @internal
 162      */
 163     int32_t             fBreakType;
 164
 165     //=======================================================================
 166     // constructors
 167     //=======================================================================
 168
 169     /**
 170      * Constant to be used in the constructor
 171      * RuleBasedBreakIterator57(RBBIDataHeader57*, EDontAdopt, UErrorCode &);
 172      * which does not adopt the memory indicated by the RBBIDataHeader57*
 173      * parameter.
 174      *
 175      * @internal, used by rbtok.cpp, urbtok57.cpp
 176      */
 177     enum EDontAdopt {
 178         kDontAdopt
 179     };
 180
 181     /**
 182      * Constructor from a flattened set of RBBI data in malloced memory.
 183      *             RulesBasedBreakIterators built from a custom set of rules
 184      *             are created via this constructor; the rules are compiled
 185      *             into memory, then the break iterator is constructed here.
 186      *
 187      *             The break iterator adopts the memory, and will
 188      *             free it when done.
 189      * @internal, used by rbtok.cpp
 190      */
 191     RuleBasedBreakIterator57(RBBIDataHeader57* data, UErrorCode &status);
 192
 193     /**
 194      * Constructor from a flattened set of RBBI data in memory which need not
 195      *             be malloced (e.g. it may be a memory-mapped file, etc.).
 196      *
 197      *             This version does not adopt the memory, and does not
 198      *             free it when done.
 199      * @internal, used by rbtok.cpp
 200      */
 201     RuleBasedBreakIterator57(const RBBIDataHeader57* data, enum EDontAdopt dontAdopt, UErrorCode &status);
 202
 203
 204     friend class RBBIRuleBuilder57;
 205     /** @internal */
 206     friend class BreakIterator;
 207
 208 public:
 209
 210     /** Default constructor.  Creates an empty shell of an iterator, with no
 211      *  rules or text to iterate over.   Object can subsequently be assigned to.
 212      *  @internal
 213      */
 214     RuleBasedBreakIterator57();
 215
 216     /**
 217      * Copy constructor.  Will produce a break iterator with the same behavior,
 218      * and which iterates over the same text, as the one passed in.
 219      * @param that The RuleBasedBreakIterator57 passed to be copied
 220      * @internal
 221      */
 222     RuleBasedBreakIterator57(const RuleBasedBreakIterator57& that);
 223
 224     /**
 225      * Construct a RuleBasedBreakIterator57 from a set of rules supplied as a string.
 226      * @param rules The break rules to be used.
 227      * @param parseError  In the event of a syntax error in the rules, provides the location
 228      *                    within the rules of the problem.
 229      * @param status Information on any errors encountered.
 230      * @internal, used by rbtok.cpp
 231      */
 232     RuleBasedBreakIterator57( const UnicodeString    &rules,
 233                              UParseError           &parseError,
 234                              UErrorCode            &status);
 235
 236 #if 0
 237 // not used by rbtok.cpp
 238     /**
 239      * Contruct a RuleBasedBreakIterator57 from a set of precompiled binary rules.
 240      * Binary rules are obtained from RulesBasedBreakIterator::getBinaryRules().
 241      * Construction of a break iterator in this way is substantially faster than
 242      * constuction from source rules.
 243      *
 244      * Ownership of the storage containing the compiled rules remains with the
 245      * caller of this function.  The compiled rules must not be  modified or
 246      * deleted during the life of the break iterator.
 247      *
 248      * The compiled rules are not compatible across different major versions of ICU.
 249      * The compiled rules are comaptible only between machines with the same
 250      * byte ordering (little or big endian) and the same base character set family
 251      * (ASCII or EBCDIC).
 252      *
 253      * @see #getBinaryRules
 254      * @param compiledRules A pointer to the compiled break rules to be used.
 255      * @param ruleLength The length of the compiled break rules, in bytes.  This
 256      *   corresponds to the length value produced by getBinaryRules().
 257      * @param status Information on any errors encountered, including invalid
 258      *   binary rules.
 259      * @internal
 260      */
 261     RuleBasedBreakIterator57(const uint8_t *compiledRules,
 262                            uint32_t       ruleLength,
 263                            UErrorCode    &status);
 264
 265     /**
 266      * This constructor uses the udata interface to create a BreakIterator
 267      * whose internal tables live in a memory-mapped file.  "image" is an
 268      * ICU UDataMemory handle for the pre-compiled break iterator tables.
 269      * @param image handle to the memory image for the break iterator data.
 270      *        Ownership of the UDataMemory handle passes to the Break Iterator,
 271      *        which will be responsible for closing it when it is no longer needed.
 272      * @param status Information on any errors encountered.
 273      * @see udata_open
 274      * @see #getBinaryRules
 275      * @internal
 276      */
 277     RuleBasedBreakIterator57(UDataMemory* image, UErrorCode &status);
 278 #endif
 279
 280     /**
 281      * Destructor
 282      *  @internal
 283      */
 284     virtual ~RuleBasedBreakIterator57();
 285
 286     /**
 287      * Assignment operator.  Sets this iterator to have the same behavior,
 288      * and iterate over the same text, as the one passed in.
 289      * @param that The RuleBasedBreakItertor passed in
 290      * @return the newly created RuleBasedBreakIterator57
 291      *  @internal
 292      */
 293     RuleBasedBreakIterator57& operator=(const RuleBasedBreakIterator57& that);
 294
 295     /**
 296      * Equality operator.  Returns TRUE if both BreakIterators are of the
 297      * same class, have the same behavior, and iterate over the same text.
 298      * @param that The BreakIterator to be compared for equality
 299      * @return TRUE if both BreakIterators are of the
 300      * same class, have the same behavior, and iterate over the same text.
 301      *  @internal
 302      */
 303     virtual UBool operator==(const BreakIterator& that) const;
 304
 305     /**
 306      * Not-equal operator.  If operator== returns TRUE, this returns FALSE,
 307      * and vice versa.
 308      * @param that The BreakIterator to be compared for inequality
 309      * @return TRUE if both BreakIterators are not same.
 310      *  @internal
 311      */
 312     UBool operator!=(const BreakIterator& that) const;
 313
 314     /**
 315      * Returns a newly-constructed RuleBasedBreakIterator57 with the same
 316      * behavior, and iterating over the same text, as this one.
 317      * Differs from the copy constructor in that it is polymorphic, and
 318      * will correctly clone (copy) a derived class.
 319      * clone() is thread safe.  Multiple threads may simultaeneously
 320      * clone the same source break iterator.
 321      * @return a newly-constructed RuleBasedBreakIterator57
 322      * @internal
 323      */
 324     virtual BreakIterator* clone() const;
 325
 326     /**
 327      * Compute a hash code for this BreakIterator
 328      * @return A hash code
 329      *  @internal
 330      */
 331     virtual int32_t hashCode(void) const;
 332
 333 #if 0
 334 // not used by rbtok.cpp
 335     /**
 336      * Returns the description used to create this iterator
 337      * @return the description used to create this iterator
 338      *  @internal
 339      */
 340     virtual const UnicodeString& getRules(void) const;
 341 #endif
 342     //=======================================================================
 343     // BreakIterator overrides
 344     //=======================================================================
 345
 346     /**
 347      * <p>
 348      * Return a CharacterIterator over the text being analyzed.
 349      * The returned character iterator is owned by the break iterator, and must
 350      * not be deleted by the caller.  Repeated calls to this function may
 351      * return the same CharacterIterator.
 352      * </p>
 353      * <p>
 354      * The returned character iterator must not be used concurrently with
 355      * the break iterator.  If concurrent operation is needed, clone the
 356      * returned character iterator first and operate on the clone.
 357      * </p>
 358      * <p>
 359      * When the break iterator is operating on text supplied via a UText,
 360      * this function will fail.  Lacking any way to signal failures, it
 361      * returns an CharacterIterator containing no text.
 362      * The function getUText() provides similar functionality,
 363      * is reliable, and is more efficient.
 364      * </p>
 365      *
 366      * TODO:  deprecate this function?
 367      *
 368      * @return An iterator over the text being analyzed.
 369      * @internal, inherited from BreakIterator
 370      */
 371     virtual  CharacterIterator& getText(void) const;
 372
 373
 374     /**
 375       *  Get a UText for the text being analyzed.
 376       *  The returned UText is a shallow clone of the UText used internally
 377       *  by the break iterator implementation.  It can safely be used to
 378       *  access the text without impacting any break iterator operations,
 379       *  but the underlying text itself must not be altered.
 380       *
 381       * @param fillIn A UText to be filled in.  If NULL, a new UText will be
 382       *           allocated to hold the result.
 383       * @param status receives any error codes.
 384       * @return   The current UText for this break iterator.  If an input
 385       *           UText was provided, it will always be returned.
 386       * @internal, inherited from BreakIterator
 387       */
 388      virtual UText *getUText(UText *fillIn, UErrorCode &status) const;
 389
 390     /**
 391      * Set the iterator to analyze a new piece of text.  This function resets
 392      * the current iteration position to the beginning of the text.
 393      * @param newText An iterator over the text to analyze.  The BreakIterator
 394      * takes ownership of the character iterator.  The caller MUST NOT delete it!
 395      *  @internal, inherited from BreakIterator
 396      */
 397     virtual void adoptText(CharacterIterator* newText);
 398
 399     /**
 400      * Set the iterator to analyze a new piece of text.  This function resets
 401      * the current iteration position to the beginning of the text.
 402      *
 403      * The BreakIterator will retain a reference to the supplied string.
 404      * The caller must not modify or delete the text while the BreakIterator
 405      * retains the reference.
 406      *
 407      * @param newText The text to analyze.
 408      *  @internal, inherited from BreakIterator
 409      */
 410     virtual void setText(const UnicodeString& newText);
 411
 412     /**
 413      * Reset the break iterator to operate over the text represented by
 414      * the UText.  The iterator position is reset to the start.
 415      *
 416      * This function makes a shallow clone of the supplied UText.  This means
 417      * that the caller is free to immediately close or otherwise reuse the
 418      * Utext that was passed as a parameter, but that the underlying text itself
 419      * must not be altered while being referenced by the break iterator.
 420      *
 421      * @param text    The UText used to change the text.
 422      * @param status  Receives any error codes.
 423      * @internal, inherited from BreakIterator
 424      */
 425     virtual void  setText(UText *text, UErrorCode &status);
 426
 427     /**
 428      * Sets the current iteration position to the beginning of the text, position zero.
 429      * @return The offset of the beginning of the text, zero.
 430      *  @internal, inherited from BreakIterator
 431      */
 432     virtual int32_t first(void);
 433
 434     /**
 435      * Sets the current iteration position to the end of the text.
 436      * @return The text's past-the-end offset.
 437      *  @internal, inherited from BreakIterator
 438      */
 439     virtual int32_t last(void);
 440
 441     /**
 442      * Advances the iterator either forward or backward the specified number of steps.
 443      * Negative values move backward, and positive values move forward.  This is
 444      * equivalent to repeatedly calling next() or previous().
 445      * @param n The number of steps to move.  The sign indicates the direction
 446      * (negative is backwards, and positive is forwards).
 447      * @return The character offset of the boundary position n boundaries away from
 448      * the current one.
 449      *  @internal, inherited from BreakIterator
 450      */
 451     virtual int32_t next(int32_t n);
 452
 453     /**
 454      * Advances the iterator to the next boundary position.
 455      * @return The position of the first boundary after this one.
 456      *  @internal, inherited from BreakIterator
 457      */
 458     virtual int32_t next(void);
 459
 460     /**
 461      * Moves the iterator backwards, to the last boundary preceding this one.
 462      * @return The position of the last boundary position preceding this one.
 463      *  @internal, inherited from BreakIterator
 464      */
 465     virtual int32_t previous(void);
 466
 467     /**
 468      * Sets the iterator to refer to the first boundary position following
 469      * the specified position.
 470      * @param offset The position from which to begin searching for a break position.
 471      * @return The position of the first break after the current position.
 472      *  @internal, inherited from BreakIterator
 473      */
 474     virtual int32_t following(int32_t offset);
 475
 476     /**
 477      * Sets the iterator to refer to the last boundary position before the
 478      * specified position.
 479      * @param offset The position to begin searching for a break from.
 480      * @return The position of the last boundary before the starting position.
 481      *  @internal, inherited from BreakIterator
 482      */
 483     virtual int32_t preceding(int32_t offset);
 484
 485     /**
 486      * Returns true if the specfied position is a boundary position.  As a side
 487      * effect, leaves the iterator pointing to the first boundary position at
 488      * or after "offset".
 489      * @param offset the offset to check.
 490      * @return True if "offset" is a boundary position.
 491      *  @internal, inherited from BreakIterator
 492      */
 493     virtual UBool isBoundary(int32_t offset);
 494
 495     /**
 496      * Returns the current iteration position.
 497      * @return The current iteration position.
 498      * @internal, inherited from BreakIterator
 499      */
 500     virtual int32_t current(void) const;
 501
 502
 503     /**
 504      * Return the status tag from the break rule that determined the most recently
 505      * returned break position.  For break rules that do not specify a
 506      * status, a default value of 0 is returned.  If more than one break rule
 507      * would cause a boundary to be located at some position in the text,
 508      * the numerically largest of the applicable status values is returned.
 509      * <p>
 510      * Of the standard types of ICU break iterators, only word break and
 511      * line break provide status values.  The values are defined in
 512      * the header file ubrk.h.  For Word breaks, the status allows distinguishing between words
 513      * that contain alphabetic letters, "words" that appear to be numbers,
 514      * punctuation and spaces, words containing ideographic characters, and
 515      * more.  For Line Break, the status distinguishes between hard (mandatory) breaks
 516      * and soft (potential) break positions.
 517      * <p>
 518      * <code>getRuleStatus()</code> can be called after obtaining a boundary
 519      * position from <code>next()</code>, <code>previous()</code>, or
 520      * any other break iterator functions that returns a boundary position.
 521      * <p>
 522      * When creating custom break rules, one is free to define whatever
 523      * status values may be convenient for the application.
 524      * <p>
 525      * Note: this function is not thread safe.  It should not have been
 526      *       declared const, and the const remains only for compatibility
 527      *       reasons.  (The function is logically const, but not bit-wise const).
 528      * <p>
 529      * @return the status from the break rule that determined the most recently
 530      * returned break position.
 531      *
 532      * @see UWordBreak
 533      * @internal, inherited from BreakIterator
 534      */
 535     virtual int32_t getRuleStatus() const;
 536
 537    /**
 538     * Get the status (tag) values from the break rule(s) that determined the most
 539     * recently returned break position.
 540     * <p>
 541     * The returned status value(s) are stored into an array provided by the caller.
 542     * The values are stored in sorted (ascending) order.
 543     * If the capacity of the output array is insufficient to hold the data,
 544     *  the output will be truncated to the available length, and a
 545     *  U_BUFFER_OVERFLOW_ERROR will be signaled.
 546     *
 547     * @param fillInVec an array to be filled in with the status values.
 548     * @param capacity  the length of the supplied vector.  A length of zero causes
 549     *                  the function to return the number of status values, in the
 550     *                  normal way, without attemtping to store any values.
 551     * @param status    receives error codes.
 552     * @return          The number of rule status values from rules that determined
 553     *                  the most recent boundary returned by the break iterator.
 554     *                  In the event of a U_BUFFER_OVERFLOW_ERROR, the return value
 555     *                  is the total number of status values that were available,
 556     *                  not the reduced number that were actually returned.
 557     * @see getRuleStatus
 558     * @internal, inherited from BreakIterator
 559     */
 560     virtual int32_t getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status);
 561
 562     /**
 563      * Returns a unique class ID POLYMORPHICALLY.  Pure virtual override.
 564      * This method is to implement a simple version of RTTI, since not all
 565      * C++ compilers support genuine RTTI.  Polymorphic operator==() and
 566      * clone() methods call this method.
 567      *
 568      * @return          The class ID for this object. All objects of a
 569      *                  given class have the same class ID.  Objects of
 570      *                  other classes have different class IDs.
 571      * @internal
 572      */
 573     virtual UClassID getDynamicClassID(void) const;
 574
 575     /**
 576      * Returns the class ID for this class.  This is useful only for
 577      * comparing to a return value from getDynamicClassID().  For example:
 578      *
 579      *      Base* polymorphic_pointer = createPolymorphicObject();
 580      *      if (polymorphic_pointer->getDynamicClassID() ==
 581      *          Derived::getStaticClassID()) ...
 582      *
 583      * @return          The class ID for all objects of this class.
 584      * @internal
 585      */
 586     static UClassID U_EXPORT2 getStaticClassID(void);
 587
 588     /**
 589      * Deprecated functionality. Use clone() instead.
 590      *
 591      * Create a clone (copy) of this break iterator in memory provided
 592      *  by the caller.  The idea is to increase performance by avoiding
 593      *  a storage allocation.  Use of this functoin is NOT RECOMMENDED.
 594      *  Performance gains are minimal, and correct buffer management is
 595      *  tricky.  Use clone() instead.
 596      *
 597      * @param stackBuffer  The pointer to the memory into which the cloned object
 598      *                     should be placed.  If NULL,  allocate heap memory
 599      *                     for the cloned object.
 600      * @param BufferSize   The size of the buffer.  If zero, return the required
 601      *                     buffer size, but do not clone the object.  If the
 602      *                     size was too small (but not zero), allocate heap
 603      *                     storage for the cloned object.
 604      *
 605      * @param status       Error status.  U_SAFECLONE_ALLOCATED_WARNING will be
 606      *                     returned if the the provided buffer was too small, and
 607      *                     the clone was therefore put on the heap.
 608      *
 609      * @return  Pointer to the clone object.  This may differ from the stackBuffer
 610      *          address if the byte alignment of the stack buffer was not suitable
 611      *          or if the stackBuffer was too small to hold the clone.
 612      * @deprecated ICU 52. Use clone() instead.
 613      */
 614     virtual BreakIterator *  createBufferClone(void *stackBuffer,
 615                                                int32_t &BufferSize,
 616                                                UErrorCode &status);
 617
 618
 619     /**
 620      * Return the binary form of compiled break rules,
 621      * which can then be used to create a new break iterator at some
 622      * time in the future.  Creating a break iterator from pre-compiled rules
 623      * is much faster than building one from the source form of the
 624      * break rules.
 625      *
 626      * The binary data can only be used with the same version of ICU
 627      *  and on the same platform type (processor endian-ness)
 628      *
 629      * @param length Returns the length of the binary data.  (Out paramter.)
 630      *
 631      * @return   A pointer to the binary (compiled) rule data.  The storage
 632      *           belongs to the RulesBasedBreakIterator object, not the
 633      *           caller, and must not be modified or deleted.
 634      * @internal, used by urbtok57.cpp
 635      */
 636     virtual const uint8_t *getBinaryRules(uint32_t &length);
 637
 638     /**
 639      *  Set the subject text string upon which the break iterator is operating
 640      *  without changing any other aspect of the matching state.
 641      *  The new and previous text strings must have the same content.
 642      *
 643      *  This function is intended for use in environments where ICU is operating on
 644      *  strings that may move around in memory.  It provides a mechanism for notifying
 645      *  ICU that the string has been relocated, and providing a new UText to access the
 646      *  string in its new position.
 647      *
 648      *  Note that the break iterator implementation never copies the underlying text
 649      *  of a string being processed, but always operates directly on the original text
 650      *  provided by the user. Refreshing simply drops the references to the old text
 651      *  and replaces them with references to the new.
 652      *
 653      *  Caution:  this function is normally used only by very specialized,
 654      *  system-level code.  One example use case is with garbage collection that moves
 655      *  the text in memory.
 656      *
 657      * @param input      The new (moved) text string.
 658      * @param status     Receives errors detected by this function.
 659      * @return           *this
 660      *
 661      * @internal, inherited from BreakIterator
 662      */
 663     virtual RuleBasedBreakIterator57 &refreshInputText(UText *input, UErrorCode &status);
 664
 665
 666 protected:
 667     //=======================================================================
 668     // implementation
 669     //=======================================================================
 670     /**
 671      * Dumps caches and performs other actions associated with a complete change
 672      * in text or iteration position.
 673      * @internal
 674      */
 675     virtual void reset(void);
 676
 677     /**
 678       * Set the type of the break iterator.
 679       * @internal
 680       */
 681     virtual void setBreakType(int32_t type);
 682
 683     /**
 684       * Common initialization function, used by constructors and bufferClone.
 685       * @internal
 686       */
 687     void init();
 688
 689 private:
 690
 691     /**
 692      * This method backs the iterator back up to a "safe position" in the text.
 693      * This is a position that we know, without any context, must be a break position.
 694      * The various calling methods then iterate forward from this safe position to
 695      * the appropriate position to return.  (For more information, see the description
 696      * of buildBackwardsStateTable() in RuleBasedBreakIterator57.Builder.)
 697      * @param statetable state table used of moving backwards
 698      * @internal
 699      */
 700     int32_t handlePrevious(const RBBIStateTable *statetable);
 701
 702     /**
 703      * This method is the actual implementation of the next() method.  All iteration
 704      * vectors through here.  This method initializes the state machine to state 1
 705      * and advances through the text character by character until we reach the end
 706      * of the text or the state machine transitions to state 0.  We update our return
 707      * value every time the state machine passes through a possible end state.
 708      * @param statetable state table used of moving forwards
 709      * @internal
 710      */
 711     int32_t handleNext(const RBBIStateTable *statetable);
 712
 713 protected:
 714
 715     /**
 716      * This is the function that actually implements dictionary-based
 717      * breaking.  Covering at least the range from startPos to endPos,
 718      * it checks for dictionary characters, and if it finds them determines
 719      * the appropriate object to deal with them. It may cache found breaks in
 720      * fCachedBreakPositions as it goes. It may well also look at text outside
 721      * the range startPos to endPos.
 722      * If going forward, endPos is the normal Unicode break result, and
 723      * if goind in reverse, startPos is the normal Unicode break result
 724      * @param startPos  The start position of a range of text
 725      * @param endPos    The end position of a range of text
 726      * @param reverse   The call is for the reverse direction
 727      * @internal
 728      */
 729     int32_t checkDictionary(int32_t startPos, int32_t endPos, UBool reverse);
 730
 731 private:
 732
 733     /**
 734      * This function returns the appropriate LanguageBreakEngine for a
 735      * given character c.
 736      * @param c         A character in the dictionary set
 737      * @internal
 738      */
 739     const LanguageBreakEngine *getLanguageBreakEngine(UChar32 c);
 740
 741     /**
 742      *  @internal
 743      */
 744     void makeRuleStatusValid();
 745
 746 };
 747
 748 //------------------------------------------------------------------------------
 749 //
 750 //   Inline Functions Definitions ...
 751 //
 752 //------------------------------------------------------------------------------
 753
 754 inline UBool RuleBasedBreakIterator57::operator!=(const BreakIterator& that) const {
 755     return !operator==(that);
 756 }
 757
 758 U_NAMESPACE_END
 759
 760 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */
 761
 762 #endif