ICU 63.1 63.1

chariter.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ********************************************************************
5 *
6 * Copyright (C) 1997-2011, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 ********************************************************************
10 */
11
12 #ifndef CHARITER_H
13 #define CHARITER_H
14
15 #include "unicode/utypes.h"
16 #include "unicode/uobject.h"
17 #include "unicode/unistr.h"
23 U_NAMESPACE_BEGIN
91 class U_COMMON_API ForwardCharacterIterator : public UObject {
92 public:
98 enum { DONE = 0xffff };
99
104 virtual ~ForwardCharacterIterator();
105
114 virtual UBool operator==(const ForwardCharacterIterator& that) const = 0;
115
126 inline UBool operator!=(const ForwardCharacterIterator& that) const;
127
133 virtual int32_t hashCode(void) const = 0;
134
142 virtual UClassID getDynamicClassID(void) const = 0;
143
152 virtual char16_t nextPostInc(void) = 0;
153
162 virtual UChar32 next32PostInc(void) = 0;
163
173 virtual UBool hasNext() = 0;
174
175 protected:
177 ForwardCharacterIterator();
178
180 ForwardCharacterIterator(const ForwardCharacterIterator &other);
181
186 ForwardCharacterIterator &operator=(const ForwardCharacterIterator&) { return *this; }
187 };
188
358 class U_COMMON_API CharacterIterator : public ForwardCharacterIterator {
359 public:
364 enum EOrigin { kStart, kCurrent, kEnd };
365
370 virtual ~CharacterIterator();
371
380 virtual CharacterIterator* clone(void) const = 0;
381
389 virtual char16_t first(void) = 0;
390
399 virtual char16_t firstPostInc(void);
400
410 virtual UChar32 first32(void) = 0;
411
420 virtual UChar32 first32PostInc(void);
421
429 inline int32_t setToStart();
430
438 virtual char16_t last(void) = 0;
439
447 virtual UChar32 last32(void) = 0;
448
456 inline int32_t setToEnd();
457
466 virtual char16_t setIndex(int32_t position) = 0;
467
479 virtual UChar32 setIndex32(int32_t position) = 0;
480
486 virtual char16_t current(void) const = 0;
487
493 virtual UChar32 current32(void) const = 0;
494
502 virtual char16_t next(void) = 0;
503
514 virtual UChar32 next32(void) = 0;
515
523 virtual char16_t previous(void) = 0;
524
532 virtual UChar32 previous32(void) = 0;
533
543 virtual UBool hasPrevious() = 0;
544
555 inline int32_t startIndex(void) const;
556
566 inline int32_t endIndex(void) const;
567
576 inline int32_t getIndex(void) const;
577
584 inline int32_t getLength() const;
585
597 virtual int32_t move(int32_t delta, EOrigin origin) = 0;
598
610 #ifdef move32
611 // One of the system headers right now is sometimes defining a conflicting macro we don't use
612 #undef move32
613 #endif
614 virtual int32_t move32(int32_t delta, EOrigin origin) = 0;
615
622 virtual void getText(UnicodeString& result) = 0;
623
624 protected:
629 CharacterIterator();
630
635 CharacterIterator(int32_t length);
636
641 CharacterIterator(int32_t length, int32_t position);
642
647 CharacterIterator(int32_t length, int32_t textBegin, int32_t textEnd, int32_t position);
648
655 CharacterIterator(const CharacterIterator &that);
656
664 CharacterIterator &operator=(const CharacterIterator &that);
665
671 int32_t textLength;
672
677 int32_t pos;
678
683 int32_t begin;
684
689 int32_t end;
690 };
691
692 inline UBool
693 ForwardCharacterIterator::operator!=(const ForwardCharacterIterator& that) const {
694 return !operator==(that);
695 }
696
697 inline int32_t
698 CharacterIterator::setToStart() {
699 return move(0, kStart);
700 }
701
702 inline int32_t
703 CharacterIterator::setToEnd() {
704 return move(0, kEnd);
705 }
706
707 inline int32_t
708 CharacterIterator::startIndex(void) const {
709 return begin;
710 }
711
712 inline int32_t
713 CharacterIterator::endIndex(void) const {
714 return end;
715 }
716
717 inline int32_t
718 CharacterIterator::getIndex(void) const {
719 return pos;
720 }
721
722 inline int32_t
723 CharacterIterator::getLength(void) const {
724 return textLength;
725 }
726
727 U_NAMESPACE_END
728 #endif
unistr.h
C++ API: Unicode String.
icu::operator==
U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)
Global operator == for StringPiece.
UClassID
void * UClassID
UClassID is used to identify classes without using the compiler&#39;s RTTI.
Definition: uobject.h:90
U_NAMESPACE_BEGIN
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:137
icu::CharacterIterator
Abstract class that defines an API for iteration on text objects.
Definition: chariter.h:358
icu::operator!=
UBool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:218
icu::CharacterIterator::textLength
int32_t textLength
Base class text length field.
Definition: chariter.h:671
UChar32
int32_t UChar32
Define UChar32 as a type for single Unicode code points.
Definition: umachine.h:389
icu::UObject::getDynamicClassID
virtual UClassID getDynamicClassID() const
ICU4C "poor man&#39;s RTTI", returns a UClassID for the actual ICU class.
icu::CharacterIterator::begin
int32_t begin
Base class field for the start of the iteration range.
Definition: chariter.h:683
uobject.h
C++ API: Common ICU base class UObject.
U_NAMESPACE_END
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:138
icu::CharacterIterator::pos
int32_t pos
Base class field for the current position.
Definition: chariter.h:677
icu::ForwardCharacterIterator
Abstract class that defines an API for forward-only iteration on text objects.
Definition: chariter.h:91
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
U_COMMON_API
#define U_COMMON_API
Set to export library symbols from inside the common library, and to import them from outside...
Definition: utypes.h:300
icu::UnicodeString
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:289
icu::ForwardCharacterIterator::operator=
ForwardCharacterIterator & operator=(const ForwardCharacterIterator &)
Assignment operator to be overridden in the implementing class.
Definition: chariter.h:186
icu::CharacterIterator::end
int32_t end
Base class field for the end of the iteration range.
Definition: chariter.h:689
icu::UObject
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:220
icu::CharacterIterator::EOrigin
EOrigin
Origin enumeration for the move() and move32() functions.
Definition: chariter.h:364
UBool
int8_t UBool
The ICU boolean type.
Definition: umachine.h:225