← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/i18n/rbt_set.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

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