LanguageBreakEngines implement language-specific knowledge for * finding text boundaries within a run of characters belonging to a * specific set. The boundaries will be of a specific kind, e.g. word, * line, etc.
* *LanguageBreakEngines should normally be implemented so as to * be shared between threads without locking.
*/ class LanguageBreakEngine : public UObject { public: /** *Default constructor.
* */ LanguageBreakEngine(); /** *Virtual destructor.
*/ virtual ~LanguageBreakEngine(); /** *Indicate whether this engine handles a particular character for * a particular kind of break.
* * @param c A character which begins a run that the engine might handle * @param locale The locale. * @return true if this engine handles the particular character and break * type. */ virtual UBool handles(UChar32 c, const char* locale) const = 0; /** *Find any breaks within a run in the supplied text.
* * @param text A UText representing the text. The * iterator is left at the end of the run of characters which the engine * is capable of handling. * @param startPos The start of the run within the supplied text. * @param endPos The end of the run within the supplied text. * @param foundBreaks A Vector of int32_t to receive the breaks. * @param status Information on any errors encountered. * @return The number of breaks found. */ virtual int32_t findBreaks( UText *text, int32_t startPos, int32_t endPos, UVector32 &foundBreaks, UBool isPhraseBreaking, UErrorCode &status) const = 0; }; /******************************************************************* * BreakEngineWrapper */ /** *BreakEngineWrapper implement LanguageBreakEngine by * a thin wrapper that delegate the task to ExternalBreakEngine *
*/ class BreakEngineWrapper : public LanguageBreakEngine { public: BreakEngineWrapper(ExternalBreakEngine* engine, UErrorCode &status); virtual ~BreakEngineWrapper(); virtual UBool handles(UChar32 c, const char* locale) const override; virtual int32_t findBreaks( UText *text, int32_t startPos, int32_t endPos, UVector32 &foundBreaks, UBool isPhraseBreaking, UErrorCode &status) const override; private: LocalPointerLanguageBreakFactorys find and return a LanguageBreakEngine * that can determine breaks for characters in a specific set, if * such an object can be found.
* *If a LanguageBreakFactory is to be shared between threads, * appropriate synchronization must be used; there is none internal * to the factory.
* *A LanguageBreakEngine returned by a LanguageBreakFactory can * normally be shared between threads without synchronization, unless * the specific subclass of LanguageBreakFactory indicates otherwise.
* *A LanguageBreakFactory is responsible for deleting any LanguageBreakEngine * it returns when it itself is deleted, unless the specific subclass of * LanguageBreakFactory indicates otherwise. Naturally, the factory should * not be deleted until the LanguageBreakEngines it has returned are no * longer needed.
*/ class LanguageBreakFactory : public UMemory { public: /** *Default constructor.
* */ LanguageBreakFactory(); /** *Virtual destructor.
*/ virtual ~LanguageBreakFactory(); /** *Find and return a LanguageBreakEngine that can find the desired * kind of break for the set of characters to which the supplied * character belongs. It is up to the set of available engines to * determine what the sets of characters are.
* * @param c A character that begins a run for which a LanguageBreakEngine is * sought. * @param locale The locale. * @return A LanguageBreakEngine with the desired characteristics, or 0. */ virtual const LanguageBreakEngine *getEngineFor(UChar32 c, const char* locale) = 0; }; /******************************************************************* * UnhandledEngine */ /** *UnhandledEngine is a special subclass of LanguageBreakEngine that * handles characters that no other LanguageBreakEngine is available to * handle. It is told the character and the type of break; at its * discretion it may handle more than the specified character (e.g., * the entire script to which that character belongs.
* *UnhandledEngines may not be shared between threads without * external synchronization.
*/ class UnhandledEngine : public LanguageBreakEngine { private: /** * The sets of characters handled. * @internal */ UnicodeSet *fHandled; public: /** *Default constructor.
* */ UnhandledEngine(UErrorCode &status); /** *Virtual destructor.
*/ virtual ~UnhandledEngine(); /** *Indicate whether this engine handles a particular character for * a particular kind of break.
* * @param c A character which begins a run that the engine might handle * @param locale The locale. * @return true if this engine handles the particular character and break * type. */ virtual UBool handles(UChar32 c, const char* locale) const override; /** *Find any breaks within a run in the supplied text.
* * @param text A UText representing the text (TODO: UText). The * iterator is left at the end of the run of characters which the engine * is capable of handling. * @param startPos The start of the run within the supplied text. * @param endPos The end of the run within the supplied text. * @param foundBreaks An allocated C array of the breaks found, if any * @param status Information on any errors encountered. * @return The number of breaks found. */ virtual int32_t findBreaks( UText *text, int32_t startPos, int32_t endPos, UVector32 &foundBreaks, UBool isPhraseBreaking, UErrorCode &status) const override; /** *Tell the engine to handle a particular character and break type.
* * @param c A character which the engine should handle */ virtual void handleCharacter(UChar32 c); }; /******************************************************************* * ICULanguageBreakFactory */ /** *ICULanguageBreakFactory is the default LanguageBreakFactory for * ICU. It creates dictionary-based LanguageBreakEngines from dictionary * data in the ICU data file.
*/ class ICULanguageBreakFactory : public LanguageBreakFactory { private: /** * The stack of break engines created by this factory * @internal */ UStack *fEngines; public: /** *Standard constructor.
* */ ICULanguageBreakFactory(UErrorCode &status); /** *Virtual destructor.
*/ virtual ~ICULanguageBreakFactory(); /** *Find and return a LanguageBreakEngine that can find the desired * kind of break for the set of characters to which the supplied * character belongs. It is up to the set of available engines to * determine what the sets of characters are.
* * @param c A character that begins a run for which a LanguageBreakEngine is * sought. * @param locale The locale. * @return A LanguageBreakEngine with the desired characteristics, or 0. */ virtual const LanguageBreakEngine *getEngineFor(UChar32 c, const char* locale) override; /** * Add and adopt the engine and return an URegistryKey. * @param engine The ExternalBreakEngine to be added and adopt. The caller * pass the ownership and should not release the memory after this. * @param status the error code. */ virtual void addExternalEngine(ExternalBreakEngine* engine, UErrorCode& status); protected: /** *Create a LanguageBreakEngine for the set of characters to which * the supplied character belongs, for the specified break type.
* * @param c A character that begins a run for which a LanguageBreakEngine is * sought. * @param locale The locale. * @return A LanguageBreakEngine with the desired characteristics, or 0. */ virtual const LanguageBreakEngine *loadEngineFor(UChar32 c, const char* locale); /** *Create a DictionaryMatcher for the specified script and break type.
* @param script An ISO 15924 script code that identifies the dictionary to be * created. * @return A DictionaryMatcher with the desired characteristics, or nullptr. */ virtual DictionaryMatcher *loadDictionaryMatcherFor(UScriptCode script); private: void ensureEngines(UErrorCode& status); }; U_NAMESPACE_END /* BRKENG_H */ #endif