icuSources/i18n/utf16collationiterator.h

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2010-2014, International Business Machines
   6 * Corporation and others.  All Rights Reserved.
   7 *******************************************************************************
   8 * utf16collationiterator.h
   9 *
  10 * created on: 2010oct27
  11 * created by: Markus W. Scherer
  12 */
  13
  14 #ifndef __UTF16COLLATIONITERATOR_H__
  15 #define __UTF16COLLATIONITERATOR_H__
  16
  17 #include "unicode/utypes.h"
  18
  19 #if !UCONFIG_NO_COLLATION
  20
  21 #include "cmemory.h"
  22 #include "collation.h"
  23 #include "collationdata.h"
  24 #include "collationiterator.h"
  25 #include "normalizer2impl.h"
  26
  27 U_NAMESPACE_BEGIN
  28
  29 /**
  30  * UTF-16 collation element and character iterator.
  31  * Handles normalized UTF-16 text inline, with length or NUL-terminated.
  32  * Unnormalized text is handled by a subclass.
  33  */
  34 class U_I18N_API UTF16CollationIterator : public CollationIterator {
  35 public:
  36     UTF16CollationIterator(const CollationData *d, UBool numeric,
  37                            const UChar *s, const UChar *p, const UChar *lim)
  38             : CollationIterator(d, numeric),
  39               start(s), pos(p), limit(lim) {}
  40
  41     UTF16CollationIterator(const UTF16CollationIterator &other, const UChar *newText);
  42
  43     virtual ~UTF16CollationIterator();
  44
  45     virtual UBool operator==(const CollationIterator &other) const;
  46
  47     virtual void resetToOffset(int32_t newOffset);
  48
  49     virtual int32_t getOffset() const;
  50
  51     void setText(const UChar *s, const UChar *lim) {
  52         reset();
  53         start = pos = s;
  54         limit = lim;
  55     }
  56
  57     virtual UChar32 nextCodePoint(UErrorCode &errorCode);
  58
  59     virtual UChar32 previousCodePoint(UErrorCode &errorCode);
  60
  61 protected:
  62     // Copy constructor only for subclasses which set the pointers.
  63     UTF16CollationIterator(const UTF16CollationIterator &other)
  64             : CollationIterator(other),
  65               start(NULL), pos(NULL), limit(NULL) {}
  66
  67     virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
  68
  69     virtual UChar handleGetTrailSurrogate();
  70
  71     virtual UBool foundNULTerminator();
  72
  73     virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
  74
  75     virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
  76
  77     // UTF-16 string pointers.
  78     // limit can be NULL for NUL-terminated strings.
  79     const UChar *start, *pos, *limit;
  80 };
  81
  82 /**
  83  * Incrementally checks the input text for FCD and normalizes where necessary.
  84  */
  85 class U_I18N_API FCDUTF16CollationIterator : public UTF16CollationIterator {
  86 public:
  87     FCDUTF16CollationIterator(const CollationData *data, UBool numeric,
  88                               const UChar *s, const UChar *p, const UChar *lim)
  89             : UTF16CollationIterator(data, numeric, s, p, lim),
  90               rawStart(s), segmentStart(p), segmentLimit(NULL), rawLimit(lim),
  91               nfcImpl(data->nfcImpl),
  92               checkDir(1) {}
  93
  94     FCDUTF16CollationIterator(const FCDUTF16CollationIterator &other, const UChar *newText);
  95
  96     virtual ~FCDUTF16CollationIterator();
  97
  98     virtual UBool operator==(const CollationIterator &other) const;
  99
 100     virtual void resetToOffset(int32_t newOffset);
 101
 102     virtual int32_t getOffset() const;
 103
 104     virtual UChar32 nextCodePoint(UErrorCode &errorCode);
 105
 106     virtual UChar32 previousCodePoint(UErrorCode &errorCode);
 107
 108 protected:
 109     virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
 110
 111     virtual UBool foundNULTerminator();
 112
 113     virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
 114
 115     virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
 116
 117 private:
 118     /**
 119      * Switches to forward checking if possible.
 120      * To be called when checkDir < 0 || (checkDir == 0 && pos == limit).
 121      * Returns with checkDir > 0 || (checkDir == 0 && pos != limit).
 122      */
 123     void switchToForward();
 124
 125     /**
 126      * Extend the FCD text segment forward or normalize around pos.
 127      * To be called when checkDir > 0 && pos != limit.
 128      * @return TRUE if success, checkDir == 0 and pos != limit
 129      */
 130     UBool nextSegment(UErrorCode &errorCode);
 131
 132     /**
 133      * Switches to backward checking.
 134      * To be called when checkDir > 0 || (checkDir == 0 && pos == start).
 135      * Returns with checkDir < 0 || (checkDir == 0 && pos != start).
 136      */
 137     void switchToBackward();
 138
 139     /**
 140      * Extend the FCD text segment backward or normalize around pos.
 141      * To be called when checkDir < 0 && pos != start.
 142      * @return TRUE if success, checkDir == 0 and pos != start
 143      */
 144     UBool previousSegment(UErrorCode &errorCode);
 145
 146     UBool normalize(const UChar *from, const UChar *to, UErrorCode &errorCode);
 147
 148     // Text pointers: The input text is [rawStart, rawLimit[
 149     // where rawLimit can be NULL for NUL-terminated text.
 150     //
 151     // checkDir > 0:
 152     //
 153     // The input text [segmentStart..pos[ passes the FCD check.
 154     // Moving forward checks incrementally.
 155     // segmentLimit is undefined. limit == rawLimit.
 156     //
 157     // checkDir < 0:
 158     // The input text [pos..segmentLimit[ passes the FCD check.
 159     // Moving backward checks incrementally.
 160     // segmentStart is undefined, start == rawStart.
 161     //
 162     // checkDir == 0:
 163     //
 164     // The input text [segmentStart..segmentLimit[ is being processed.
 165     // These pointers are at FCD boundaries.
 166     // Either this text segment already passes the FCD check
 167     // and segmentStart==start<=pos<=limit==segmentLimit,
 168     // or the current segment had to be normalized so that
 169     // [segmentStart..segmentLimit[ turned into the normalized string,
 170     // corresponding to normalized.getBuffer()==start<=pos<=limit==start+normalized.length().
 171     const UChar *rawStart;
 172     const UChar *segmentStart;
 173     const UChar *segmentLimit;
 174     // rawLimit==NULL for a NUL-terminated string.
 175     const UChar *rawLimit;
 176
 177     const Normalizer2Impl &nfcImpl;
 178     UnicodeString normalized;
 179     // Direction of incremental FCD check. See comments before rawStart.
 180     int8_t checkDir;
 181 };
 182
 183 U_NAMESPACE_END
 184
 185 #endif  // !UCONFIG_NO_COLLATION
 186 #endif  // __UTF16COLLATIONITERATOR_H__