Movatterモバイル変換


[0]ホーム

URL:


ICU 78.1  78.1
coll.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 (C) 1996-2016, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 ******************************************************************************
8 */
9 
52 #ifndef COLL_H
53 #define COLL_H
54 
55 #include "unicode/utypes.h"
56 
57 #if U_SHOW_CPLUSPLUS_API
58 
59 #if !UCONFIG_NO_COLLATION
60 
61 #include <functional>
62 #include <string_view>
63 #include <type_traits>
64 
65 #include "unicode/char16ptr.h"
66 #include "unicode/uobject.h"
67 #include "unicode/ucol.h"
68 #include "unicode/unorm.h"
69 #include "unicode/locid.h"
70 #include "unicode/uniset.h"
71 #include "unicode/umisc.h"
72 #include "unicode/unistr.h"
73 #include "unicode/uiter.h"
74 #include "unicode/stringpiece.h"
75 
76 U_NAMESPACE_BEGIN
77 
78 classStringEnumeration;
79 
80 #if !UCONFIG_NO_SERVICE
84 classCollatorFactory;
85 #endif
86 
90 classCollationKey;
91 
173 classU_I18N_APICollator :publicUObject {
174 public:
175 
176 // Collator public enums -----------------------------------------------
177 
203 enumECollationStrength
204  {
205  PRIMARY =UCOL_PRIMARY,// 0
206  SECONDARY =UCOL_SECONDARY,// 1
207  TERTIARY =UCOL_TERTIARY,// 2
208  QUATERNARY =UCOL_QUATERNARY,// 3
209  IDENTICAL =UCOL_IDENTICAL// 15
210  };
211 
212 
213 // Cannot use #ifndef U_HIDE_DEPRECATED_API for the following, it is
214 // used by virtual methods that cannot have that conditional.
215 #ifndef U_FORCE_HIDE_DEPRECATED_API
226 enumEComparisonResult
227  {
228  LESS =UCOL_LESS,// -1
229  EQUAL =UCOL_EQUAL,// 0
230  GREATER =UCOL_GREATER// 1
231  };
232 #endif// U_FORCE_HIDE_DEPRECATED_API
233 
234 // Collator public destructor -----------------------------------------
235 
240 virtual~Collator();
241 
242 // Collator public methods --------------------------------------------
243 
262 virtualbooloperator==(constCollator& other)const;
263 
271 virtualbooloperator!=(constCollator& other)const;
272 
278 virtualCollator*clone()const = 0;
279 
299 staticCollator* U_EXPORT2createInstance(UErrorCode& err);
300 
334 staticCollator* U_EXPORT2createInstance(constLocale& loc,UErrorCode& err);
335 
336 #ifndef U_FORCE_HIDE_DEPRECATED_API
348 virtualEComparisonResultcompare(constUnicodeString& source,
349 constUnicodeString& target)const;
350 #endif// U_FORCE_HIDE_DEPRECATED_API
351 
364 virtualUCollationResultcompare(constUnicodeString& source,
365 constUnicodeString& target,
366 UErrorCode &status)const = 0;
367 
368 #ifndef U_FORCE_HIDE_DEPRECATED_API
381 virtualEComparisonResultcompare(constUnicodeString& source,
382 constUnicodeString& target,
383  int32_t length)const;
384 #endif// U_FORCE_HIDE_DEPRECATED_API
385 
399 virtualUCollationResultcompare(constUnicodeString& source,
400 constUnicodeString& target,
401  int32_t length,
402 UErrorCode &status)const = 0;
403 
404 #ifndef U_FORCE_HIDE_DEPRECATED_API
438 virtualEComparisonResultcompare(const char16_t* source, int32_t sourceLength,
439 const char16_t* target, int32_t targetLength)
440 const;
441 #endif// U_FORCE_HIDE_DEPRECATED_API
442 
459 virtualUCollationResultcompare(const char16_t* source, int32_t sourceLength,
460 const char16_t* target, int32_t targetLength,
461 UErrorCode &status)const = 0;
462 
474 virtualUCollationResultcompare(UCharIterator &sIter,
475 UCharIterator &tIter,
476 UErrorCode &status)const;
477 
491 virtualUCollationResultcompareUTF8(constStringPiece &source,
492 constStringPiece &target,
493 UErrorCode &status)const;
494 
513 virtualCollationKey&getCollationKey(constUnicodeString& source,
514 CollationKey& key,
515 UErrorCode& status)const = 0;
516 
536 virtualCollationKey&getCollationKey(const char16_t*source,
537  int32_t sourceLength,
538 CollationKey& key,
539 UErrorCode& status)const = 0;
544 virtual int32_thashCode()const = 0;
545 
546 #ifndef U_FORCE_HIDE_DEPRECATED_API
559 virtualLocalegetLocale(ULocDataLocaleType type,UErrorCode& status)const = 0;
560 #endif// U_FORCE_HIDE_DEPRECATED_API
561 
571 UBoolgreater(constUnicodeString& source,constUnicodeString& target)
572 const;
573 
583 UBoolgreaterOrEqual(constUnicodeString& source,
584 constUnicodeString& target)const;
585 
595 UBoolequals(constUnicodeString& source,constUnicodeString& target)const;
596 
602 inlineautoequal_to() const{return Predicate<std::equal_to, UCOL_EQUAL>(*this); }
603 
609 inlineautogreater() const{return Predicate<std::equal_to, UCOL_GREATER>(*this); }
610 
616 inlineautoless() const{return Predicate<std::equal_to, UCOL_LESS>(*this); }
617 
623 inlineautonot_equal_to() const{return Predicate<std::not_equal_to, UCOL_EQUAL>(*this); }
624 
630 inlineautogreater_equal() const{return Predicate<std::not_equal_to, UCOL_LESS>(*this); }
631 
637 inlineautoless_equal() const{return Predicate<std::not_equal_to, UCOL_GREATER>(*this); }
638 
639 #ifndef U_FORCE_HIDE_DEPRECATED_API
650 virtualECollationStrengthgetStrength()const;
651 
670 virtualvoidsetStrength(ECollationStrength newStrength);
671 #endif// U_FORCE_HIDE_DEPRECATED_API
672 
688 virtual int32_tgetReorderCodes(int32_t *dest,
689  int32_t destCapacity,
690 UErrorCode& status)const;
691 
707 virtualvoidsetReorderCodes(const int32_t* reorderCodes,
708  int32_t reorderCodesLength,
709 UErrorCode& status) ;
710 
731 static int32_t U_EXPORT2getEquivalentReorderCodes(int32_t reorderCode,
732  int32_t* dest,
733  int32_t destCapacity,
734 UErrorCode& status);
735 
745 staticUnicodeString& U_EXPORT2getDisplayName(constLocale& objectLocale,
746 constLocale& displayLocale,
747 UnicodeString& name);
748 
757 staticUnicodeString& U_EXPORT2getDisplayName(constLocale& objectLocale,
758 UnicodeString& name);
759 
771 staticconstLocale* U_EXPORT2getAvailableLocales(int32_t& count);
772 
781 staticStringEnumeration* U_EXPORT2getAvailableLocales();
782 
792 staticStringEnumeration* U_EXPORT2getKeywords(UErrorCode& status);
793 
805 staticStringEnumeration* U_EXPORT2getKeywordValues(constchar *keyword,UErrorCode& status);
806 
823 staticStringEnumeration* U_EXPORT2getKeywordValuesForLocale(constchar* keyword,constLocale& locale,
824 UBool commonlyUsed,UErrorCode& status);
825 
853 staticLocale U_EXPORT2getFunctionalEquivalent(constchar* keyword,constLocale& locale,
854 UBool& isAvailable,UErrorCode& status);
855 
856 #if !UCONFIG_NO_SERVICE
868 staticURegistryKey U_EXPORT2registerInstance(Collator* toAdopt,constLocale& locale,UErrorCode& status);
869 
880 staticURegistryKey U_EXPORT2registerFactory(CollatorFactory* toAdopt,UErrorCode& status);
881 
895 staticUBool U_EXPORT2unregister(URegistryKey key,UErrorCode& status);
896 #endif/* UCONFIG_NO_SERVICE */
897 
903 virtualvoidgetVersion(UVersionInfo info)const = 0;
904 
915 virtualUClassIDgetDynamicClassID()const override = 0;
916 
925 virtualvoidsetAttribute(UColAttribute attr,UColAttributeValue value,
926 UErrorCode &status) = 0;
927 
936 virtualUColAttributeValuegetAttribute(UColAttribute attr,
937 UErrorCode &status)const = 0;
938 
957 virtualCollator &setMaxVariable(UColReorderCode group,UErrorCode &errorCode);
958 
967 virtualUColReorderCodegetMaxVariable()const;
968 
969 #ifndef U_FORCE_HIDE_DEPRECATED_API
986 virtual uint32_tsetVariableTop(const char16_t *varTop, int32_t len,UErrorCode &status) = 0;
987 
1003 virtual uint32_tsetVariableTop(constUnicodeString &varTop,UErrorCode &status) = 0;
1004 
1016 virtualvoidsetVariableTop(uint32_t varTop,UErrorCode &status) = 0;
1017 #endif// U_FORCE_HIDE_DEPRECATED_API
1018 
1026 virtual uint32_tgetVariableTop(UErrorCode &status)const = 0;
1027 
1037 virtualUnicodeSet *getTailoredSet(UErrorCode &status)const;
1038 
1039 #ifndef U_FORCE_HIDE_DEPRECATED_API
1047 virtualCollator*safeClone()const;
1048 #endif// U_FORCE_HIDE_DEPRECATED_API
1049 
1066 virtual int32_tgetSortKey(constUnicodeString& source,
1067  uint8_t* result,
1068  int32_t resultLength)const = 0;
1069 
1089 virtual int32_tgetSortKey(const char16_t*source, int32_t sourceLength,
1090  uint8_t*result, int32_t resultLength)const = 0;
1091 
1129 static int32_t U_EXPORT2getBound(const uint8_t *source,
1130  int32_t sourceLength,
1131 UColBoundMode boundType,
1132  uint32_t noOfLevels,
1133  uint8_t *result,
1134  int32_t resultLength,
1135 UErrorCode &status);
1136 
1137 
1138 protected:
1139 
1140 // Collator protected constructors -------------------------------------
1141 
1149 Collator();
1150 
1151 #ifndef U_HIDE_DEPRECATED_API
1163 Collator(UCollationStrength collationStrength,
1164 UNormalizationMode decompositionMode);
1165 #endif/* U_HIDE_DEPRECATED_API */
1166 
1172 Collator(constCollator& other);
1173 
1174 public:
1182 virtualvoidsetLocales(constLocale& requestedLocale,constLocale& validLocale,constLocale& actualLocale);
1183 
1207 virtual int32_tinternalGetShortDefinitionString(constchar *locale,
1208 char *buffer,
1209  int32_t capacity,
1210 UErrorCode &status)const;
1211 
1216 virtualUCollationResultinternalCompareUTF8(
1217 constchar *left, int32_t leftLength,
1218 constchar *right, int32_t rightLength,
1219 UErrorCode &errorCode)const;
1220 
1225 virtual int32_t
1226 internalNextSortKeyPart(
1227 UCharIterator *iter, uint32_t state[2],
1228  uint8_t *dest, int32_t count,UErrorCode &errorCode)const;
1229 
1230 #ifndef U_HIDE_INTERNAL_API
1232 staticinlineCollator *fromUCollator(UCollator *uc) {
1233 returnreinterpret_cast<Collator *>(uc);
1234  }
1236 staticinlineconstCollator *fromUCollator(constUCollator *uc) {
1237 returnreinterpret_cast<constCollator *>(uc);
1238  }
1240 inlineUCollator *toUCollator() {
1241 returnreinterpret_cast<UCollator *>(this);
1242  }
1244 inlineconstUCollator *toUCollator() const{
1245 returnreinterpret_cast<constUCollator *>(this);
1246  }
1247 #endif// U_HIDE_INTERNAL_API
1248 
1249 private:
1253 Collator& operator=(constCollator& other) =delete;
1254 
1255 friendclassCFactory;
1256 friendclassSimpleCFactory;
1257 friendclassICUCollatorFactory;
1258 friendclassICUCollatorService;
1259 staticCollator* makeInstance(constLocale& desiredLocale,
1260 UErrorCode& status);
1261 
1266 template <template <typename...>typename Compare,UCollationResult result>
1267 classPredicate {
1268 public:
1269 explicit Predicate(constCollator& parent) : collator(parent) {}
1270 
1271 template <
1272 typename T,typename U,
1273 typename = std::enable_if_t<ConvertibleToU16StringView<T> && ConvertibleToU16StringView<U>>>
1274 bool operator()(const T& lhs,const U& rhs) const{
1275 UErrorCode status =U_ZERO_ERROR;
1276 return compare(
1277  collator.compare(
1278  UnicodeString::readOnlyAlias(lhs),
1279  UnicodeString::readOnlyAlias(rhs),
1280  status),
1281  result);
1282  }
1283 
1284 bool operator()(std::string_view lhs, std::string_view rhs) const{
1285 UErrorCode status =U_ZERO_ERROR;
1286 return compare(collator.compareUTF8(lhs, rhs, status), result);
1287  }
1288 
1289 #if defined(__cpp_char8_t)
1290 bool operator()(std::u8string_view lhs, std::u8string_view rhs) const{
1291 UErrorCode status =U_ZERO_ERROR;
1292 return compare(collator.compareUTF8(lhs, rhs, status), result);
1293  }
1294 #endif
1295 
1296 private:
1297 const Collator& collator;
1298 static constexpr Compare<UCollationResult> compare{};
1299  };
1300 };
1301 
1302 #if !UCONFIG_NO_SERVICE
1319 classU_I18N_APICollatorFactory :publicUObject {
1320 public:
1321 
1326 virtual~CollatorFactory();
1327 
1335 virtualUBoolvisible()const;
1336 
1344 virtualCollator*createCollator(constLocale& loc) = 0;
1345 
1356 virtualUnicodeString&getDisplayName(constLocale& objectLocale,
1357 constLocale& displayLocale,
1358 UnicodeString& result);
1359 
1369 virtualconstUnicodeString *getSupportedIDs(int32_t &count,UErrorCode& status) = 0;
1370 };
1371 #endif/* UCONFIG_NO_SERVICE */
1372 
1373 // Collator inline methods -----------------------------------------------
1374 
1375 U_NAMESPACE_END
1376 
1377 #endif/* #if !UCONFIG_NO_COLLATION */
1378 
1379 #endif/* U_SHOW_CPLUSPLUS_API */
1380 
1381 #endif
char16ptr.h
C++ API: char16_t pointer wrappers with implicit conversion from bit-compatible raw pointer types.
icu::CollationKey
Collation keys are generated by the Collator class.
Definition:sortkey.h:101
icu::CollatorFactory
A factory, used with registerFactory, the creates multiple collators and provides display names for t...
Definition:coll.h:1319
icu::CollatorFactory::getSupportedIDs
virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode &status)=0
Return an array of all the locale names directly supported by this factory.
icu::CollatorFactory::getDisplayName
virtual UnicodeString & getDisplayName(const Locale &objectLocale, const Locale &displayLocale, UnicodeString &result)
Return the name of the collator for the objectLocale, localized for the displayLocale.
icu::CollatorFactory::visible
virtual UBool visible() const
Return true if this factory is visible.
icu::CollatorFactory::createCollator
virtual Collator * createCollator(const Locale &loc)=0
Return a collator for the provided locale.
icu::CollatorFactory::~CollatorFactory
virtual ~CollatorFactory()
Destructor.
icu::Collator
The Collator class performs locale-sensitive string comparison.
Definition:coll.h:173
icu::Collator::internalCompareUTF8
virtual UCollationResult internalCompareUTF8(const char *left, int32_t leftLength, const char *right, int32_t rightLength, UErrorCode &errorCode) const
Implements ucol_strcollUTF8().
icu::Collator::registerInstance
static URegistryKey registerInstance(Collator *toAdopt, const Locale &locale, UErrorCode &status)
Register a new Collator.
icu::Collator::clone
virtual Collator * clone() const =0
Makes a copy of this object.
icu::Collator::getDisplayName
static UnicodeString & getDisplayName(const Locale &objectLocale, UnicodeString &name)
Get name of the object for the desired Locale, in the language of the default locale.
icu::Collator::getStrength
virtual ECollationStrength getStrength() const
Determines the minimum strength that will be used in comparison or transformation.
icu::Collator::getAvailableLocales
static StringEnumeration * getAvailableLocales()
Return a StringEnumeration over the locales available at the time of the call, including registered l...
icu::Collator::equals
UBool equals(const UnicodeString &source, const UnicodeString &target) const
Convenience method for comparing two strings based on the collation rules.
icu::Collator::getKeywords
static StringEnumeration * getKeywords(UErrorCode &status)
Create a string enumerator of all possible keywords that are relevant to collation.
icu::Collator::toUCollator
const UCollator * toUCollator() const
Definition:coll.h:1244
icu::Collator::getVersion
virtual void getVersion(UVersionInfo info) const =0
Gets the version information for a Collator.
icu::Collator::safeClone
virtual Collator * safeClone() const
Same as clone().
icu::Collator::operator==
virtual bool operator==(const Collator &other) const
Returns true if "other" is the same as "this".
icu::Collator::less
auto less() const
Creates a comparison function object that uses this collator.
Definition:coll.h:616
icu::Collator::getCollationKey
virtual CollationKey & getCollationKey(const char16_t *source, int32_t sourceLength, CollationKey &key, UErrorCode &status) const =0
Transforms the string into a series of characters that can be compared with CollationKey::compareTo.
icu::Collator::getFunctionalEquivalent
static Locale getFunctionalEquivalent(const char *keyword, const Locale &locale, UBool &isAvailable, UErrorCode &status)
Return the functionally equivalent locale for the given requested locale, with respect to given keywo...
icu::Collator::Collator
Collator()
Default constructor.
icu::Collator::compare
virtual EComparisonResult compare(const UnicodeString &source, const UnicodeString &target) const
The comparison function compares the character data stored in two different strings.
icu::Collator::setLocales
virtual void setLocales(const Locale &requestedLocale, const Locale &validLocale, const Locale &actualLocale)
Used internally by registration to define the requested and valid locales.
icu::Collator::less_equal
auto less_equal() const
Creates a comparison function object that uses this collator.
Definition:coll.h:637
icu::Collator::getKeywordValues
static StringEnumeration * getKeywordValues(const char *keyword, UErrorCode &status)
Given a keyword, create a string enumeration of all values for that keyword that are currently in use...
icu::Collator::setAttribute
virtual void setAttribute(UColAttribute attr, UColAttributeValue value, UErrorCode &status)=0
Universal attribute setter.
icu::Collator::getDynamicClassID
virtual UClassID getDynamicClassID() const override=0
Returns a unique class ID POLYMORPHICALLY.
icu::Collator::createInstance
static Collator * createInstance(UErrorCode &err)
Creates the Collator object for the current default locale.
icu::Collator::greaterOrEqual
UBool greaterOrEqual(const UnicodeString &source, const UnicodeString &target) const
Convenience method for comparing two strings based on the collation rules.
icu::Collator::getSortKey
virtual int32_t getSortKey(const UnicodeString &source, uint8_t *result, int32_t resultLength) const =0
Get the sort key as an array of bytes from a UnicodeString.
icu::Collator::getTailoredSet
virtual UnicodeSet * getTailoredSet(UErrorCode &status) const
Get a UnicodeSet that contains all the characters and sequences tailored in this collator.
icu::Collator::compareUTF8
virtual UCollationResult compareUTF8(const StringPiece &source, const StringPiece &target, UErrorCode &status) const
Compares two UTF-8 strings using the Collator.
icu::Collator::greater
UBool greater(const UnicodeString &source, const UnicodeString &target) const
Convenience method for comparing two strings based on the collation rules.
icu::Collator::getVariableTop
virtual uint32_t getVariableTop(UErrorCode &status) const =0
Gets the variable top value of a Collator.
icu::Collator::setStrength
virtual void setStrength(ECollationStrength newStrength)
Sets the minimum strength to be used in comparison or transformation.
icu::Collator::getBound
static int32_t getBound(const uint8_t *source, int32_t sourceLength, UColBoundMode boundType, uint32_t noOfLevels, uint8_t *result, int32_t resultLength, UErrorCode &status)
Produce a bound for a given sortkey and a number of levels.
icu::Collator::compare
virtual UCollationResult compare(const char16_t *source, int32_t sourceLength, const char16_t *target, int32_t targetLength, UErrorCode &status) const =0
The comparison function compares the character data stored in two different string arrays.
icu::Collator::equal_to
auto equal_to() const
Creates a comparison function object that uses this collator.
Definition:coll.h:602
icu::Collator::fromUCollator
static Collator * fromUCollator(UCollator *uc)
Definition:coll.h:1232
icu::Collator::getReorderCodes
virtual int32_t getReorderCodes(int32_t *dest, int32_t destCapacity, UErrorCode &status) const
Retrieves the reordering codes for this collator.
icu::Collator::toUCollator
UCollator * toUCollator()
Definition:coll.h:1240
icu::Collator::setVariableTop
virtual uint32_t setVariableTop(const UnicodeString &varTop, UErrorCode &status)=0
Sets the variable top to the primary weight of the specified string.
icu::Collator::ECollationStrength
ECollationStrength
Base letter represents a primary difference.
Definition:coll.h:204
icu::Collator::compare
virtual UCollationResult compare(const UnicodeString &source, const UnicodeString &target, UErrorCode &status) const =0
The comparison function compares the character data stored in two different strings.
icu::Collator::compare
virtual UCollationResult compare(UCharIterator &sIter, UCharIterator &tIter, UErrorCode &status) const
Compares two strings using the Collator.
icu::Collator::getKeywordValuesForLocale
static StringEnumeration * getKeywordValuesForLocale(const char *keyword, const Locale &locale, UBool commonlyUsed, UErrorCode &status)
Given a key and a locale, returns an array of string values in a preferred order that would make a di...
icu::Collator::greater_equal
auto greater_equal() const
Creates a comparison function object that uses this collator.
Definition:coll.h:630
icu::Collator::not_equal_to
auto not_equal_to() const
Creates a comparison function object that uses this collator.
Definition:coll.h:623
icu::Collator::hashCode
virtual int32_t hashCode() const =0
Generates the hash code for the collation object.
icu::Collator::registerFactory
static URegistryKey registerFactory(CollatorFactory *toAdopt, UErrorCode &status)
Register a new CollatorFactory.
icu::Collator::Collator
Collator(UCollationStrength collationStrength, UNormalizationMode decompositionMode)
Constructor.
icu::Collator::fromUCollator
static const Collator * fromUCollator(const UCollator *uc)
Definition:coll.h:1236
icu::Collator::~Collator
virtual ~Collator()
Destructor.
icu::Collator::internalNextSortKeyPart
virtual int32_t internalNextSortKeyPart(UCharIterator *iter, uint32_t state[2], uint8_t *dest, int32_t count, UErrorCode &errorCode) const
Implements ucol_nextSortKeyPart().
icu::Collator::getLocale
virtual Locale getLocale(ULocDataLocaleType type, UErrorCode &status) const =0
Gets the locale of the Collator.
icu::Collator::getAttribute
virtual UColAttributeValue getAttribute(UColAttribute attr, UErrorCode &status) const =0
Universal attribute getter.
icu::Collator::compare
virtual EComparisonResult compare(const char16_t *source, int32_t sourceLength, const char16_t *target, int32_t targetLength) const
The comparison function compares the character data stored in two different string arrays.
icu::Collator::getMaxVariable
virtual UColReorderCode getMaxVariable() const
Returns the maximum reordering group whose characters are affected by UCOL_ALTERNATE_HANDLING.
icu::Collator::greater
auto greater() const
Creates a comparison function object that uses this collator.
Definition:coll.h:609
icu::Collator::setMaxVariable
virtual Collator & setMaxVariable(UColReorderCode group, UErrorCode &errorCode)
Sets the variable top to the top of the specified reordering group.
icu::Collator::getSortKey
virtual int32_t getSortKey(const char16_t *source, int32_t sourceLength, uint8_t *result, int32_t resultLength) const =0
Get the sort key as an array of bytes from a char16_t buffer.
icu::Collator::EComparisonResult
EComparisonResult
LESS is returned if source string is compared to be less than target string in the compare() method.
Definition:coll.h:227
icu::Collator::operator!=
virtual bool operator!=(const Collator &other) const
Returns true if "other" is not the same as "this".
icu::Collator::setReorderCodes
virtual void setReorderCodes(const int32_t *reorderCodes, int32_t reorderCodesLength, UErrorCode &status)
Sets the ordering of scripts for this collator.
icu::Collator::getCollationKey
virtual CollationKey & getCollationKey(const UnicodeString &source, CollationKey &key, UErrorCode &status) const =0
Transforms the string into a series of characters that can be compared with CollationKey::compareTo.
icu::Collator::setVariableTop
virtual void setVariableTop(uint32_t varTop, UErrorCode &status)=0
Sets the variable top to the specified primary weight.
icu::Collator::setVariableTop
virtual uint32_t setVariableTop(const char16_t *varTop, int32_t len, UErrorCode &status)=0
Sets the variable top to the primary weight of the specified string.
icu::Collator::compare
virtual UCollationResult compare(const UnicodeString &source, const UnicodeString &target, int32_t length, UErrorCode &status) const =0
Does the same thing as compare but limits the comparison to a specified length.
icu::Collator::unregister
static UBool unregister(URegistryKey key, UErrorCode &status)
Unregister a previously-registered Collator or CollatorFactory using the key returned from the regist...
icu::Collator::Collator
Collator(const Collator &other)
Copy constructor.
icu::Collator::compare
virtual EComparisonResult compare(const UnicodeString &source, const UnicodeString &target, int32_t length) const
Does the same thing as compare but limits the comparison to a specified length.
icu::Collator::createInstance
static Collator * createInstance(const Locale &loc, UErrorCode &err)
Gets the collation object for the desired locale.
icu::Collator::getEquivalentReorderCodes
static int32_t getEquivalentReorderCodes(int32_t reorderCode, int32_t *dest, int32_t destCapacity, UErrorCode &status)
Retrieves the reorder codes that are grouped with the given reorder code.
icu::Collator::getAvailableLocales
static const Locale * getAvailableLocales(int32_t &count)
Get the set of Locales for which Collations are installed.
icu::Collator::getDisplayName
static UnicodeString & getDisplayName(const Locale &objectLocale, const Locale &displayLocale, UnicodeString &name)
Get name of the object for the desired Locale, in the desired language.
icu::Collator::internalGetShortDefinitionString
virtual int32_t internalGetShortDefinitionString(const char *locale, char *buffer, int32_t capacity, UErrorCode &status) const
Get the short definition string for a collator.
icu::Locale
A Locale object represents a specific geographical, political, or cultural region.
Definition:locid.h:198
icu::StringEnumeration
Base class for 'pure' C++ implementations of uenum api.
Definition:strenum.h:61
icu::StringPiece
A string-like object that points to a sized piece of memory.
Definition:stringpiece.h:61
icu::UObject
UObject is the common ICU "boilerplate" class.
Definition:uobject.h:222
icu::UnicodeSet
A mutable set of Unicode characters and multicharacter strings.
Definition:uniset.h:285
icu::UnicodeString
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition:unistr.h:303
locid.h
C++ API: Locale ID object.
stringpiece.h
C++ API: StringPiece: Read-only byte string wrapper class.
UCharIterator
C API for code unit iteration.
Definition:uiter.h:341
ucol.h
C API: Collator.
UCollator
struct UCollator UCollator
structure representing a collator object instance
Definition:ucol.h:61
UColAttribute
UColAttribute
Attributes that collation service understands.
Definition:ucol.h:245
UCollationResult
UCollationResult
UCOL_LESS is returned if source string is compared to be less than target string in the ucol_strcoll(...
Definition:ucol.h:76
UCOL_LESS
@ UCOL_LESS
string a < string b
Definition:ucol.h:82
UCOL_GREATER
@ UCOL_GREATER
string a > string b
Definition:ucol.h:80
UCOL_EQUAL
@ UCOL_EQUAL
string a == string b
Definition:ucol.h:78
UColBoundMode
UColBoundMode
enum that is taken by ucol_getBound API See below for explanation do not change the values assigned...
Definition:ucol.h:1073
UColAttributeValue
UColAttributeValue
Enum containing attribute values for controlling collation behavior.
Definition:ucol.h:92
UCOL_TERTIARY
@ UCOL_TERTIARY
Tertiary collation strength.
Definition:ucol.h:101
UCOL_IDENTICAL
@ UCOL_IDENTICAL
Identical collation strength.
Definition:ucol.h:108
UCOL_QUATERNARY
@ UCOL_QUATERNARY
Quaternary collation strength.
Definition:ucol.h:106
UCOL_PRIMARY
@ UCOL_PRIMARY
Primary collation strength.
Definition:ucol.h:97
UCOL_SECONDARY
@ UCOL_SECONDARY
Secondary collation strength.
Definition:ucol.h:99
UColReorderCode
UColReorderCode
Enum containing the codes for reordering segments of the collation table that are not script codes.
Definition:ucol.h:149
uiter.h
C API: Unicode Character Iteration.
ULocDataLocaleType
ULocDataLocaleType
Constants for *_getLocale() Allow user to select whether she wants information on requested,...
Definition:uloc.h:338
UBool
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition:umachine.h:269
umisc.h
C API: Miscellaneous definitions.
URegistryKey
const void * URegistryKey
Opaque type returned by registerInstance, registerFactory and unregister for service registration.
Definition:umisc.h:57
uniset.h
C++ API: Unicode Set.
unistr.h
C++ API: Unicode String.
unorm.h
C API: Unicode Normalization.
UNormalizationMode
UNormalizationMode
Constants for normalization modes.
Definition:unorm.h:140
uobject.h
C++ API: Common ICU base class UObject.
UClassID
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition:uobject.h:96
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
UErrorCode
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition:utypes.h:509
U_ZERO_ERROR
@ U_ZERO_ERROR
No error, no warning.
Definition:utypes.h:544
U_I18N_API
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside.
Definition:utypes.h:316
UVersionInfo
uint8_t UVersionInfo[U_MAX_VERSION_LENGTH]
The binary form of a version on ICU APIs is an array of 4 uint8_t.
Definition:uversion.h:59

Generated by doxygen 1.9.1
[8]ページ先頭

©2009-2025 Movatter.jp