388 lines
13 KiB
C++
388 lines
13 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
**********************************************************************
|
|
* Copyright (C) 1998-2005, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
**********************************************************************
|
|
*/
|
|
|
|
#ifndef UCHRITER_H
|
|
#define UCHRITER_H
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/chariter.h"
|
|
|
|
/**
|
|
* \file
|
|
* \brief C++ API: char16_t Character Iterator
|
|
*/
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
/**
|
|
* A concrete subclass of CharacterIterator that iterates over the
|
|
* characters (code units or code points) in a char16_t array.
|
|
* It's possible not only to create an
|
|
* iterator that iterates over an entire char16_t array, but also to
|
|
* create one that iterates over only a subrange of a char16_t array
|
|
* (iterators over different subranges of the same char16_t array don't
|
|
* compare equal).
|
|
* @see CharacterIterator
|
|
* @see ForwardCharacterIterator
|
|
* @stable ICU 2.0
|
|
*/
|
|
class U_COMMON_API UCharCharacterIterator : public CharacterIterator {
|
|
public:
|
|
/**
|
|
* Create an iterator over the char16_t array referred to by "textPtr".
|
|
* The iteration range is 0 to <code>length-1</code>.
|
|
* text is only aliased, not adopted (the
|
|
* destructor will not delete it).
|
|
* @param textPtr The char16_t array to be iterated over
|
|
* @param length The length of the char16_t array
|
|
* @stable ICU 2.0
|
|
*/
|
|
UCharCharacterIterator(ConstChar16Ptr textPtr, int32_t length);
|
|
|
|
/**
|
|
* Create an iterator over the char16_t array referred to by "textPtr".
|
|
* The iteration range is 0 to <code>length-1</code>.
|
|
* text is only aliased, not adopted (the
|
|
* destructor will not delete it).
|
|
* The starting
|
|
* position is specified by "position". If "position" is outside the valid
|
|
* iteration range, the behavior of this object is undefined.
|
|
* @param textPtr The char16_t array to be iteratd over
|
|
* @param length The length of the char16_t array
|
|
* @param position The starting position of the iteration
|
|
* @stable ICU 2.0
|
|
*/
|
|
UCharCharacterIterator(ConstChar16Ptr textPtr, int32_t length,
|
|
int32_t position);
|
|
|
|
/**
|
|
* Create an iterator over the char16_t array referred to by "textPtr".
|
|
* The iteration range is 0 to <code>end-1</code>.
|
|
* text is only aliased, not adopted (the
|
|
* destructor will not delete it).
|
|
* The starting
|
|
* position is specified by "position". If begin and end do not
|
|
* form a valid iteration range or "position" is outside the valid
|
|
* iteration range, the behavior of this object is undefined.
|
|
* @param textPtr The char16_t array to be iterated over
|
|
* @param length The length of the char16_t array
|
|
* @param textBegin The begin position of the iteration range
|
|
* @param textEnd The end position of the iteration range
|
|
* @param position The starting position of the iteration
|
|
* @stable ICU 2.0
|
|
*/
|
|
UCharCharacterIterator(ConstChar16Ptr textPtr, int32_t length,
|
|
int32_t textBegin,
|
|
int32_t textEnd,
|
|
int32_t position);
|
|
|
|
/**
|
|
* Copy constructor. The new iterator iterates over the same range
|
|
* of the same string as "that", and its initial position is the
|
|
* same as "that"'s current position.
|
|
* @param that The UCharCharacterIterator to be copied
|
|
* @stable ICU 2.0
|
|
*/
|
|
UCharCharacterIterator(const UCharCharacterIterator& that);
|
|
|
|
/**
|
|
* Destructor.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual ~UCharCharacterIterator();
|
|
|
|
/**
|
|
* Assignment operator. *this is altered to iterate over the sane
|
|
* range of the same string as "that", and refers to the same
|
|
* character within that string as "that" does.
|
|
* @param that The object to be copied
|
|
* @return the newly created object
|
|
* @stable ICU 2.0
|
|
*/
|
|
UCharCharacterIterator&
|
|
operator=(const UCharCharacterIterator& that);
|
|
|
|
/**
|
|
* Returns true if the iterators iterate over the same range of the
|
|
* same string and are pointing at the same character.
|
|
* @param that The ForwardCharacterIterator used to be compared for equality
|
|
* @return true if the iterators iterate over the same range of the
|
|
* same string and are pointing at the same character.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UBool operator==(const ForwardCharacterIterator& that) const;
|
|
|
|
/**
|
|
* Generates a hash code for this iterator.
|
|
* @return the hash code.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual int32_t hashCode(void) const;
|
|
|
|
/**
|
|
* Returns a new UCharCharacterIterator referring to the same
|
|
* character in the same range of the same string as this one. The
|
|
* caller must delete the new iterator.
|
|
* @return the CharacterIterator newly created
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual CharacterIterator* clone(void) const;
|
|
|
|
/**
|
|
* Sets the iterator to refer to the first code unit in its
|
|
* iteration range, and returns that code unit.
|
|
* This can be used to begin an iteration with next().
|
|
* @return the first code unit in its iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t first(void);
|
|
|
|
/**
|
|
* Sets the iterator to refer to the first code unit in its
|
|
* iteration range, returns that code unit, and moves the position
|
|
* to the second code unit. This is an alternative to setToStart()
|
|
* for forward iteration with nextPostInc().
|
|
* @return the first code unit in its iteration range
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t firstPostInc(void);
|
|
|
|
/**
|
|
* Sets the iterator to refer to the first code point in its
|
|
* iteration range, and returns that code unit,
|
|
* This can be used to begin an iteration with next32().
|
|
* Note that an iteration with next32PostInc(), beginning with,
|
|
* e.g., setToStart() or firstPostInc(), is more efficient.
|
|
* @return the first code point in its iteration range
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 first32(void);
|
|
|
|
/**
|
|
* Sets the iterator to refer to the first code point in its
|
|
* iteration range, returns that code point, and moves the position
|
|
* to the second code point. This is an alternative to setToStart()
|
|
* for forward iteration with next32PostInc().
|
|
* @return the first code point in its iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 first32PostInc(void);
|
|
|
|
/**
|
|
* Sets the iterator to refer to the last code unit in its
|
|
* iteration range, and returns that code unit.
|
|
* This can be used to begin an iteration with previous().
|
|
* @return the last code unit in its iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t last(void);
|
|
|
|
/**
|
|
* Sets the iterator to refer to the last code point in its
|
|
* iteration range, and returns that code unit.
|
|
* This can be used to begin an iteration with previous32().
|
|
* @return the last code point in its iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 last32(void);
|
|
|
|
/**
|
|
* Sets the iterator to refer to the "position"-th code unit
|
|
* in the text-storage object the iterator refers to, and
|
|
* returns that code unit.
|
|
* @param position the position within the text-storage object
|
|
* @return the code unit
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t setIndex(int32_t position);
|
|
|
|
/**
|
|
* Sets the iterator to refer to the beginning of the code point
|
|
* that contains the "position"-th code unit
|
|
* in the text-storage object the iterator refers to, and
|
|
* returns that code point.
|
|
* The current position is adjusted to the beginning of the code point
|
|
* (its first code unit).
|
|
* @param position the position within the text-storage object
|
|
* @return the code unit
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 setIndex32(int32_t position);
|
|
|
|
/**
|
|
* Returns the code unit the iterator currently refers to.
|
|
* @return the code unit the iterator currently refers to.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t current(void) const;
|
|
|
|
/**
|
|
* Returns the code point the iterator currently refers to.
|
|
* @return the code point the iterator currently refers to.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 current32(void) const;
|
|
|
|
/**
|
|
* Advances to the next code unit in the iteration range (toward
|
|
* endIndex()), and returns that code unit. If there are no more
|
|
* code units to return, returns DONE.
|
|
* @return the next code unit in the iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t next(void);
|
|
|
|
/**
|
|
* Gets the current code unit for returning and advances to the next code unit
|
|
* in the iteration range
|
|
* (toward endIndex()). If there are
|
|
* no more code units to return, returns DONE.
|
|
* @return the current code unit.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t nextPostInc(void);
|
|
|
|
/**
|
|
* Advances to the next code point in the iteration range (toward
|
|
* endIndex()), and returns that code point. If there are no more
|
|
* code points to return, returns DONE.
|
|
* Note that iteration with "pre-increment" semantics is less
|
|
* efficient than iteration with "post-increment" semantics
|
|
* that is provided by next32PostInc().
|
|
* @return the next code point in the iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 next32(void);
|
|
|
|
/**
|
|
* Gets the current code point for returning and advances to the next code point
|
|
* in the iteration range
|
|
* (toward endIndex()). If there are
|
|
* no more code points to return, returns DONE.
|
|
* @return the current point.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 next32PostInc(void);
|
|
|
|
/**
|
|
* Returns FALSE if there are no more code units or code points
|
|
* at or after the current position in the iteration range.
|
|
* This is used with nextPostInc() or next32PostInc() in forward
|
|
* iteration.
|
|
* @return FALSE if there are no more code units or code points
|
|
* at or after the current position in the iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UBool hasNext();
|
|
|
|
/**
|
|
* Advances to the previous code unit in the iteration range (toward
|
|
* startIndex()), and returns that code unit. If there are no more
|
|
* code units to return, returns DONE.
|
|
* @return the previous code unit in the iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual char16_t previous(void);
|
|
|
|
/**
|
|
* Advances to the previous code point in the iteration range (toward
|
|
* startIndex()), and returns that code point. If there are no more
|
|
* code points to return, returns DONE.
|
|
* @return the previous code point in the iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UChar32 previous32(void);
|
|
|
|
/**
|
|
* Returns FALSE if there are no more code units or code points
|
|
* before the current position in the iteration range.
|
|
* This is used with previous() or previous32() in backward
|
|
* iteration.
|
|
* @return FALSE if there are no more code units or code points
|
|
* before the current position in the iteration range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UBool hasPrevious();
|
|
|
|
/**
|
|
* Moves the current position relative to the start or end of the
|
|
* iteration range, or relative to the current position itself.
|
|
* The movement is expressed in numbers of code units forward
|
|
* or backward by specifying a positive or negative delta.
|
|
* @param delta the position relative to origin. A positive delta means forward;
|
|
* a negative delta means backward.
|
|
* @param origin Origin enumeration {kStart, kCurrent, kEnd}
|
|
* @return the new position
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual int32_t move(int32_t delta, EOrigin origin);
|
|
|
|
/**
|
|
* Moves the current position relative to the start or end of the
|
|
* iteration range, or relative to the current position itself.
|
|
* The movement is expressed in numbers of code points forward
|
|
* or backward by specifying a positive or negative delta.
|
|
* @param delta the position relative to origin. A positive delta means forward;
|
|
* a negative delta means backward.
|
|
* @param origin Origin enumeration {kStart, kCurrent, kEnd}
|
|
* @return the new position
|
|
* @stable ICU 2.0
|
|
*/
|
|
#ifdef move32
|
|
// One of the system headers right now is sometimes defining a conflicting macro we don't use
|
|
#undef move32
|
|
#endif
|
|
virtual int32_t move32(int32_t delta, EOrigin origin);
|
|
|
|
/**
|
|
* Sets the iterator to iterate over a new range of text
|
|
* @stable ICU 2.0
|
|
*/
|
|
void setText(ConstChar16Ptr newText, int32_t newTextLength);
|
|
|
|
/**
|
|
* Copies the char16_t array under iteration into the UnicodeString
|
|
* referred to by "result". Even if this iterator iterates across
|
|
* only a part of this string, the whole string is copied.
|
|
* @param result Receives a copy of the text under iteration.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual void getText(UnicodeString& result);
|
|
|
|
/**
|
|
* Return a class ID for this class (not really public)
|
|
* @return a class ID for this class
|
|
* @stable ICU 2.0
|
|
*/
|
|
static UClassID U_EXPORT2 getStaticClassID(void);
|
|
|
|
/**
|
|
* Return a class ID for this object (not really public)
|
|
* @return a class ID for this object.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UClassID getDynamicClassID(void) const;
|
|
|
|
protected:
|
|
/**
|
|
* Protected constructor
|
|
* @stable ICU 2.0
|
|
*/
|
|
UCharCharacterIterator();
|
|
/**
|
|
* Protected member text
|
|
* @stable ICU 2.0
|
|
*/
|
|
const char16_t* text;
|
|
|
|
};
|
|
|
|
U_NAMESPACE_END
|
|
#endif
|