icuSources/i18n/rbt_set.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-2007, International Business Machines Corporation
   6 * and others. All Rights Reserved.
   7 **********************************************************************
   8 *   Date        Name        Description
   9 *   11/17/99    aliu        Creation.
  10 **********************************************************************
  11 */
  12 #ifndef RBT_SET_H
  13 #define RBT_SET_H
  14
  15 #include "unicode/utypes.h"
  16
  17 #if !UCONFIG_NO_TRANSLITERATION
  18
  19 #include "unicode/uobject.h"
  20 #include "unicode/utrans.h"
  21 #include "uvector.h"
  22
  23 U_NAMESPACE_BEGIN
  24
  25 class Replaceable;
  26 class TransliterationRule;
  27 class TransliterationRuleData;
  28 class UnicodeFilter;
  29 class UnicodeString;
  30 class UnicodeSet;
  31
  32 /**
  33  * A set of rules for a <code>RuleBasedTransliterator</code>.
  34  * @author Alan Liu
  35  */
  36 class TransliterationRuleSet : public UMemory {
  37     /**
  38      * Vector of rules, in the order added.  This is used while the
  39      * rule set is getting built.  After that, freeze() reorders and
  40      * indexes the rules into rules[].  Any given rule is stored once
  41      * in ruleVector, and one or more times in rules[].  ruleVector
  42      * owns and deletes the rules.
  43      */
  44     UVector* ruleVector;
  45
  46     /**
  47      * Sorted and indexed table of rules.  This is created by freeze()
  48      * from the rules in ruleVector.  It contains alias pointers to
  49      * the rules in ruleVector.  It is zero before freeze() is called
  50      * and non-zero thereafter.
  51      */
  52     TransliterationRule** rules;
  53
  54     /**
  55      * Index table.  For text having a first character c, compute x = c&0xFF.
  56      * Now use rules[index[x]..index[x+1]-1].  This index table is created by
  57      * freeze().  Before freeze() is called it contains garbage.
  58      */
  59     int32_t index[257];
  60
  61     /**
  62      * Length of the longest preceding context
  63      */
  64     int32_t maxContextLength;
  65
  66 public:
  67
  68     /**
  69      * Construct a new empty rule set.
  70      * @param status    Output parameter filled in with success or failure status.
  71      */
  72     TransliterationRuleSet(UErrorCode& status);
  73
  74     /**
  75      * Copy constructor.
  76      */
  77     TransliterationRuleSet(const TransliterationRuleSet&);
  78
  79     /**
  80      * Destructor.
  81      */
  82     virtual ~TransliterationRuleSet();
  83
  84     /**
  85      * Change the data object that this rule belongs to.  Used
  86      * internally by the TransliterationRuleData copy constructor.
  87      * @param data    the new data value to be set.
  88      */
  89     void setData(const TransliterationRuleData* data);
  90
  91     /**
  92      * Return the maximum context length.
  93      * @return the length of the longest preceding context.
  94      */
  95     virtual int32_t getMaximumContextLength(void) const;
  96
  97     /**
  98      * Add a rule to this set.  Rules are added in order, and order is
  99      * significant.  The last call to this method must be followed by
 100      * a call to <code>freeze()</code> before the rule set is used.
 101      * This method must <em>not</em> be called after freeze() has been
 102      * called.
 103      *
 104      * @param adoptedRule the rule to add
 105      */
 106     virtual void addRule(TransliterationRule* adoptedRule,
 107                          UErrorCode& status);
 108
 109     /**
 110      * Check this for masked rules and index it to optimize performance.
 111      * The sequence of operations is: (1) add rules to a set using
 112      * <code>addRule()</code>; (2) freeze the set using
 113      * <code>freeze()</code>; (3) use the rule set.  If
 114      * <code>addRule()</code> is called after calling this method, it
 115      * invalidates this object, and this method must be called again.
 116      * That is, <code>freeze()</code> may be called multiple times,
 117      * although for optimal performance it shouldn't be.
 118      * @param parseError A pointer to UParseError to receive information about errors
 119      *                   occurred.
 120      * @param status     Output parameter filled in with success or failure status.
 121      */
 122     virtual void freeze(UParseError& parseError, UErrorCode& status);
 123
 124     /**
 125      * Transliterate the given text with the given UTransPosition
 126      * indices.  Return TRUE if the transliteration should continue
 127      * or FALSE if it should halt (because of a U_PARTIAL_MATCH match).
 128      * Note that FALSE is only ever returned if isIncremental is TRUE.
 129      * @param text the text to be transliterated
 130      * @param index the position indices, which will be updated
 131      * @param isIncremental if TRUE, assume new text may be inserted
 132      * at index.limit, and return FALSE if thre is a partial match.
 133      * @return TRUE unless a U_PARTIAL_MATCH has been obtained,
 134      * indicating that transliteration should stop until more text
 135      * arrives.
 136      */
 137     UBool transliterate(Replaceable& text,
 138                         UTransPosition& index,
 139                         UBool isIncremental);
 140
 141     /**
 142      * Create rule strings that represents this rule set.
 143      * @param result string to receive the rule strings.  Current
 144      * contents will be deleted.
 145      * @param escapeUnprintable  True, will escape the unprintable characters
 146      * @return    A reference to 'result'.
 147      */
 148     virtual UnicodeString& toRules(UnicodeString& result,
 149                                    UBool escapeUnprintable) const;
 150
 151     /**
 152      * Return the set of all characters that may be modified
 153      * (getTarget=false) or emitted (getTarget=true) by this set.
 154      */
 155     UnicodeSet& getSourceTargetSet(UnicodeSet& result,
 156                    UBool getTarget) const;
 157
 158 private:
 159
 160     TransliterationRuleSet &operator=(const TransliterationRuleSet &other); // forbid copying of this class
 161 };
 162
 163 U_NAMESPACE_END
 164
 165 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
 166
 167 #endif