1 | // © 2016 and later: Unicode, Inc. and others. |
2 | // License & terms of use: http://www.unicode.org/copyright.html |
3 | /* |
4 | * Copyright (C) 1997-2005, International Business Machines Corporation and others. All Rights Reserved. |
5 | ******************************************************************************* |
6 | * |
7 | * File PARSEPOS.H |
8 | * |
9 | * Modification History: |
10 | * |
11 | * Date Name Description |
12 | * 07/09/97 helena Converted from java. |
13 | * 07/17/98 stephen Added errorIndex support. |
14 | * 05/11/99 stephen Cleaned up. |
15 | ******************************************************************************* |
16 | */ |
17 | |
18 | #ifndef PARSEPOS_H |
19 | #define PARSEPOS_H |
20 | |
21 | #include "unicode/utypes.h" |
22 | |
23 | #if U_SHOW_CPLUSPLUS_API |
24 | |
25 | #include "unicode/uobject.h" |
26 | |
27 | |
28 | U_NAMESPACE_BEGIN |
29 | |
30 | /** |
31 | * \file |
32 | * \brief C++ API: Canonical Iterator |
33 | */ |
34 | /** |
35 | * <code>ParsePosition</code> is a simple class used by <code>Format</code> |
36 | * and its subclasses to keep track of the current position during parsing. |
37 | * The <code>parseObject</code> method in the various <code>Format</code> |
38 | * classes requires a <code>ParsePosition</code> object as an argument. |
39 | * |
40 | * <p> |
41 | * By design, as you parse through a string with different formats, |
42 | * you can use the same <code>ParsePosition</code>, since the index parameter |
43 | * records the current position. |
44 | * |
45 | * The ParsePosition class is not suitable for subclassing. |
46 | * |
47 | * @version 1.3 10/30/97 |
48 | * @author Mark Davis, Helena Shih |
49 | * @see java.text.Format |
50 | */ |
51 | |
52 | class U_COMMON_API ParsePosition : public UObject { |
53 | public: |
54 | /** |
55 | * Default constructor, the index starts with 0 as default. |
56 | * @stable ICU 2.0 |
57 | */ |
58 | ParsePosition() |
59 | : UObject(), |
60 | index(0), |
61 | errorIndex(-1) |
62 | {} |
63 | |
64 | /** |
65 | * Create a new ParsePosition with the given initial index. |
66 | * @param newIndex the new text offset. |
67 | * @stable ICU 2.0 |
68 | */ |
69 | ParsePosition(int32_t newIndex) |
70 | : UObject(), |
71 | index(newIndex), |
72 | errorIndex(-1) |
73 | {} |
74 | |
75 | /** |
76 | * Copy constructor |
77 | * @param copy the object to be copied from. |
78 | * @stable ICU 2.0 |
79 | */ |
80 | ParsePosition(const ParsePosition& copy) |
81 | : UObject(copy), |
82 | index(copy.index), |
83 | errorIndex(copy.errorIndex) |
84 | {} |
85 | |
86 | /** |
87 | * Destructor |
88 | * @stable ICU 2.0 |
89 | */ |
90 | virtual ~ParsePosition(); |
91 | |
92 | /** |
93 | * Assignment operator |
94 | * @stable ICU 2.0 |
95 | */ |
96 | inline ParsePosition& operator=(const ParsePosition& copy); |
97 | |
98 | /** |
99 | * Equality operator. |
100 | * @return true if the two parse positions are equal, false otherwise. |
101 | * @stable ICU 2.0 |
102 | */ |
103 | inline bool operator==(const ParsePosition& that) const; |
104 | |
105 | /** |
106 | * Equality operator. |
107 | * @return true if the two parse positions are not equal, false otherwise. |
108 | * @stable ICU 2.0 |
109 | */ |
110 | inline bool operator!=(const ParsePosition& that) const; |
111 | |
112 | /** |
113 | * Clone this object. |
114 | * Clones can be used concurrently in multiple threads. |
115 | * If an error occurs, then nullptr is returned. |
116 | * The caller must delete the clone. |
117 | * |
118 | * @return a clone of this object |
119 | * |
120 | * @see getDynamicClassID |
121 | * @stable ICU 2.8 |
122 | */ |
123 | ParsePosition *clone() const; |
124 | |
125 | /** |
126 | * Retrieve the current parse position. On input to a parse method, this |
127 | * is the index of the character at which parsing will begin; on output, it |
128 | * is the index of the character following the last character parsed. |
129 | * @return the current index. |
130 | * @stable ICU 2.0 |
131 | */ |
132 | inline int32_t getIndex(void) const; |
133 | |
134 | /** |
135 | * Set the current parse position. |
136 | * @param index the new index. |
137 | * @stable ICU 2.0 |
138 | */ |
139 | inline void setIndex(int32_t index); |
140 | |
141 | /** |
142 | * Set the index at which a parse error occurred. Formatters |
143 | * should set this before returning an error code from their |
144 | * parseObject method. The default value is -1 if this is not |
145 | * set. |
146 | * @stable ICU 2.0 |
147 | */ |
148 | inline void setErrorIndex(int32_t ei); |
149 | |
150 | /** |
151 | * Retrieve the index at which an error occurred, or -1 if the |
152 | * error index has not been set. |
153 | * @stable ICU 2.0 |
154 | */ |
155 | inline int32_t getErrorIndex(void) const; |
156 | |
157 | /** |
158 | * ICU "poor man's RTTI", returns a UClassID for this class. |
159 | * |
160 | * @stable ICU 2.2 |
161 | */ |
162 | static UClassID U_EXPORT2 getStaticClassID(); |
163 | |
164 | /** |
165 | * ICU "poor man's RTTI", returns a UClassID for the actual class. |
166 | * |
167 | * @stable ICU 2.2 |
168 | */ |
169 | virtual UClassID getDynamicClassID() const override; |
170 | |
171 | private: |
172 | /** |
173 | * Input: the place you start parsing. |
174 | * <br>Output: position where the parse stopped. |
175 | * This is designed to be used serially, |
176 | * with each call setting index up for the next one. |
177 | */ |
178 | int32_t index; |
179 | |
180 | /** |
181 | * The index at which a parse error occurred. |
182 | */ |
183 | int32_t errorIndex; |
184 | |
185 | }; |
186 | |
187 | inline ParsePosition& |
188 | ParsePosition::operator=(const ParsePosition& copy) |
189 | { |
190 | index = copy.index; |
191 | errorIndex = copy.errorIndex; |
192 | return *this; |
193 | } |
194 | |
195 | inline bool |
196 | ParsePosition::operator==(const ParsePosition& copy) const |
197 | { |
198 | if(index != copy.index || errorIndex != copy.errorIndex) |
199 | return false; |
200 | else |
201 | return true; |
202 | } |
203 | |
204 | inline bool |
205 | ParsePosition::operator!=(const ParsePosition& copy) const |
206 | { |
207 | return !operator==(copy); |
208 | } |
209 | |
210 | inline int32_t |
211 | ParsePosition::getIndex() const |
212 | { |
213 | return index; |
214 | } |
215 | |
216 | inline void |
217 | ParsePosition::setIndex(int32_t offset) |
218 | { |
219 | this->index = offset; |
220 | } |
221 | |
222 | inline int32_t |
223 | ParsePosition::getErrorIndex() const |
224 | { |
225 | return errorIndex; |
226 | } |
227 | |
228 | inline void |
229 | ParsePosition::setErrorIndex(int32_t ei) |
230 | { |
231 | this->errorIndex = ei; |
232 | } |
233 | U_NAMESPACE_END |
234 | |
235 | #endif /* U_SHOW_CPLUSPLUS_API */ |
236 | |
237 | #endif |
238 | |