ICU 65.1 65.1

normlzr.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 * COPYRIGHT:
6 * Copyright (c) 1996-2015, International Business Machines Corporation and
7 * others. All Rights Reserved.
8 ********************************************************************
9 */
10
11 #ifndef NORMLZR_H
12 #define NORMLZR_H
13
14 #include "unicode/utypes.h"
15
16 #if U_SHOW_CPLUSPLUS_API
17
23 #if !UCONFIG_NO_NORMALIZATION
24
25 #include "unicode/chariter.h"
26 #include "unicode/normalizer2.h"
27 #include "unicode/unistr.h"
28 #include "unicode/unorm.h"
29 #include "unicode/uobject.h"
30
31 U_NAMESPACE_BEGIN
136 class U_COMMON_API Normalizer : public UObject {
137 public:
138 #ifndef U_HIDE_DEPRECATED_API
139
144 enum {
145 DONE=0xffff
146 };
147
148 // Constructors
149
160 Normalizer(const UnicodeString& str, UNormalizationMode mode);
161
173 Normalizer(ConstChar16Ptr str, int32_t length, UNormalizationMode mode);
174
185 Normalizer(const CharacterIterator& iter, UNormalizationMode mode);
186 #endif /* U_HIDE_DEPRECATED_API */
187
188 #ifndef U_FORCE_HIDE_DEPRECATED_API
189
194 Normalizer(const Normalizer& copy);
195
200 virtual ~Normalizer();
201 #endif // U_FORCE_HIDE_DEPRECATED_API
202
203 //-------------------------------------------------------------------------
204 // Static utility methods
205 //-------------------------------------------------------------------------
206
207 #ifndef U_HIDE_DEPRECATED_API
208
222 static void U_EXPORT2 normalize(const UnicodeString& source,
223 UNormalizationMode mode, int32_t options,
224 UnicodeString& result,
225 UErrorCode &status);
226
244 static void U_EXPORT2 compose(const UnicodeString& source,
245 UBool compat, int32_t options,
246 UnicodeString& result,
247 UErrorCode &status);
248
266 static void U_EXPORT2 decompose(const UnicodeString& source,
267 UBool compat, int32_t options,
268 UnicodeString& result,
269 UErrorCode &status);
270
291 static inline UNormalizationCheckResult
292 quickCheck(const UnicodeString &source, UNormalizationMode mode, UErrorCode &status);
293
307 static UNormalizationCheckResult
308 quickCheck(const UnicodeString &source, UNormalizationMode mode, int32_t options, UErrorCode &status);
309
330 static inline UBool
331 isNormalized(const UnicodeString &src, UNormalizationMode mode, UErrorCode &errorCode);
332
348 static UBool
349 isNormalized(const UnicodeString &src, UNormalizationMode mode, int32_t options, UErrorCode &errorCode);
350
380 static UnicodeString &
381 U_EXPORT2 concatenate(const UnicodeString &left, const UnicodeString &right,
382 UnicodeString &result,
383 UNormalizationMode mode, int32_t options,
384 UErrorCode &errorCode);
385 #endif /* U_HIDE_DEPRECATED_API */
386
451 static inline int32_t
452 compare(const UnicodeString &s1, const UnicodeString &s2,
453 uint32_t options,
454 UErrorCode &errorCode);
455
456 #ifndef U_HIDE_DEPRECATED_API
457 //-------------------------------------------------------------------------
458 // Iteration API
459 //-------------------------------------------------------------------------
460
469 UChar32 current(void);
470
479 UChar32 first(void);
480
489 UChar32 last(void);
490
505 UChar32 next(void);
506
521 UChar32 previous(void);
522
532 void setIndexOnly(int32_t index);
533
539 void reset(void);
540
555 int32_t getIndex(void) const;
556
565 int32_t startIndex(void) const;
566
577 int32_t endIndex(void) const;
578
587 UBool operator==(const Normalizer& that) const;
588
597 inline UBool operator!=(const Normalizer& that) const;
598
605 Normalizer* clone() const;
606
613 int32_t hashCode(void) const;
614
615 //-------------------------------------------------------------------------
616 // Property access methods
617 //-------------------------------------------------------------------------
618
634 void setMode(UNormalizationMode newMode);
635
646 UNormalizationMode getUMode(void) const;
647
664 void setOption(int32_t option,
665 UBool value);
666
677 UBool getOption(int32_t option) const;
678
687 void setText(const UnicodeString& newText,
688 UErrorCode &status);
689
698 void setText(const CharacterIterator& newText,
699 UErrorCode &status);
700
710 void setText(ConstChar16Ptr newText,
711 int32_t length,
712 UErrorCode &status);
719 void getText(UnicodeString& result);
720
726 static UClassID U_EXPORT2 getStaticClassID();
727 #endif /* U_HIDE_DEPRECATED_API */
728
729 #ifndef U_FORCE_HIDE_DEPRECATED_API
730
735 virtual UClassID getDynamicClassID() const;
736 #endif // U_FORCE_HIDE_DEPRECATED_API
737
738 private:
739 //-------------------------------------------------------------------------
740 // Private functions
741 //-------------------------------------------------------------------------
742
743 Normalizer(); // default constructor not implemented
744 Normalizer &operator=(const Normalizer &that); // assignment operator not implemented
745
746 // Private utility methods for iteration
747 // For documentation, see the source code
748 UBool nextNormalize();
749 UBool previousNormalize();
750
751 void init();
752 void clearBuffer(void);
753
754 //-------------------------------------------------------------------------
755 // Private data
756 //-------------------------------------------------------------------------
757
758 FilteredNormalizer2*fFilteredNorm2; // owned if not NULL
759 const Normalizer2 *fNorm2; // not owned; may be equal to fFilteredNorm2
760 UNormalizationMode fUMode; // deprecated
761 int32_t fOptions;
762
763 // The input text and our position in it
764 CharacterIterator *text;
765
766 // The normalization buffer is the result of normalization
767 // of the source in [currentIndex..nextIndex[ .
768 int32_t currentIndex, nextIndex;
769
770 // A buffer for holding intermediate results
771 UnicodeString buffer;
772 int32_t bufferPos;
773 };
774
775 //-------------------------------------------------------------------------
776 // Inline implementations
777 //-------------------------------------------------------------------------
778
779 #ifndef U_HIDE_DEPRECATED_API
780 inline UBool
781 Normalizer::operator!= (const Normalizer& other) const
782 { return ! operator==(other); }
783
784 inline UNormalizationCheckResult
785 Normalizer::quickCheck(const UnicodeString& source,
786 UNormalizationMode mode,
787 UErrorCode &status) {
788 return quickCheck(source, mode, 0, status);
789 }
790
791 inline UBool
792 Normalizer::isNormalized(const UnicodeString& source,
793 UNormalizationMode mode,
794 UErrorCode &status) {
795 return isNormalized(source, mode, 0, status);
796 }
797 #endif /* U_HIDE_DEPRECATED_API */
798
799 inline int32_t
800 Normalizer::compare(const UnicodeString &s1, const UnicodeString &s2,
801 uint32_t options,
802 UErrorCode &errorCode) {
803 // all argument checking is done in unorm_compare
804 return unorm_compare(toUCharPtr(s1.getBuffer()), s1.length(),
805 toUCharPtr(s2.getBuffer()), s2.length(),
806 options,
807 &errorCode);
808 }
809
810 U_NAMESPACE_END
811
812 #endif /* #if !UCONFIG_NO_NORMALIZATION */
813
814 #endif // NORMLZR_H
815
816 #endif /* U_SHOW_CPLUSPLUS_API */
icu::Normalizer::isNormalized
static UBool isNormalized(const UnicodeString &src, UNormalizationMode mode, UErrorCode &errorCode)
Test if a string is in a given normalization form.
Definition: normlzr.h:792
icu::Normalizer::quickCheck
static UNormalizationCheckResult quickCheck(const UnicodeString &source, UNormalizationMode mode, UErrorCode &status)
Performing quick check on a string, to quickly determine if the string is in a particular normalizati...
Definition: normlzr.h:785
unorm_compare
int32_t unorm_compare(const UChar *s1, int32_t length1, const UChar *s2, int32_t length2, uint32_t options, UErrorCode *pErrorCode)
Compares two strings for canonical equivalence.
icu::Normalizer::compare
static int32_t compare(const UnicodeString &s1, const UnicodeString &s2, uint32_t options, UErrorCode &errorCode)
Compare two strings for canonical equivalence.
Definition: normlzr.h:800
UNormalizationMode
UNormalizationMode
Constants for normalization modes.
Definition: unorm.h:140
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:96
normalizer2.h
C++ API: New API for Unicode Normalization.
icu::Normalizer2
Unicode normalization functionality for standard Unicode normalization or for using custom mapping ta...
Definition: normalizer2.h:85
icu::CharacterIterator
Abstract class that defines an API for iteration on text objects.
Definition: chariter.h:361
icu::operator!=
UBool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:251
unorm.h
C API: Unicode Normalization.
UChar32
int32_t UChar32
Define UChar32 as a type for single Unicode code points.
Definition: umachine.h:425
icu::UObject::getDynamicClassID
virtual UClassID getDynamicClassID() const
ICU4C "poor man&#39;s RTTI", returns a UClassID for the actual ICU class.
icu::toUCharPtr
const UChar * toUCharPtr(const char16_t *p)
Converts from const char16_t * to const UChar *.
Definition: char16ptr.h:260
icu::Normalizer
Old Unicode normalization API.
Definition: normlzr.h:136
uobject.h
C++ API: Common ICU base class UObject.
UErrorCode
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition: utypes.h:415
icu::UnicodeString::length
int32_t length(void) const
Return the length of the UnicodeString object.
Definition: unistr.h:3890
icu::ConstChar16Ptr
const char16_t * wrapper with implicit conversion from distinct but bit-compatible pointer types...
Definition: char16ptr.h:149
icu::UnicodeString::getBuffer
char16_t * getBuffer(int32_t minCapacity)
Get a read/write pointer to the internal buffer.
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:294
chariter.h
C++ API: Character Iterator.
icu::Normalizer::operator!=
UBool operator!=(const Normalizer &that) const
Returns FALSE when both iterators refer to the same character in the same input text.
Definition: normlzr.h:781
icu::UObject
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:223
icu::FilteredNormalizer2
Normalization filtered by a UnicodeSet.
Definition: normalizer2.h:503
UNormalizationCheckResult
UNormalizationCheckResult
Result values for normalization quick check functions.
Definition: unorm2.h:94
UBool
int8_t UBool
The ICU boolean type.
Definition: umachine.h:261