rbbi.h

Go to the documentation of this file.

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
***************************************************************************
*   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
 
#if !UCONFIG_NO_BREAK_ITERATION
 
#include "unicode/brkiter.h"
#include "unicode/udata.h"
#include "unicode/parseerr.h"
#include "unicode/schriter.h"
 
struct UCPTrie;
 
U_NAMESPACE_BEGIN
 
class  LanguageBreakEngine;
struct RBBIDataHeader;
class  RBBIDataWrapper;
class  UnhandledEngine;
class  UStack;
 
 
#ifndef U_HIDE_INTERNAL_API
class ExternalBreakEngine : public UObject {
  public:
    virtual ~ExternalBreakEngine() {}
 
    virtual bool isFor(UChar32 c, const char* locale) const = 0;
 
    virtual bool handles(UChar32 c) const = 0;
 
     virtual int32_t fillBreaks(UText* text,  int32_t start, int32_t end,
                               int32_t* foundBreaks, int32_t foundBreaksCapacity,
                               UErrorCode& status) const = 0;
};
#endif  /* U_HIDE_INTERNAL_API */
 
 
class U_COMMON_API RuleBasedBreakIterator /*final*/ : public BreakIterator {
 
private:
    UText  fText = UTEXT_INITIALIZER;
 
#ifndef U_HIDE_INTERNAL_API
public:
#endif /* U_HIDE_INTERNAL_API */
    RBBIDataWrapper    *fData = nullptr;
 
private:
    UErrorCode      fErrorCode = U_ZERO_ERROR;
 
    int32_t         fPosition = 0;
 
    int32_t         fRuleStatusIndex = 0;
 
    class BreakCache;
    BreakCache         *fBreakCache = nullptr;
 
    class DictionaryCache;
    DictionaryCache *fDictionaryCache = nullptr;
 
    UStack              *fLanguageBreakEngines = nullptr;
 
    UnhandledEngine     *fUnhandledBreakEngine = nullptr;
 
    uint32_t            fDictionaryCharCount = 0;
 
    CharacterIterator  *fCharIter = &fSCharIter;
 
    UCharCharacterIterator fSCharIter {u"", 0};
 
    bool           fDone = false;
 
    int32_t *fLookAheadMatches = nullptr;
 
    UBool fIsPhraseBreaking = false;
 
    //=======================================================================
    // constructors
    //=======================================================================
 
    RuleBasedBreakIterator(RBBIDataHeader* data, UErrorCode &status);
 
    RuleBasedBreakIterator(UDataMemory* image, UBool isPhraseBreaking, UErrorCode &status);
 
    friend class RBBIRuleBuilder;
    friend class BreakIterator;
 
    RuleBasedBreakIterator(UErrorCode *status);
 
public:
 
    RuleBasedBreakIterator();
 
    RuleBasedBreakIterator(const RuleBasedBreakIterator& that);
 
    RuleBasedBreakIterator( const UnicodeString    &rules,
                             UParseError           &parseError,
                             UErrorCode            &status);
 
    RuleBasedBreakIterator(const uint8_t *compiledRules,
                           uint32_t       ruleLength,
                           UErrorCode    &status);
 
    RuleBasedBreakIterator(UDataMemory* image, UErrorCode &status);
 
    virtual ~RuleBasedBreakIterator();
 
    RuleBasedBreakIterator& operator=(const RuleBasedBreakIterator& that) U_LIFETIME_BOUND;
 
    virtual bool operator==(const BreakIterator& that) const override;
 
    inline bool operator!=(const BreakIterator& that) const {
        return !operator==(that);
    }
 
    virtual RuleBasedBreakIterator* clone() const override;
 
    virtual int32_t hashCode() const;
 
    virtual const UnicodeString& getRules() const U_LIFETIME_BOUND;
 
    //=======================================================================
    // BreakIterator overrides
    //=======================================================================
 
    virtual CharacterIterator& getText() const U_LIFETIME_BOUND override;
 
    virtual UText* getUText(UText* fillIn U_LIFETIME_BOUND, UErrorCode& status) const override;
 
    virtual void adoptText(CharacterIterator* newText) override;
 
    virtual void setText(const UnicodeString& newText) override;
 
    virtual void  setText(UText *text, UErrorCode &status) override;
 
    virtual int32_t first() override;
 
    virtual int32_t last() override;
 
    virtual int32_t next(int32_t n) override;
 
    virtual int32_t next() override;
 
    virtual int32_t previous() override;
 
    virtual int32_t following(int32_t offset) override;
 
    virtual int32_t preceding(int32_t offset) override;
 
    virtual UBool isBoundary(int32_t offset) override;
 
    virtual int32_t current() const override;
 
    virtual int32_t getRuleStatus() const override;
 
    virtual int32_t getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status) override;
 
    virtual UClassID getDynamicClassID() const override;
 
    static UClassID U_EXPORT2 getStaticClassID();
 
#ifndef U_FORCE_HIDE_DEPRECATED_API
    virtual RuleBasedBreakIterator *createBufferClone(void *stackBuffer,
                                                      int32_t &BufferSize,
                                                      UErrorCode &status) override;
#endif  // U_FORCE_HIDE_DEPRECATED_API
 
    virtual const uint8_t* getBinaryRules(uint32_t& length) U_LIFETIME_BOUND;
 
    virtual RuleBasedBreakIterator& refreshInputText(UText* input,
                                                     UErrorCode& status) U_LIFETIME_BOUND override;
 
 
private:
    //=======================================================================
    // implementation
    //=======================================================================
 
#ifndef U_HIDE_INTERNAL_API
public:
#endif /* U_HIDE_INTERNAL_API */
    int32_t handleSafePrevious(int32_t fromPosition);
 
private:
    int32_t handleNext();
 
    /*
     * Templatized version of handleNext() and handleSafePrevious().
     *
     * There will be exactly four instantiations, two each for 8 and 16 bit tables,
     * 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 parameter for the Trie access function is a value, 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 same type
     * 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();
 
 
    const LanguageBreakEngine* getLanguageBreakEngine(UChar32 c,
                                                      const char* locale) U_LIFETIME_BOUND;
 
  public:
#ifndef U_HIDE_INTERNAL_API
     void dumpCache();
 
    void dumpTables();
#endif  /* U_HIDE_INTERNAL_API */
 
#ifndef U_HIDE_INTERNAL_API
    static void U_EXPORT2 registerExternalBreakEngine(
                  ExternalBreakEngine* toAdopt, UErrorCode& status);
#endif  /* U_HIDE_INTERNAL_API */
 
};
 
 
U_NAMESPACE_END
 
#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif