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