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