/src/icu/source/common/unicode/parsepos.h

Source (jump to first uncovered line)
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
* Copyright (C) 1997-2005, International Business Machines Corporation and others. All Rights Reserved.
*******************************************************************************
*
* File PARSEPOS.H
*
* Modification History:
*
*   Date        Name        Description
*   07/09/97    helena      Converted from java.
*   07/17/98    stephen     Added errorIndex support.
*   05/11/99    stephen     Cleaned up.
*******************************************************************************
*/

#ifndef PARSEPOS_H
#define PARSEPOS_H

#include "unicode/utypes.h"

#if U_SHOW_CPLUSPLUS_API

#include "unicode/uobject.h"

 
U_NAMESPACE_BEGIN

/**
 * \file
 * \brief C++ API: Canonical Iterator
 */
/** 
 * <code>ParsePosition</code> is a simple class used by <code>Format</code>
 * and its subclasses to keep track of the current position during parsing.
 * The <code>parseObject</code> method in the various <code>Format</code>
 * classes requires a <code>ParsePosition</code> object as an argument.
 *
 * <p>
 * By design, as you parse through a string with different formats,
 * you can use the same <code>ParsePosition</code>, since the index parameter
 * records the current position.
 *
 * The ParsePosition class is not suitable for subclassing.
 *
 * @version     1.3 10/30/97
 * @author      Mark Davis, Helena Shih
 * @see         java.text.Format
 */

class U_COMMON_API ParsePosition : public UObject {
public:
    /**
     * Default constructor, the index starts with 0 as default.
     * @stable ICU 2.0
     */
    ParsePosition()
        : UObject(),
        index(0),
        errorIndex(-1)
      {}

    /**
     * Create a new ParsePosition with the given initial index.
     * @param newIndex the new text offset.
     * @stable ICU 2.0
     */
    ParsePosition(int32_t newIndex)
        : UObject(),
        index(newIndex),
        errorIndex(-1)
      {}

    /**
     * Copy constructor
     * @param copy the object to be copied from.
     * @stable ICU 2.0
     */
    ParsePosition(const ParsePosition& copy)
        : UObject(copy),
        index(copy.index),
        errorIndex(copy.errorIndex)
      {}

    /**
     * Destructor
     * @stable ICU 2.0
     */
    virtual ~ParsePosition();

    /**
     * Assignment operator
     * @stable ICU 2.0
     */
    inline ParsePosition&      operator=(const ParsePosition& copy);

    /**
     * Equality operator.
     * @return true if the two parse positions are equal, false otherwise.
     * @stable ICU 2.0
     */
    inline bool               operator==(const ParsePosition& that) const;

    /**
     * Equality operator.
     * @return true if the two parse positions are not equal, false otherwise.
     * @stable ICU 2.0
     */
    inline bool               operator!=(const ParsePosition& that) const;

    /**
     * Clone this object.
     * Clones can be used concurrently in multiple threads.
     * If an error occurs, then NULL is returned.
     * The caller must delete the clone.
     *
     * @return a clone of this object
     *
     * @see getDynamicClassID
     * @stable ICU 2.8
     */
    ParsePosition *clone() const;

    /**
     * Retrieve the current parse position.  On input to a parse method, this
     * is the index of the character at which parsing will begin; on output, it
     * is the index of the character following the last character parsed.
     * @return the current index.
     * @stable ICU 2.0
     */
    inline int32_t getIndex(void) const;

    /**
     * Set the current parse position.
     * @param index the new index.
     * @stable ICU 2.0
     */
    inline void setIndex(int32_t index);

    /**
     * Set the index at which a parse error occurred.  Formatters
     * should set this before returning an error code from their
     * parseObject method.  The default value is -1 if this is not
     * set.
     * @stable ICU 2.0
     */
    inline void setErrorIndex(int32_t ei);

    /**
     * Retrieve the index at which an error occurred, or -1 if the
     * error index has not been set.
     * @stable ICU 2.0
     */
    inline int32_t getErrorIndex(void) const;

    /**
     * ICU "poor man's RTTI", returns a UClassID for this class.
     *
     * @stable ICU 2.2
     */
    static UClassID U_EXPORT2 getStaticClassID();

    /**
     * ICU "poor man's RTTI", returns a UClassID for the actual class.
     *
     * @stable ICU 2.2
     */
    virtual UClassID getDynamicClassID() const;

private:
    /**
     * Input: the place you start parsing.
     * <br>Output: position where the parse stopped.
     * This is designed to be used serially,
     * with each call setting index up for the next one.
     */
    int32_t index;

    /**
     * The index at which a parse error occurred.
     */
    int32_t errorIndex;

};

inline ParsePosition&
ParsePosition::operator=(const ParsePosition& copy)
{
  index = copy.index;
  errorIndex = copy.errorIndex;
  return *this;
}

inline bool
ParsePosition::operator==(const ParsePosition& copy) const
{
  if(index != copy.index || errorIndex != copy.errorIndex)
  return false;
  else
  return true;
}

inline bool
ParsePosition::operator!=(const ParsePosition& copy) const
{
  return !operator==(copy);
}

inline int32_t
ParsePosition::getIndex() const
{
  return index;
}

inline void
ParsePosition::setIndex(int32_t offset)
{
  this->index = offset;
}

inline int32_t
ParsePosition::getErrorIndex() const
{
  return errorIndex;
}

inline void
ParsePosition::setErrorIndex(int32_t ei)
{
  this->errorIndex = ei;
}
U_NAMESPACE_END

#endif /* U_SHOW_CPLUSPLUS_API */

#endif

Coverage Report

Created: 2025-06-24 06:43

Line	Count	Source (jump to first uncovered line)
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	0	: UObject(),
60	0	index(0),
61	0	errorIndex(-1)
62	0	{}
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	0	: UObject(),
71	0	index(newIndex),
72	0	errorIndex(-1)
73	0	{}
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	0	: UObject(copy),
82	0	index(copy.index),
83	0	errorIndex(copy.errorIndex)
84	0	{}
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 NULL 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;
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	0	{
190	0	index = copy.index;
191	0	errorIndex = copy.errorIndex;
192	0	return *this;
193	0	}
194
195		inline bool
196		ParsePosition::operator==(const ParsePosition& copy) const
197	0	{
198	0	if(index != copy.index \|\| errorIndex != copy.errorIndex)
199	0	return false;
200	0	else
201	0	return true;
202	0	}
203
204		inline bool
205		ParsePosition::operator!=(const ParsePosition& copy) const
206	0	{
207	0	return !operator==(copy);
208	0	}
209
210		inline int32_t
211		ParsePosition::getIndex() const
212	0	{
213	0	return index;
214	0	}
215
216		inline void
217		ParsePosition::setIndex(int32_t offset)
218	0	{
219	0	this->index = offset;
220	0	}
221
222		inline int32_t
223		ParsePosition::getErrorIndex() const
224	0	{
225	0	return errorIndex;
226	0	}
227
228		inline void
229		ParsePosition::setErrorIndex(int32_t ei)
230	0	{
231	0	this->errorIndex = ei;
232	0	}
233		U_NAMESPACE_END
234
235		#endif /* U_SHOW_CPLUSPLUS_API */
236
237		#endif