icuSources/common/dictbe.h

   1 /**
   2  *******************************************************************************
   3  * Copyright (C) 2006, International Business Machines Corporation and others. *
   4  * All Rights Reserved.                                                        *
   5  *******************************************************************************
   6  */
   7
   8 #ifndef DICTBE_H
   9 #define DICTBE_H
  10
  11 #include "unicode/utypes.h"
  12 #include "unicode/uniset.h"
  13 #include "unicode/utext.h"
  14
  15 #include "brkeng.h"
  16
  17 U_NAMESPACE_BEGIN
  18
  19 class TrieWordDictionary;
  20
  21 /*******************************************************************
  22  * DictionaryBreakEngine
  23  */
  24
  25 /**
  26  * <p>DictionaryBreakEngine is a kind of LanguageBreakEngine that uses a
  27  * dictionary to determine language-specific breaks.</p>
  28  *
  29  * <p>After it is constructed a DictionaryBreakEngine may be shared between
  30  * threads without synchronization.</p>
  31  */
  32 class DictionaryBreakEngine : public LanguageBreakEngine {
  33  private:
  34     /**
  35      * The set of characters handled by this engine
  36      * @internal
  37      */
  38
  39   UnicodeSet    fSet;
  40
  41     /**
  42      * The set of break types handled by this engine
  43      * @internal
  44      */
  45
  46   uint32_t      fTypes;
  47
  48   /**
  49    * <p>Default constructor.</p>
  50    *
  51    */
  52   DictionaryBreakEngine();
  53
  54  public:
  55
  56   /**
  57    * <p>Constructor setting the break types handled.</p>
  58    *
  59    * @param breakTypes A bitmap of types handled by the engine.
  60    */
  61   DictionaryBreakEngine( uint32_t breakTypes );
  62
  63   /**
  64    * <p>Virtual destructor.</p>
  65    */
  66   virtual ~DictionaryBreakEngine();
  67
  68  /**
  69   * <p>Indicate whether this engine handles a particular character for
  70   * a particular kind of break.</p>
  71   *
  72   * @param c A character which begins a run that the engine might handle
  73   * @param breakType The type of text break which the caller wants to determine
  74   * @return TRUE if this engine handles the particular character and break
  75   * type.
  76   */
  77   virtual UBool handles( UChar32 c, int32_t breakType ) const;
  78
  79  /**
  80   * <p>Find any breaks within a run in the supplied text.</p>
  81   *
  82   * @param text A UText representing the text. The
  83   * iterator is left at the end of the run of characters which the engine
  84   * is capable of handling.
  85   * @param startPos The start of the run within the supplied text.
  86   * @param endPos The end of the run within the supplied text.
  87   * @param reverse Whether the caller is looking for breaks in a reverse
  88   * direction.
  89   * @param breakType The type of break desired, or -1.
  90   * @param foundBreaks An allocated C array of the breaks found, if any
  91   * @return The number of breaks found.
  92   */
  93   virtual int32_t findBreaks( UText *text,
  94                               int32_t startPos,
  95                               int32_t endPos,
  96                               UBool reverse,
  97                               int32_t breakType,
  98                               UStack &foundBreaks ) const;
  99
 100  protected:
 101
 102  /**
 103   * <p>Set the character set handled by this engine.</p>
 104   *
 105   * @param set A UnicodeSet of the set of characters handled by the engine
 106   */
 107   virtual void setCharacters( const UnicodeSet &set );
 108
 109  /**
 110   * <p>Set the break types handled by this engine.</p>
 111   *
 112   * @param breakTypes A bitmap of types handled by the engine.
 113   */
 114 //  virtual void setBreakTypes( uint32_t breakTypes );
 115
 116  /**
 117   * <p>Divide up a range of known dictionary characters.</p>
 118   *
 119   * @param text A UText representing the text
 120   * @param rangeStart The start of the range of dictionary characters
 121   * @param rangeEnd The end of the range of dictionary characters
 122   * @param foundBreaks Output of C array of int32_t break positions, or 0
 123   * @return The number of breaks found
 124   */
 125   virtual int32_t divideUpDictionaryRange( UText *text,
 126                                            int32_t rangeStart,
 127                                            int32_t rangeEnd,
 128                                            UStack &foundBreaks ) const = 0;
 129
 130 };
 131
 132 /*******************************************************************
 133  * ThaiBreakEngine
 134  */
 135
 136 /**
 137  * <p>ThaiBreakEngine is a kind of DictionaryBreakEngine that uses a
 138  * TrieWordDictionary and heuristics to determine Thai-specific breaks.</p>
 139  *
 140  * <p>After it is constructed a ThaiBreakEngine may be shared between
 141  * threads without synchronization.</p>
 142  */
 143 class ThaiBreakEngine : public DictionaryBreakEngine {
 144  private:
 145     /**
 146      * The set of characters handled by this engine
 147      * @internal
 148      */
 149
 150   UnicodeSet                fThaiWordSet;
 151   UnicodeSet                fEndWordSet;
 152   UnicodeSet                fBeginWordSet;
 153   UnicodeSet                fSuffixSet;
 154   UnicodeSet                fMarkSet;
 155   const TrieWordDictionary  *fDictionary;
 156
 157  public:
 158
 159   /**
 160    * <p>Default constructor.</p>
 161    *
 162    * @param adoptDictionary A TrieWordDictionary to adopt. Deleted when the
 163    * engine is deleted.
 164    */
 165   ThaiBreakEngine(const TrieWordDictionary *adoptDictionary, UErrorCode &status);
 166
 167   /**
 168    * <p>Virtual destructor.</p>
 169    */
 170   virtual ~ThaiBreakEngine();
 171
 172  protected:
 173  /**
 174   * <p>Divide up a range of known dictionary characters.</p>
 175   *
 176   * @param text A UText representing the text
 177   * @param rangeStart The start of the range of dictionary characters
 178   * @param rangeEnd The end of the range of dictionary characters
 179   * @param foundBreaks Output of C array of int32_t break positions, or 0
 180   * @return The number of breaks found
 181   */
 182   virtual int32_t divideUpDictionaryRange( UText *text,
 183                                            int32_t rangeStart,
 184                                            int32_t rangeEnd,
 185                                            UStack &foundBreaks ) const;
 186
 187 };
 188
 189
 190 U_NAMESPACE_END
 191
 192     /* DICTBE_H */
 193 #endif