1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
* Copyright (c) 2003-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
* Created: September 24 2003
* Since: ICU 2.8
**********************************************************************
*/
#ifndef _RULEITER_H_
#define _RULEITER_H_
#include "unicode/uobject.h"
U_NAMESPACE_BEGIN
class UnicodeString;
class ParsePosition;
class SymbolTable;
/**
* An iterator that returns 32-bit code points. This class is deliberately
* <em>not</em> related to any of the ICU character iterator classes
* in order to minimize complexity.
* @author Alan Liu
* @since ICU 2.8
*/
class RuleCharacterIterator : public UMemory {
// TODO: Ideas for later. (Do not implement if not needed, lest the
// code coverage numbers go down due to unused methods.)
// 1. Add a copy constructor, operator==() method.
// 2. Rather than return DONE, throw an exception if the end
// is reached -- this is an alternate usage model, probably not useful.
private:
/**
* Text being iterated.
*/
const UnicodeString& text;
/**
* Position of iterator.
*/
ParsePosition& pos;
/**
* Symbol table used to parse and dereference variables. May be 0.
*/
const SymbolTable* sym;
/**
* Current variable expansion, or 0 if none.
*/
const UnicodeString* buf;
/**
* Position within buf. Meaningless if buf == 0.
*/
int32_t bufPos;
public:
/**
* Value returned when there are no more characters to iterate.
*/
enum { DONE = -1 };
/**
* Bitmask option to enable parsing of variable names. If (options &
* PARSE_VARIABLES) != 0, then an embedded variable will be expanded to
* its value. Variables are parsed using the SymbolTable API.
*/
enum { PARSE_VARIABLES = 1 };
/**
* Bitmask option to enable parsing of escape sequences. If (options &
* PARSE_ESCAPES) != 0, then an embedded escape sequence will be expanded
* to its value. Escapes are parsed using Utility.unescapeAt().
*/
enum { PARSE_ESCAPES = 2 };
/**
* Bitmask option to enable skipping of whitespace. If (options &
* SKIP_WHITESPACE) != 0, then Pattern_White_Space characters will be silently
* skipped, as if they were not present in the input.
*/
enum { SKIP_WHITESPACE = 4 };
/**
* Constructs an iterator over the given text, starting at the given
* position.
* @param text the text to be iterated
* @param sym the symbol table, or null if there is none. If sym is null,
* then variables will not be dereferenced, even if the PARSE_VARIABLES
* option is set.
* @param pos upon input, the index of the next character to return. If a
* variable has been dereferenced, then pos will <em>not</em> increment as
* characters of the variable value are iterated.
*/
RuleCharacterIterator(const UnicodeString& text, const SymbolTable* sym,
ParsePosition& pos);
/**
* Returns true if this iterator has no more characters to return.
*/
UBool atEnd() const;
/**
* Returns the next character using the given options, or DONE if there
* are no more characters, and advance the position to the next
* character.
* @param options one or more of the following options, bitwise-OR-ed
* together: PARSE_VARIABLES, PARSE_ESCAPES, SKIP_WHITESPACE.
* @param isEscaped output parameter set to true if the character
* was escaped
* @param ec input-output error code. An error will only be set by
* this routing if options includes PARSE_VARIABLES and an unknown
* variable name is seen, or if options includes PARSE_ESCAPES and
* an invalid escape sequence is seen.
* @return the current 32-bit code point, or DONE
*/
UChar32 next(int32_t options, UBool& isEscaped, UErrorCode& ec);
/**
* Returns true if this iterator is currently within a variable expansion.
*/
inline UBool inVariable() const;
/**
* An opaque object representing the position of a RuleCharacterIterator.
*/
struct Pos : public UMemory {
private:
const UnicodeString* buf;
int32_t pos;
int32_t bufPos;
friend class RuleCharacterIterator;
};
/**
* Sets an object which, when later passed to setPos(), will
* restore this iterator's position. Usage idiom:
*
* RuleCharacterIterator iterator = ...;
* RuleCharacterIterator::Pos pos;
* iterator.getPos(pos);
* for (;;) {
* iterator.getPos(pos);
* int c = iterator.next(...);
* ...
* }
* iterator.setPos(pos);
*
* @param p a position object to be set to this iterator's
* current position.
*/
void getPos(Pos& p) const;
/**
* Restores this iterator to the position it had when getPos()
* set the given object.
* @param p a position object previously set by getPos()
*/
void setPos(const Pos& p);
/**
* Skips ahead past any ignored characters, as indicated by the given
* options. This is useful in conjunction with the lookahead() method.
*
* Currently, this only has an effect for SKIP_WHITESPACE.
* @param options one or more of the following options, bitwise-OR-ed
* together: PARSE_VARIABLES, PARSE_ESCAPES, SKIP_WHITESPACE.
*/
void skipIgnored(int32_t options);
/**
* Returns a string containing the remainder of the characters to be
* returned by this iterator, without any option processing. If the
* iterator is currently within a variable expansion, this will only
* extend to the end of the variable expansion. This method is provided
* so that iterators may interoperate with string-based APIs. The typical
* sequence of calls is to call skipIgnored(), then call lookahead(), then
* parse the string returned by lookahead(), then call jumpahead() to
* resynchronize the iterator.
* @param result a string to receive the characters to be returned
* by future calls to next()
* @param maxLookAhead The maximum to copy into the result.
* @return a reference to result
*/
UnicodeString& lookahead(UnicodeString& result, int32_t maxLookAhead = -1) const;
/**
* Advances the position by the given number of 16-bit code units.
* This is useful in conjunction with the lookahead() method.
* @param count the number of 16-bit code units to jump over
*/
void jumpahead(int32_t count);
/**
* Returns a string representation of this object, consisting of the
* characters being iterated, with a '|' marking the current position.
* Position within an expanded variable is <em>not</em> indicated.
* @param result output parameter to receive a string
* representation of this object
*/
// UnicodeString& toString(UnicodeString& result) const;
private:
/**
* Returns the current 32-bit code point without parsing escapes, parsing
* variables, or skipping whitespace.
* @return the current 32-bit code point
*/
UChar32 _current() const;
/**
* Advances the position by the given amount.
* @param count the number of 16-bit code units to advance past
*/
void _advance(int32_t count);
};
inline UBool RuleCharacterIterator::inVariable() const {
return buf != 0;
}
U_NAMESPACE_END
#endif // _RULEITER_H_
//eof
|
