AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ICU-176 add and document full, efficient UTF-16 support to CharacterIterator and ForwardCharacterIterator

Browse Source 
X-SVN-Rev: 1203
This commit is contained in:
Markus Scherer 2000-04-20 23:02:20 +00:00
parent e75d5d93c0
commit f421a70211
6 changed files with 642 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
icu4c/source/common/chariter.cpp
View File

@ -1,4 +1,3 @@
/*
**********************************************************************
* Copyright (C) 1999, International Business Machines
@ -8,5 +7,69 @@
#include "unicode/chariter.h"
CharacterIterator::~CharacterIterator()
{}
CharacterIterator::CharacterIterator(int32_t length)
: textLength(length), pos(0), begin(0), end(length) {
if(textLength < 0) {
textLength = end = 0;
}
}
CharacterIterator::CharacterIterator(int32_t length, UTextOffset position)
: textLength(length), pos(position), begin(0), end(length) {
if(textLength < 0) {
textLength = end = 0;
}
if(pos < 0) {
pos = 0;
} else if(pos > end) {
pos = end;
}
}
CharacterIterator::CharacterIterator(int32_t length, UTextOffset begin, UTextOffset end, UTextOffset position)
: textLength(length), pos(position), begin(begin), end(end) {
if(textLength < 0) {
textLength = 0;
}
if(begin < 0) {
begin = 0;
} else if(begin > textLength) {
begin = textLength;
}
if(end < begin) {
end = begin;
} else if(end > textLength) {
end = textLength;
}
if(pos < begin) {
pos = begin;
} else if(pos > end) {
pos = end;
}
}
CharacterIterator::CharacterIterator(const CharacterIterator &that) :
textLength(that.textLength), pos(that.pos), begin(that.begin), end(that.end) {}
CharacterIterator &
CharacterIterator::operator=(const CharacterIterator &that) {
textLength = that.textLength;
pos = that.pos;
begin = that.begin;
end = that.end;
return *this;
}
// implementing first[32]PostInc() directly in a subclass should be faster
// but these implementations make subclassing a little easier
UChar
CharacterIterator::firstPostInc(void) {
setToStart();
return nextPostInc();
}
UChar32
CharacterIterator::first32PostInc(void) {
setToStart();
return next32PostInc();
}

2
icu4c/source/common/schriter.cpp
View File

@ -75,7 +75,7 @@ StringCharacterIterator::operator=(const StringCharacterIterator& that) {
}
bool_t
StringCharacterIterator::operator==(const CharacterIterator& that) const {
StringCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
if (this == &that) {
return TRUE;
}

155
icu4c/source/common/uchriter.cpp
View File

@ -10,47 +10,24 @@
UCharCharacterIterator::UCharCharacterIterator()
: CharacterIterator(),
text(0),
textLength(0),
pos(0),
begin(0),
end(0)
text(0)
{
// never default construct!
}
UCharCharacterIterator::UCharCharacterIterator(const UChar* text,
int32_t textLength)
: CharacterIterator(),
text(text),
textLength(textLength),
pos(0),
begin(0),
end(textLength)
: CharacterIterator(text != 0 ? textLength : 0),
text(text)
{
if(text == 0 || textLength < 0) {
textLength = end = 0;
}
}
UCharCharacterIterator::UCharCharacterIterator(const UChar* text,
int32_t textLength,
UTextOffset pos)
: CharacterIterator(),
text(text),
textLength(textLength),
pos(pos),
begin(0),
end(textLength)
: CharacterIterator(text != 0 ? textLength : 0, pos),
text(text)
{
if(text == 0 || textLength < 0) {
textLength = end = 0;
}
if(pos < 0) {
pos = 0;
} else if(pos > end) {
pos = end;
}
}
UCharCharacterIterator::UCharCharacterIterator(const UChar* text,
@ -58,50 +35,21 @@ UCharCharacterIterator::UCharCharacterIterator(const UChar* text,
UTextOffset begin,
UTextOffset end,
UTextOffset pos)
: CharacterIterator(),
text(text),
textLength(textLength),
pos(pos),
begin(begin),
end(end)
: CharacterIterator(text != 0 ? textLength : 0, begin, end, pos),
text(text)
{
if(text == 0 || textLength < 0) {
textLength = 0;
}
if(begin < 0) {
begin = 0;
} else if(begin > textLength) {
begin = textLength;
}
if(end < begin) {
end = begin;
} else if(end > textLength) {
end = textLength;
}
if(pos < begin) {
pos = begin;
} else if(pos > end) {
pos = end;
}
}
UCharCharacterIterator::UCharCharacterIterator(const UCharCharacterIterator& that)
: CharacterIterator(that),
text(that.text),
textLength(that.textLength),
pos(that.pos),
begin(that.begin),
end(that.end)
text(that.text)
{
}
UCharCharacterIterator&
UCharCharacterIterator::operator=(const UCharCharacterIterator& that) {
CharacterIterator::operator=(that);
text = that.text;
textLength = that.textLength;
pos = that.pos;
begin = that.begin;
end = that.end;
return *this;
}
@ -109,7 +57,7 @@ UCharCharacterIterator::~UCharCharacterIterator() {
}
bool_t
UCharCharacterIterator::operator==(const CharacterIterator& that) const {
UCharCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
if (this == &that) {
return TRUE;
}
@ -147,9 +95,14 @@ UCharCharacterIterator::first() {
}
}
UTextOffset
UCharCharacterIterator::setToStart() {
return pos = begin;
UChar
UCharCharacterIterator::firstPostInc() {
pos = begin;
if(pos < end) {
return text[pos++];
} else {
return DONE;
}
}
UChar
@ -162,11 +115,6 @@ UCharCharacterIterator::last() {
}
}
UTextOffset
UCharCharacterIterator::setToEnd() {
return pos = end;
}
UChar
UCharCharacterIterator::setIndex(UTextOffset pos) {
if(pos < begin) {
@ -243,6 +191,18 @@ UCharCharacterIterator::first32() {
}
}
UChar32
UCharCharacterIterator::first32PostInc() {
pos = begin;
if(pos < end) {
UChar32 c;
UTF_NEXT_CHAR(text, pos, end, c);
return c;
} else {
return DONE;
}
}
UChar32
UCharCharacterIterator::last32() {
pos = end;
@ -324,17 +284,58 @@ UCharCharacterIterator::previous32() {
}
UTextOffset
UCharCharacterIterator::startIndex() const {
return begin;
UCharCharacterIterator::move(int32_t delta, CharacterIterator::EOrigin origin) {
switch(origin) {
case kStart:
pos = begin + delta;
break;
case kCurrent:
pos += delta;
break;
case kEnd:
pos = end + delta;
break;
default:
break;
}
if(pos < begin) {
pos = begin;
} else if(pos > end) {
pos = end;
}
return pos;
}
UTextOffset
UCharCharacterIterator::endIndex() const {
return end;
}
UCharCharacterIterator::move32(int32_t delta, CharacterIterator::EOrigin origin) {
// this implementation relies on the "safe" version of the UTF macros
// (or the trustworthiness of the caller)
switch(origin) {
case kStart:
pos = begin;
if(delta > 0) {
UTF_FWD_N(text, pos, end, delta);
}
break;
case kCurrent:
if(delta > 0) {
UTF_FWD_N(text, pos, end, delta);
} else {
UTF_BACK_N(text, pos, end, -delta);
}
break;
case kEnd:
pos = end;
if(delta < 0) {
UTF_BACK_N(text, pos, end, -delta);
}
break;
default:
break;
}
UTextOffset
UCharCharacterIterator::getIndex() const {
return pos;
}

530
icu4c/source/common/unicode/chariter.h
View File

@ -1,4 +1,3 @@
/*
********************************************************************
*
@ -14,79 +13,74 @@
#include "unicode/utypes.h"
#include "unicode/unistr.h"
/**
* Abstract class defining a protcol for accessing characters in a text-storage object.
<P>Examples:<P>
Function processing characters, in this example simple output
<pre>
. void processChar( UChar c )
. {
. cout &lt;&lt; " " &lt;&lt; c;
. }
</pre>
Traverse the text from start to finish
<pre>
. void traverseForward(CharacterIterator& iter)
. {
. for(UChar c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
. processChar(c);
. }
. }
</pre>
Traverse the text backwards, from end to start
<pre>
. void traverseBackward(CharacterIterator& iter)
. {
. for(UChar c = iter.last(); c != CharacterIterator.DONE; c = iter.previous()) {
. processChar(c);
. }
. }
</pre>
Traverse both forward and backward from a given position in the text.
Calls to notBoundary() in this example represents some additional stopping criteria.
<pre>
. void traverseOut(CharacterIterator& iter, UTextOffset pos)
. {
. UChar c;
. for (c = iter.setIndex(pos);
. c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
. c = iter.next()) {}
. UTextOffset end = iter.getIndex();
. for (c = iter.setIndex(pos);
. c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
. c = iter.previous()) {}
. UTextOffset start = iter.getIndex() + 1;
.
. cout &lt;&lt; "start: " &lt;&lt; start &lt;&lt; " end: " &lt;&lt; end &lt;&lt; endl;
. for (c = iter.setIndex(start); iter.getIndex() &lt; end; c = iter.next() ) {
. processChar(c);
. }
. }
</pre>
Creating a StringCharacterIteratorand calling the test functions
<pre>
. void CharacterIterator_Example( void )
. {
. cout &lt;&lt; endl &lt;&lt; "===== CharacterIterator_Example: =====" &lt;&lt; endl;
. UnicodeString text("Ein kleiner Satz.");
. StringCharacterIterator iterator(text);
. cout &lt;&lt; "----- traverseForward: -----------" &lt;&lt; endl;
. traverseForward( iterator );
. cout &lt;&lt; endl &lt;&lt; endl &lt;&lt; "----- traverseBackward: ----------" &lt;&lt; endl;
. traverseBackward( iterator );
. cout &lt;&lt; endl &lt;&lt; endl &lt;&lt; "----- traverseOut: ---------------" &lt;&lt; endl;
. traverseOut( iterator, 7 );
. cout &lt;&lt; endl &lt;&lt; endl &lt;&lt; "-----" &lt;&lt; endl;
. }
</pre>
* Abstract class that defines an API for forward-only iteration
* on text objects.
* This is a minimal interface for iteration without random access
* or backwards iteration. It is especially useful for wrapping
* streams with converters into an object for collation or
* normalization.
*
* <p>Characters can be accessed in two ways: as code units or as
* code points.
* Unicode code points are 21-bit integers and are the scalar values
* of Unicode characters. ICU uses the type UChar32 for them.
* Unicode code units are the storage units of a given
* Unicode/UCS Transformation Format (a character encoding scheme).
* With UTF-16, all code points can be represented with either one
* or two code units ("surrogates").
* String storage is typically based on code units, while properties
* of characters are typically determined using code point values.
* Some processes may be designed to work with sequences of code units,
* or it may be known that all characters that are important to an
* algorithm can be represented with single code units.
* Other processes will need to use the code point access functions.</p>
*
* <p>ForwardCharacterIterator provides nextPostInc() to access
* a code unit and advance an internal position into the text object,
* similar to a <code>return text[position++]</code>.<br>
* It provides next32PostInc() to access a code point and advance an internal
* position.</p>
*
* <p>next32PostInc() assumes that the current position is that of
* the beginning of a code point, i.e., of its first code unit.
* After next32PostInc(), this will be true again.
* In general, access to code units and code points in the same
* iteration loop should not be mixed. In UTF-16, if the current position
* is on a second code unit (Low Surrogate), then only that code unit
* is returned even by next32PostInc().</p>
*
* <p>For iteration with either function, there are two ways to
* check for the end of the iteration. When there are no more
* characters in the text object:
* <ul>
* <li>The hasNext() function returns FALSE.</li>
* <li>nextPostInc() and next32PostInc() return DONE
* when one attempts to read beyond the end of the text object.</li>
* </ul>
*
* Example:
* <pre>
* &#32; void function1(ForwardCharacterIterator &it) {
* &#32; UChar32 c;
* &#32; while(it.hasNext()) {
* &#32; c=it.next32PostInc();
* &#32; // use c
* &#32; }
* &#32; }
*
* &#32; void function1(ForwardCharacterIterator &it) {
* &#32; UChar c;
* &#32; while((c=it.nextPostInc())!=ForwardCharacterIterator::DONE) {
* &#32; // use c
* &#32; }
* &#32; }
* </pre></p>
*/
class U_COMMON_API CharacterIterator
{
class U_COMMON_API ForwardCharacterIterator {
public:
/**
* Value returned by most of CharacterIterator's functions
* Value returned by most of ForwardCharacterIterator's functions
* when the iterator has reached the limits of its iteration. */
enum { DONE = 0xffff };
@ -94,14 +88,14 @@ public:
* Destructor.
* @stable
*/
virtual ~CharacterIterator();
virtual ~ForwardCharacterIterator() {}
/**
* Returns true when both iterators refer to the same
* character in the same character-storage object.
* @stable
*/
virtual bool_t operator==(const CharacterIterator& that) const = 0;
virtual bool_t operator==(const ForwardCharacterIterator& that) const = 0;
/**
* Returns true when the iterators refer to different
@ -109,7 +103,210 @@ public:
* same text-storage object.
* @stable
*/
bool_t operator!=(const CharacterIterator& that) const { return !operator==(that); }
inline bool_t operator!=(const ForwardCharacterIterator& that) const;
/**
* Generates a hash code for this iterator.
* @stable
*/
virtual int32_t hashCode(void) const = 0;
/**
* Returns a UClassID for this ForwardCharacterIterator ("poor man's
* RTTI").<P> Despite the fact that this function is public,
* DO NOT CONSIDER IT PART OF CHARACTERITERATOR'S API!
* @stable
*/
virtual UClassID getDynamicClassID(void) const = 0;
/**
* 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.
* @draft
*/
virtual UChar nextPostInc(void) = 0;
/**
* 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.
* @draft
*/
virtual UChar32 next32PostInc(void) = 0;
/**
* 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.
*/
virtual bool_t hasNext() = 0;
protected:
ForwardCharacterIterator() {}
ForwardCharacterIterator(const ForwardCharacterIterator&) {}
ForwardCharacterIterator &operator=(const ForwardCharacterIterator&) { return *this; }
};
/**
* Abstract class that defines an API for iteration
* on text objects.
* This is an interface for forward and backward iteration
* and random access into a text object.
*
* <p>The API provides backward compatibility to the Java and older ICU
* CharacterIterator classes but extends them significantly:
* <ol>
* <li>CharacterIterator is now a subclass of ForwardCharacterIterator.</li>
* <li>While the old API functions provided forward iteration with
* "pre-increment" semantics, the new one also provides functions
* with "post-increment" semantics. They are more efficient and should
* be the preferred iterator functions for new implementations.
* The backward iteration always had "pre-decrement" semantics, which
* are efficient.</li>
* <li>Just like ForwardCharacterIterator, it provides access to
* both code units and code points. Code point access versions are available
* for the old and the new iteration semantics.</li>
* <li>There are new functions for setting and moving the current position
* without returning a character, for efficiency.</li>
* <ol>
*
* See ForwardCharacterIterator for examples for using the new forward iteration
* functions. For backward iteration, there is also a hasPrevious() function
* that can be used analogously to hasNext().
* The old functions work as before and are shown below.</p>
*
* <p>Examples for some of the new functions:</p>
*
* Forward iteration with hasNext():
* &#32; void forward1(CharacterIterator &it) {
* &#32; UChar32 c;
* &#32; for(it.setToStart(); it.hasNext();) {
* &#32; c=it.next32PostInc();
* &#32; // use c
* &#32; }
* &#32; }
*
* Forward iteration more similar to loops with the old forward iteration,
* showing a way to convert simple for() loops:
* &#32; void forward2(CharacterIterator &it) {
* &#32; UChar c;
* &#32; for(c=it.firstPostInc(); c!=CharacterIterator::DONE; c=it.nextPostInc()) {
* &#32; // use c
* &#32; }
* &#32; }
*
* Backward iteration with setToEnd() and hasPrevious():
* &#32; void backward1(CharacterIterator &it) {
* &#32; UChar32 c;
* &#32; for(it.setToEnd(); it.hasPrevious();) {
* &#32; c=it.previous32();
* &#32; // use c
* &#32; }
* &#32; }
*
* Backward iteration with a more traditional for() loop:
* &#32; void backward2(CharacterIterator &it) {
* &#32; UChar c;
* &#32; for(c=it.last(); c!=CharacterIterator::DONE; c=it.previous()) {
* &#32; // use c
* &#32; }
* &#32; }
*
* Example for random access:
* &#32; void random(CharacterIterator &it) {
* &#32; // set to the third code point from the beginning
* &#32; it.move32(3, CharacterIterator::kStart);
* &#32; // get a code point from here without moving the position
* &#32; UChar32 c=it.current32();
* &#32; // get the position
* &#32; int32_t pos=it.getIndex();
* &#32; // get the previous code unit
* &#32; UChar u=it.previous();
* &#32; // move back one more code unit
* &#32; it.move(-1, CharacterIterator::kCurrent);
* &#32; // set the position back to where it was
* &#32; // and read the same code point c and move beyond it
* &#32; it.setIndex(pos);
* &#32; if(c!=it.next32PostInc()) {
* &#32; exit(1); // CharacterIterator inconsistent
* &#32; }
* &#32; }
*
* <p>Examples, especially for the old API:</p>
*
* Function processing characters, in this example simple output
* <pre>
* &#32; void processChar( UChar c )
* &#32; {
* &#32; cout &lt;&lt; " " &lt;&lt; c;
* &#32; }
* </pre>
* Traverse the text from start to finish
* <pre>
* &#32; void traverseForward(CharacterIterator& iter)
* &#32; {
* &#32; for(UChar c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
* &#32; processChar(c);
* &#32; }
* &#32; }
* </pre>
* Traverse the text backwards, from end to start
* <pre>
* &#32; void traverseBackward(CharacterIterator& iter)
* &#32; {
* &#32; for(UChar c = iter.last(); c != CharacterIterator.DONE; c = iter.previous()) {
* &#32; processChar(c);
* &#32; }
* &#32; }
* </pre>
* Traverse both forward and backward from a given position in the text.
* Calls to notBoundary() in this example represents some additional stopping criteria.
* <pre>
* &#32; void traverseOut(CharacterIterator& iter, UTextOffset pos)
* &#32; {
* &#32; UChar c;
* &#32; for (c = iter.setIndex(pos);
* &#32; c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
* &#32; c = iter.next()) {}
* &#32; UTextOffset end = iter.getIndex();
* &#32; for (c = iter.setIndex(pos);
* &#32; c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
* &#32; c = iter.previous()) {}
* &#32; UTextOffset start = iter.getIndex() + 1;
* &#32;
* &#32; cout &lt;&lt; "start: " &lt;&lt; start &lt;&lt; " end: " &lt;&lt; end &lt;&lt; endl;
* &#32; for (c = iter.setIndex(start); iter.getIndex() &lt; end; c = iter.next() ) {
* &#32; processChar(c);
* &#32; }
* &#32; }
* </pre>
* Creating a StringCharacterIterator and calling the test functions
* <pre>
* &#32; void CharacterIterator_Example( void )
* &#32; {
* &#32; cout &lt;&lt; endl &lt;&lt; "===== CharacterIterator_Example: =====" &lt;&lt; endl;
* &#32; UnicodeString text("Ein kleiner Satz.");
* &#32; StringCharacterIterator iterator(text);
* &#32; cout &lt;&lt; "----- traverseForward: -----------" &lt;&lt; endl;
* &#32; traverseForward( iterator );
* &#32; cout &lt;&lt; endl &lt;&lt; endl &lt;&lt; "----- traverseBackward: ----------" &lt;&lt; endl;
* &#32; traverseBackward( iterator );
* &#32; cout &lt;&lt; endl &lt;&lt; endl &lt;&lt; "----- traverseOut: ---------------" &lt;&lt; endl;
* &#32; traverseOut( iterator, 7 );
* &#32; cout &lt;&lt; endl &lt;&lt; endl &lt;&lt; "-----" &lt;&lt; endl;
* &#32; }
* </pre>
*/
class U_COMMON_API CharacterIterator : public ForwardCharacterIterator {
public:
/**
* Origin enumeration for the move() and move32() functions.
*/
enum EOrigin { kStart, kCurrent, kEnd };
/**
* Returns a pointer to a new CharacterIterator of the same
@ -118,34 +315,57 @@ public:
* caller is responsible for deleting the new clone.
* @stable
*/
virtual CharacterIterator*
clone(void) const = 0;
virtual CharacterIterator* clone(void) const = 0;
/**
* Generates a hash code for this iterator.
* @stable
*/
virtual int32_t hashCode(void) const = 0;
/**
* Sets the iterator to refer to the first code unit in its
* iteration range, and returns that code unit,
* iteration range, and returns that code unit.
* This can be used to begin an iteration with next().
* @draft
*/
virtual UChar first(void) = 0;
/**
* 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().
* @draft
*/
virtual inline UChar 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.
* @draft
*/
virtual UChar32 first32(void) = 0;
virtual UTextOffset setToStart() = 0;
/**
* 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().
* @draft
*/
virtual inline UChar32 first32PostInc(void);
/**
* Sets the iterator to refer to the first code unit or code point in its
* iteration range. This can be used to begin a forward
* iteration with nextPostInc() or next32PostInc().
* @return the start position of the iteration range
* @draft
*/
inline UTextOffset setToStart();
/**
* 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().
* @draft
*/
virtual UChar last(void) = 0;
@ -153,11 +373,19 @@ public:
/**
* 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().
* @draft
*/
virtual UChar32 last32(void) = 0;
virtual UTextOffset setToEnd() = 0;
/**
* Sets the iterator to the end of its iteration range, just behind
* the last code unit or code point. This can be used to begin a backward
* iteration with previous() or previous32().
* @return the end position of the iteration range
* @draft
*/
inline UTextOffset setToEnd();
/**
* Sets the iterator to refer to the "position"-th code unit
@ -171,7 +399,9 @@ public:
* 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.
* returns that code point.
* The current position is adjusted to the beginning of the code point
* (its first code unit).
* @draft
*/
virtual UChar32 setIndex32(UTextOffset position) = 0;
@ -190,43 +420,26 @@ public:
/**
* Advances to the next code unit in the iteration range
* (toward last()), and returns that code unit. If there are
* no more code units to return, returns DONE.
* (toward endIndex()), and returns that code unit. If there are
* no more code units to return, returns DONE.
* @draft
*/
virtual UChar next(void) = 0;
/**
* Gets the current code unit for returning and advances to the next code unit
* in the iteration range
* (toward last()). If there are
* no more code units to return, returns DONE.
* @draft
*/
virtual UChar nextPostInc(void) = 0;
/**
* Advances to the next code point in the iteration range
* (toward last()), and returns that code point. If there are
* no more code points to return, returns DONE.
* (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().
* @draft
*/
virtual UChar32 next32(void) = 0;
/**
* Gets the current code point for returning and advances to the next code point
* in the iteration range
* (toward last()). If there are
* no more code points to return, returns DONE.
* @draft
*/
virtual UChar32 next32PostInc(void) = 0;
virtual bool_t hasNext() = 0;
/**
* Advances to the previous code unit in the iteration rance
* (toward first()), and returns that code unit. If there are
* (toward startIndex()), and returns that code unit. If there are
* no more code units to return, returns DONE.
* @draft
*/
@ -234,12 +447,18 @@ public:
/**
* Advances to the previous code point in the iteration rance
* (toward first()), and returns that code point. If there are
* (toward startIndex()), and returns that code point. If there are
* no more code points to return, returns DONE.
* @draft
*/
virtual UChar32 previous32(void) = 0;
/**
* 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.
*/
virtual bool_t hasPrevious() = 0;
/**
@ -250,7 +469,7 @@ public:
* necessarily 0.
* @stable
*/
virtual UTextOffset startIndex(void) const = 0;
inline UTextOffset startIndex(void) const;
/**
* Returns the numeric index in the underlying text-storage
@ -258,7 +477,7 @@ public:
* returned by last().
* @stable
*/
virtual UTextOffset endIndex(void) const = 0;
inline UTextOffset endIndex(void) const;
/**
* Returns the numeric index in the underlying text-storage
@ -266,7 +485,31 @@ public:
* (i.e., the character returned by current()).
* @stable
*/
virtual UTextOffset getIndex(void) const = 0;
inline UTextOffset getIndex(void) const;
/**
* Returns the length of the entire text in the underlying
* text-storage object.
*/
inline int32_t getLength() const;
/**
* 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.
* @return the new position
*/
virtual UTextOffset move(int32_t delta, EOrigin origin) = 0;
/**
* 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.
* @return the new position
*/
virtual UTextOffset move32(int32_t delta, EOrigin origin) = 0;
/**
* Copies the text under iteration into the UnicodeString
@ -276,19 +519,54 @@ public:
*/
virtual void getText(UnicodeString& result) = 0;
/**
* Returns a UClassID for this CharacterIterator ("poor man's
* RTTI").<P> Despite the fact that this function is public,
* DO NOT CONSIDER IT PART OF CHARACTERITERATOR'S API!
* @stable
*/
virtual UClassID getDynamicClassID(void) const = 0;
protected:
CharacterIterator() {}
CharacterIterator(const CharacterIterator&) {}
CharacterIterator& operator=(const CharacterIterator&) { return *this; }
CharacterIterator(int32_t length);
CharacterIterator(int32_t length, UTextOffset position);
CharacterIterator(int32_t length, UTextOffset begin, UTextOffset end, UTextOffset position);
CharacterIterator(const CharacterIterator &that);
CharacterIterator &operator=(const CharacterIterator &that);
int32_t textLength; // need this for correct getText() and hashCode()
UTextOffset pos;
UTextOffset begin;
UTextOffset end;
};
inline bool_t
ForwardCharacterIterator::operator!=(const ForwardCharacterIterator& that) const {
return !operator==(that);
}
inline UTextOffset
CharacterIterator::setToStart() {
return move(0, kStart);
}
inline UTextOffset
CharacterIterator::setToEnd() {
return move(0, kEnd);
}
inline UTextOffset
CharacterIterator::startIndex(void) const {
return begin;
}
inline UTextOffset
CharacterIterator::endIndex(void) const {
return end;
}
inline UTextOffset
CharacterIterator::getIndex(void) const {
return pos;
}
inline int32_t
CharacterIterator::getLength(void) const {
return textLength;
}
#endif

8
icu4c/source/common/unicode/schriter.h
View File

@ -30,6 +30,8 @@
* create one that iterates over only a subrange of a UnicodeString
* (iterators over different subranges of the same UnicodeString don't
* compare equal).
* @see CharacterIterator
* @see ForwardCharacterIterator
*/
class U_COMMON_API StringCharacterIterator : public UCharCharacterIterator {
public:
@ -97,7 +99,7 @@ public:
* same string and are pointing at the same character.
* @stable
*/
virtual bool_t operator==(const CharacterIterator& that) const;
virtual bool_t operator==(const ForwardCharacterIterator& that) const;
/**
* Returns a new StringCharacterIterator referring to the same
@ -116,8 +118,8 @@ public:
/**
* Copies the UnicodeString 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.
* only a part of this string, the whole string is copied.
* @param result Receives a copy of the text under iteration.
* @stable
*/
virtual void getText(UnicodeString& result);

132
icu4c/source/common/unicode/uchriter.h
View File

@ -20,6 +20,8 @@
* create one that iterates over only a subrange of a UChar array
* (iterators over different subranges of the same UChar array don't
* compare equal).
* @see CharacterIterator
* @see ForwardCharacterIterator
*/
class U_COMMON_API UCharCharacterIterator : public CharacterIterator {
public:
@ -89,7 +91,7 @@ public:
* same string and are pointing at the same character.
* @stable
*/
virtual bool_t operator==(const CharacterIterator& that) const;
virtual bool_t operator==(const ForwardCharacterIterator& that) const;
/**
* Generates a hash code for this iterator.
@ -107,50 +109,71 @@ public:
/**
* Sets the iterator to refer to the first code unit in its
* iteration range, and returns that code unit,
* iteration range, and returns that code unit.
* This can be used to begin an iteration with next().
* @draft
*/
virtual UChar 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().
* @draft
*/
virtual UChar firstPostInc(void);
/**
* Sets the iterator to refer to the first code point in its
* iteration range, and returns that code point,
* 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.
* @draft
*/
virtual UChar32 first32(void);
virtual UTextOffset setToStart();
/**
* 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().
* @draft
*/
virtual UChar32 first32PostInc(void);
/**
* Sets the iterator to refer to the last code unit in its iteration
* range, and returns that code unit.
* 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().
* @draft
*/
virtual UChar last(void);
/**
* Sets the iterator to refer to the last code point in its iteration
* range, and returns that code point.
* 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().
* @draft
*/
virtual UChar32 last32(void);
virtual UTextOffset setToEnd();
/**
* Sets the iterator to refer to the "position"-th code unit in the
* UChar array the iterator refers to, and returns that code unit.
* If the index is outside the iterator's iteration range, the
* behavior of the iterator is undefined.
* 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.
* @draft
*/
virtual UChar setIndex(UTextOffset pos);
/**
* Sets the iterator to refer to the "position"-th code point in the
* UChar array the iterator refers to, and returns that code point.
* If the index is outside the iterator's iteration range, the
* behavior of the iterator is undefined.
* 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).
* @draft
*/
virtual UChar32 setIndex32(UTextOffset pos);
@ -169,29 +192,52 @@ public:
/**
* Advances to the next code unit in the iteration range (toward
* last()), and returns that code unit. If there are no more
* endIndex()), and returns that code unit. If there are no more
* code units to return, returns DONE.
* @draft
*/
virtual UChar 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.
* @draft
*/
virtual UChar nextPostInc(void);
/**
* Advances to the next code point in the iteration range (toward
* last()), and returns that code point. If there are no more
* 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().
* @draft
*/
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.
* @draft
*/
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.
*/
virtual bool_t hasNext();
/**
* Advances to the previous code unit in the iteration rance (toward
* first()), and returns that code unit. If there are no more
* startIndex()), and returns that code unit. If there are no more
* code units to return, returns DONE.
* @draft
*/
@ -199,35 +245,37 @@ public:
/**
* Advances to the previous code point in the iteration rance (toward
* first()), and returns that code point. If there are no more
* startIndex()), and returns that code point. If there are no more
* code points to return, returns DONE.
* @draft
*/
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.
*/
virtual bool_t hasPrevious();
/**
* Returns the numeric index of the first code unit in this
* iterator's iteration range.
* @stable
* 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.
* @return the new position
*/
virtual UTextOffset startIndex(void) const;
virtual UTextOffset move(int32_t delta, EOrigin origin);
/**
* Returns the numeric index of the code unit immediately BEYOND the
* last code unit in this iterator's iteration range.
* @stable
* 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.
* @return the new position
*/
virtual UTextOffset endIndex(void) const;
/**
* Returns the numeric index in the underlying UChar array of the
* code unit the iterator currently refers to (i.e., the code unit
* returned by current()).
* @stable
*/
virtual UTextOffset getIndex(void) const;
virtual UTextOffset move32(int32_t delta, EOrigin origin);
/**
* Sets the iterator to iterate over a new range of text
@ -238,8 +286,8 @@ public:
/**
* Copies the UChar 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.
* only a part of this string, the whole string is copied.
* @param result Receives a copy of the text under iteration.
* @stable
*/
virtual void getText(UnicodeString& result);
@ -262,10 +310,6 @@ protected:
UCharCharacterIterator();
const UChar* text;
int32_t textLength; // need this for correct getText() and hashCode()
UTextOffset pos;
UTextOffset begin;
UTextOffset end;
static char fgClassID;
};