ICU 76.1: i18n/unicode/ucol.h Source File

ICU 76.1 76.1

ucol.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-2015, International Business Machines Corporation and others.
6* All Rights Reserved.
7*******************************************************************************
8*/
9
10#ifndef UCOL_H
11#define UCOL_H
12
13#include "unicode/utypes.h"
14
15#if !UCONFIG_NO_COLLATION
16
17#include "unicode/unorm.h"
18#include "unicode/parseerr.h"
19#include "unicode/uloc.h"
20#include "unicode/uset.h"
21#include "unicode/uscript.h"
22
23#if U_SHOW_CPLUSPLUS_API
24#include "unicode/localpointer.h"
25#endif // U_SHOW_CPLUSPLUS_API
26
57struct UCollator;
61 typedef struct UCollator UCollator;
62
63
76 typedef enum {
78 UCOL_EQUAL = 0,
80 UCOL_GREATER = 1,
82 UCOL_LESS = -1
83} UCollationResult ;
84
85
92 typedef enum {
94 UCOL_DEFAULT = -1,
95
97 UCOL_PRIMARY = 0,
99 UCOL_SECONDARY = 1,
101 UCOL_TERTIARY = 2,
103 UCOL_DEFAULT_STRENGTH = UCOL_TERTIARY,
104 UCOL_CE_STRENGTH_LIMIT,
106 UCOL_QUATERNARY=3,
108 UCOL_IDENTICAL=15,
109 UCOL_STRENGTH_LIMIT,
110
114 UCOL_OFF = 16,
118 UCOL_ON = 17,
119
121 UCOL_SHIFTED = 20,
123 UCOL_NON_IGNORABLE = 21,
124
127 UCOL_LOWER_FIRST = 24,
129 UCOL_UPPER_FIRST = 25,
130
131#ifndef U_HIDE_DEPRECATED_API
136 UCOL_ATTRIBUTE_VALUE_COUNT
137#endif /* U_HIDE_DEPRECATED_API */
138} UColAttributeValue;
139
149 typedef enum {
155 UCOL_REORDER_CODE_DEFAULT = -1,
160 UCOL_REORDER_CODE_NONE = USCRIPT_UNKNOWN,
167 UCOL_REORDER_CODE_OTHERS = USCRIPT_UNKNOWN,
173 UCOL_REORDER_CODE_SPACE = 0x1000,
179 UCOL_REORDER_CODE_FIRST = UCOL_REORDER_CODE_SPACE,
185 UCOL_REORDER_CODE_PUNCTUATION = 0x1001,
191 UCOL_REORDER_CODE_SYMBOL = 0x1002,
197 UCOL_REORDER_CODE_CURRENCY = 0x1003,
203 UCOL_REORDER_CODE_DIGIT = 0x1004,
204#ifndef U_HIDE_DEPRECATED_API
209 UCOL_REORDER_CODE_LIMIT = 0x1005
210#endif /* U_HIDE_DEPRECATED_API */
211} UColReorderCode;
212
239 typedef UColAttributeValue UCollationStrength;
240
245 typedef enum {
252 UCOL_FRENCH_COLLATION,
266 UCOL_ALTERNATE_HANDLING,
278 UCOL_CASE_FIRST,
289 UCOL_CASE_LEVEL,
302 UCOL_NORMALIZATION_MODE,
306 UCOL_DECOMPOSITION_MODE = UCOL_NORMALIZATION_MODE,
323 UCOL_STRENGTH,
324#ifndef U_HIDE_DEPRECATED_API
336 UCOL_HIRAGANA_QUATERNARY_MODE = UCOL_STRENGTH + 1,
337#endif /* U_HIDE_DEPRECATED_API */
356 UCOL_NUMERIC_COLLATION = UCOL_STRENGTH + 2,
357
358 /* Do not conditionalize the following with #ifndef U_HIDE_DEPRECATED_API,
359 * it is needed for layout of RuleBasedCollator object. */
360#ifndef U_FORCE_HIDE_DEPRECATED_API
365 UCOL_ATTRIBUTE_COUNT
366#endif // U_FORCE_HIDE_DEPRECATED_API
367} UColAttribute;
368
372 typedef enum {
378 UCOL_TAILORING_ONLY,
386 UCOL_FULL_RULES
387} UColRuleOption ;
388
414 U_CAPI UCollator* U_EXPORT2
415ucol_open(const char *loc, UErrorCode *status);
416
442 U_CAPI UCollator* U_EXPORT2
443ucol_openRules( const UChar *rules,
444 int32_t rulesLength,
445 UColAttributeValue normalizationMode,
446 UCollationStrength strength,
447 UParseError *parseError,
448 UErrorCode *status);
449
450#ifndef U_HIDE_DEPRECATED_API
484 U_DEPRECATED UCollator* U_EXPORT2
485ucol_openFromShortString( const char *definition,
486 UBool forceDefaults,
487 UParseError *parseError,
488 UErrorCode *status);
489#endif /* U_HIDE_DEPRECATED_API */
490
491#ifndef U_HIDE_DEPRECATED_API
505 U_DEPRECATED int32_t U_EXPORT2
506ucol_getContractions( const UCollator *coll,
507 USet *conts,
508 UErrorCode *status);
509#endif /* U_HIDE_DEPRECATED_API */
510
522 U_CAPI void U_EXPORT2
523ucol_getContractionsAndExpansions( const UCollator *coll,
524 USet *contractions, USet *expansions,
525 UBool addPrefixes, UErrorCode *status);
526
537 U_CAPI void U_EXPORT2
538ucol_close(UCollator *coll);
539
540#if U_SHOW_CPLUSPLUS_API
541
542U_NAMESPACE_BEGIN
543
553 U_DEFINE_LOCAL_OPEN_POINTER(LocalUCollatorPointer, UCollator, ucol_close);
554
555U_NAMESPACE_END
556
557#endif
558
574 U_CAPI UCollationResult U_EXPORT2
575ucol_strcoll( const UCollator *coll,
576 const UChar *source,
577 int32_t sourceLength,
578 const UChar *target,
579 int32_t targetLength);
580
599 U_CAPI UCollationResult U_EXPORT2
600ucol_strcollUTF8(
601 const UCollator *coll,
602 const char *source,
603 int32_t sourceLength,
604 const char *target,
605 int32_t targetLength,
606 UErrorCode *status);
607
622 U_CAPI UBool U_EXPORT2
623ucol_greater(const UCollator *coll,
624 const UChar *source, int32_t sourceLength,
625 const UChar *target, int32_t targetLength);
626
641 U_CAPI UBool U_EXPORT2
642ucol_greaterOrEqual(const UCollator *coll,
643 const UChar *source, int32_t sourceLength,
644 const UChar *target, int32_t targetLength);
645
660 U_CAPI UBool U_EXPORT2
661ucol_equal(const UCollator *coll,
662 const UChar *source, int32_t sourceLength,
663 const UChar *target, int32_t targetLength);
664
677 U_CAPI UCollationResult U_EXPORT2
678ucol_strcollIter( const UCollator *coll,
679 UCharIterator *sIter,
680 UCharIterator *tIter,
681 UErrorCode *status);
682
692 U_CAPI UCollationStrength U_EXPORT2
693ucol_getStrength(const UCollator *coll);
694
704 U_CAPI void U_EXPORT2
705ucol_setStrength(UCollator *coll,
706 UCollationStrength strength);
707
724 U_CAPI int32_t U_EXPORT2
725ucol_getReorderCodes(const UCollator* coll,
726 int32_t* dest,
727 int32_t destCapacity,
728 UErrorCode *pErrorCode);
769 U_CAPI void U_EXPORT2
770ucol_setReorderCodes(UCollator* coll,
771 const int32_t* reorderCodes,
772 int32_t reorderCodesLength,
773 UErrorCode *pErrorCode);
774
794 U_CAPI int32_t U_EXPORT2
795ucol_getEquivalentReorderCodes(int32_t reorderCode,
796 int32_t* dest,
797 int32_t destCapacity,
798 UErrorCode *pErrorCode);
799
812 U_CAPI int32_t U_EXPORT2
813ucol_getDisplayName( const char *objLoc,
814 const char *dispLoc,
815 UChar *result,
816 int32_t resultLength,
817 UErrorCode *status);
818
828 U_CAPI const char* U_EXPORT2
829ucol_getAvailable(int32_t localeIndex);
830
839 U_CAPI int32_t U_EXPORT2
840ucol_countAvailable(void);
841
842#if !UCONFIG_NO_SERVICE
851 U_CAPI UEnumeration* U_EXPORT2
852ucol_openAvailableLocales(UErrorCode *status);
853#endif
854
864 U_CAPI UEnumeration* U_EXPORT2
865ucol_getKeywords(UErrorCode *status);
866
878 U_CAPI UEnumeration* U_EXPORT2
879ucol_getKeywordValues(const char *keyword, UErrorCode *status);
880
897 U_CAPI UEnumeration* U_EXPORT2
898ucol_getKeywordValuesForLocale(const char* key,
899 const char* locale,
900 UBool commonlyUsed,
901 UErrorCode* status);
902
934 U_CAPI int32_t U_EXPORT2
935ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
936 const char* keyword, const char* locale,
937 UBool* isAvailable, UErrorCode* status);
938
947 U_CAPI const UChar* U_EXPORT2
948ucol_getRules( const UCollator *coll,
949 int32_t *length);
950
951#ifndef U_HIDE_DEPRECATED_API
972 U_DEPRECATED int32_t U_EXPORT2
973ucol_getShortDefinitionString(const UCollator *coll,
974 const char *locale,
975 char *buffer,
976 int32_t capacity,
977 UErrorCode *status);
978
998 U_DEPRECATED int32_t U_EXPORT2
999ucol_normalizeShortDefinitionString(const char *source,
1000 char *destination,
1001 int32_t capacity,
1002 UParseError *parseError,
1003 UErrorCode *status);
1004#endif /* U_HIDE_DEPRECATED_API */
1005
1006
1029 U_CAPI int32_t U_EXPORT2
1030ucol_getSortKey(const UCollator *coll,
1031 const UChar *source,
1032 int32_t sourceLength,
1033 uint8_t *result,
1034 int32_t resultLength);
1035
1036
1057 U_CAPI int32_t U_EXPORT2
1058ucol_nextSortKeyPart(const UCollator *coll,
1059 UCharIterator *iter,
1060 uint32_t state[2],
1061 uint8_t *dest, int32_t count,
1062 UErrorCode *status);
1063
1071 typedef enum {
1073 UCOL_BOUND_LOWER = 0,
1075 UCOL_BOUND_UPPER = 1,
1077 UCOL_BOUND_UPPER_LONG = 2,
1078#ifndef U_HIDE_DEPRECATED_API
1083 UCOL_BOUND_VALUE_COUNT
1084#endif /* U_HIDE_DEPRECATED_API */
1085} UColBoundMode;
1086
1124 U_CAPI int32_t U_EXPORT2
1125ucol_getBound(const uint8_t *source,
1126 int32_t sourceLength,
1127 UColBoundMode boundType,
1128 uint32_t noOfLevels,
1129 uint8_t *result,
1130 int32_t resultLength,
1131 UErrorCode *status);
1132
1141 U_CAPI void U_EXPORT2
1142ucol_getVersion(const UCollator* coll, UVersionInfo info);
1143
1151 U_CAPI void U_EXPORT2
1152ucol_getUCAVersion(const UCollator* coll, UVersionInfo info);
1153
1201 U_CAPI int32_t U_EXPORT2
1202ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length,
1203 const uint8_t *src2, int32_t src2Length,
1204 uint8_t *dest, int32_t destCapacity);
1205
1217 U_CAPI void U_EXPORT2
1218ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status);
1219
1231 U_CAPI UColAttributeValue U_EXPORT2
1232ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status);
1233
1250 U_CAPI void U_EXPORT2
1251ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCode);
1252
1260 U_CAPI UColReorderCode U_EXPORT2
1261ucol_getMaxVariable(const UCollator *coll);
1262
1263#ifndef U_HIDE_DEPRECATED_API
1284 U_DEPRECATED uint32_t U_EXPORT2
1285ucol_setVariableTop(UCollator *coll,
1286 const UChar *varTop, int32_t len,
1287 UErrorCode *status);
1288#endif /* U_HIDE_DEPRECATED_API */
1289
1301 U_CAPI uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status);
1302
1303#ifndef U_HIDE_DEPRECATED_API
1318 U_DEPRECATED void U_EXPORT2
1319ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status);
1320#endif /* U_HIDE_DEPRECATED_API */
1321
1332 U_CAPI UCollator* U_EXPORT2 ucol_clone(const UCollator *coll, UErrorCode *status);
1333
1334#ifndef U_HIDE_DEPRECATED_API
1335
1359 U_DEPRECATED UCollator* U_EXPORT2
1360ucol_safeClone(const UCollator *coll,
1361 void *stackBuffer,
1362 int32_t *pBufferSize,
1363 UErrorCode *status);
1364
1365
1369#define U_COL_SAFECLONE_BUFFERSIZE 1
1370
1371#endif /* U_HIDE_DEPRECATED_API */
1372
1388 U_CAPI int32_t U_EXPORT2
1389ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen);
1390
1391#ifndef U_HIDE_DEPRECATED_API
1406 U_DEPRECATED const char * U_EXPORT2
1407ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);
1408#endif /* U_HIDE_DEPRECATED_API */
1409
1424 U_CAPI const char * U_EXPORT2
1425ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);
1426
1437 U_CAPI USet * U_EXPORT2
1438ucol_getTailoredSet(const UCollator *coll, UErrorCode *status);
1439
1440#ifndef U_HIDE_INTERNAL_API
1452 U_CAPI int32_t U_EXPORT2
1453ucol_getUnsafeSet( const UCollator *coll,
1454 USet *unsafe,
1455 UErrorCode *status);
1456
1477 U_CAPI void U_EXPORT2
1478ucol_prepareShortStringOpen( const char *definition,
1479 UBool forceDefaults,
1480 UParseError *parseError,
1481 UErrorCode *status);
1482#endif /* U_HIDE_INTERNAL_API */
1483
1495 U_CAPI int32_t U_EXPORT2
1496ucol_cloneBinary(const UCollator *coll,
1497 uint8_t *buffer, int32_t capacity,
1498 UErrorCode *status);
1499
1517 U_CAPI UCollator* U_EXPORT2
1518ucol_openBinary(const uint8_t *bin, int32_t length,
1519 const UCollator *base,
1520 UErrorCode *status);
1521
1522#if U_SHOW_CPLUSPLUS_API || U_SHOW_CPLUSPLUS_HEADER_API
1523
1524#include <functional>
1525#include <string_view>
1526#include <type_traits>
1527
1528#include "unicode/char16ptr.h"
1529#include "unicode/stringpiece.h"
1530#include "unicode/unistr.h"
1531
1532namespace U_HEADER_ONLY_NAMESPACE {
1533
1534#ifndef U_HIDE_DRAFT_API
1535
1536namespace collator {
1537
1538namespace internal {
1539
1544template <template <typename...> typename Compare, UCollationResult result>
1545 class Predicate {
1546 public:
1548 explicit Predicate(const UCollator* ucol) : collator(ucol) {}
1549
1551 template <
1552 typename T, typename U,
1553 typename = std::enable_if_t<ConvertibleToU16StringView<T> && ConvertibleToU16StringView<U>>>
1554 bool operator()(const T& lhs, const U& rhs) const {
1555 return match(UnicodeString::readOnlyAlias(lhs), UnicodeString::readOnlyAlias(rhs));
1556 }
1557
1559 bool operator()(std::string_view lhs, std::string_view rhs) const {
1560 return match(lhs, rhs);
1561 }
1562
1563#if defined(__cpp_char8_t)
1565 bool operator()(std::u8string_view lhs, std::u8string_view rhs) const {
1566 return match(lhs, rhs);
1567 }
1568#endif
1569
1570 private:
1571 bool match(UnicodeString lhs, UnicodeString rhs) const {
1572 return compare(
1573 ucol_strcoll(
1574 collator,
1575 toUCharPtr(lhs.getBuffer()), lhs.length(),
1576 toUCharPtr(rhs.getBuffer()), rhs.length()),
1577 result);
1578 }
1579
1580 bool match(StringPiece lhs, StringPiece rhs) const {
1581 UErrorCode status = U_ZERO_ERROR;
1582 return compare(
1583 ucol_strcollUTF8(
1584 collator,
1585 lhs.data(), lhs.length(),
1586 rhs.data(), rhs.length(),
1587 &status),
1588 result);
1589 }
1590
1591 const UCollator* const collator;
1592 static constexpr Compare<UCollationResult> compare{};
1593};
1594
1595} // namespace internal
1596
1602 using equal_to = internal::Predicate<std::equal_to, UCOL_EQUAL>;
1603
1609 using greater = internal::Predicate<std::equal_to, UCOL_GREATER>;
1610
1616 using less = internal::Predicate<std::equal_to, UCOL_LESS>;
1617
1623 using not_equal_to = internal::Predicate<std::not_equal_to, UCOL_EQUAL>;
1624
1630 using greater_equal = internal::Predicate<std::not_equal_to, UCOL_LESS>;
1631
1637 using less_equal = internal::Predicate<std::not_equal_to, UCOL_GREATER>;
1638
1639} // namespace collator
1640
1641#endif // U_HIDE_DRAFT_API
1642
1643} // namespace U_HEADER_ONLY_NAMESPACE
1644
1645#endif // U_SHOW_CPLUSPLUS_API || U_SHOW_CPLUSPLUS_HEADER_API
1646
1647#endif /* #if !UCONFIG_NO_COLLATION */
1648
1649#endif
char16ptr.h
C++ API: char16_t pointer wrappers with implicit conversion from bit-compatible raw pointer types.
LocalUCollatorPointer
"Smart pointer" class, closes a UCollator via ucol_close().
U_HEADER_ONLY_NAMESPACE::collator::internal::Predicate
Function object for performing comparisons using a UCollator.
Definition ucol.h:1545
U_HEADER_ONLY_NAMESPACE::collator::internal::Predicate::operator()
bool operator()(std::string_view lhs, std::string_view rhs) const
Definition ucol.h:1559
U_HEADER_ONLY_NAMESPACE::collator::internal::Predicate::operator()
bool operator()(const T &lhs, const U &rhs) const
Definition ucol.h:1554
U_HEADER_ONLY_NAMESPACE::collator::internal::Predicate::Predicate
Predicate(const UCollator *ucol)
Definition ucol.h:1548
localpointer.h
C++ API: "Smart pointers" for use with and in ICU4C C++ code.
U_DEFINE_LOCAL_OPEN_POINTER
#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction)
"Smart pointer" definition macro, deletes objects via the closeFunction.
Definition localpointer.h:550
parseerr.h
C API: Parse Error Information.
stringpiece.h
C++ API: StringPiece: Read-only byte string wrapper class.
UCharIterator
C API for code unit iteration.
Definition uiter.h:341
UParseError
A UParseError struct is used to returned detailed information about parsing errors.
Definition parseerr.h:58
ucol_setMaxVariable
U_CAPI void ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCode)
Sets the variable top to the top of the specified reordering group.
ucol_setVariableTop
uint32_t ucol_setVariableTop(UCollator *coll, const UChar *varTop, int32_t len, UErrorCode *status)
Sets the variable top to the primary weight of the specified string.
ucol_getRulesEx
U_CAPI int32_t ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen)
Returns current rules.
ucol_getVersion
U_CAPI void ucol_getVersion(const UCollator *coll, UVersionInfo info)
Gets the version information for a Collator.
ucol_getContractionsAndExpansions
U_CAPI void ucol_getContractionsAndExpansions(const UCollator *coll, USet *contractions, USet *expansions, UBool addPrefixes, UErrorCode *status)
Get a set containing the expansions defined by the collator.
ucol_getVariableTop
U_CAPI uint32_t ucol_getVariableTop(const UCollator *coll, UErrorCode *status)
Gets the variable top value of a Collator.
ucol_getAttribute
U_CAPI UColAttributeValue ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status)
Universal attribute getter.
ucol_getLocaleByType
U_CAPI const char * ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status)
gets the locale name of the collator.
ucol_setStrength
U_CAPI void ucol_setStrength(UCollator *coll, UCollationStrength strength)
Set the collation strength used in a UCollator.
ucol_getUnsafeSet
U_CAPI int32_t ucol_getUnsafeSet(const UCollator *coll, USet *unsafe, UErrorCode *status)
Calculates the set of unsafe code points, given a collator.
ucol_openBinary
U_CAPI UCollator * ucol_openBinary(const uint8_t *bin, int32_t length, const UCollator *base, UErrorCode *status)
Opens a collator from a collator binary image created using ucol_cloneBinary.
ucol_open
U_CAPI UCollator * ucol_open(const char *loc, UErrorCode *status)
Open a UCollator for comparing strings.
UCollator
struct UCollator UCollator
structure representing a collator object instance
Definition ucol.h:61
ucol_setAttribute
U_CAPI void ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status)
Universal attribute setter.
ucol_openAvailableLocales
U_CAPI UEnumeration * ucol_openAvailableLocales(UErrorCode *status)
Create a string enumerator of all locales for which a valid collator may be opened.
ucol_getMaxVariable
U_CAPI UColReorderCode ucol_getMaxVariable(const UCollator *coll)
Returns the maximum reordering group whose characters are affected by UCOL_ALTERNATE_HANDLING.
ucol_normalizeShortDefinitionString
int32_t ucol_normalizeShortDefinitionString(const char *source, char *destination, int32_t capacity, UParseError *parseError, UErrorCode *status)
Verifies and normalizes short definition string.
UColRuleOption
UColRuleOption
Options for retrieving the rule string.
Definition ucol.h:372
UCOL_FULL_RULES
@ UCOL_FULL_RULES
Retrieves the "UCA rules" concatenated with the tailoring rules.
Definition ucol.h:386
UCOL_TAILORING_ONLY
@ UCOL_TAILORING_ONLY
Retrieves the tailoring rules only.
Definition ucol.h:378
UColAttribute
UColAttribute
Attributes that collation service understands.
Definition ucol.h:245
UCOL_CASE_FIRST
@ UCOL_CASE_FIRST
Controls the ordering of upper and lower case letters.
Definition ucol.h:278
UCOL_NUMERIC_COLLATION
@ UCOL_NUMERIC_COLLATION
When turned on, this attribute makes substrings of digits sort according to their numeric values.
Definition ucol.h:356
UCOL_STRENGTH
@ UCOL_STRENGTH
The strength attribute.
Definition ucol.h:323
UCOL_CASE_LEVEL
@ UCOL_CASE_LEVEL
Controls whether an extra case level (positioned before the third level) is generated or not.
Definition ucol.h:289
UCOL_FRENCH_COLLATION
@ UCOL_FRENCH_COLLATION
Attribute for direction of secondary weights - used in Canadian French.
Definition ucol.h:252
UCOL_HIRAGANA_QUATERNARY_MODE
@ UCOL_HIRAGANA_QUATERNARY_MODE
When turned on, this attribute positions Hiragana before all non-ignorables on quaternary level Thi...
Definition ucol.h:336
UCOL_DECOMPOSITION_MODE
@ UCOL_DECOMPOSITION_MODE
An alias for UCOL_NORMALIZATION_MODE attribute.
Definition ucol.h:306
UCOL_ATTRIBUTE_COUNT
@ UCOL_ATTRIBUTE_COUNT
One more than the highest normal UColAttribute value.
Definition ucol.h:365
UCOL_ALTERNATE_HANDLING
@ UCOL_ALTERNATE_HANDLING
Attribute for handling variable elements.
Definition ucol.h:266
UCOL_NORMALIZATION_MODE
@ UCOL_NORMALIZATION_MODE
Controls whether the normalization check and necessary normalizations are performed.
Definition ucol.h:302
ucol_getSortKey
U_CAPI int32_t ucol_getSortKey(const UCollator *coll, const UChar *source, int32_t sourceLength, uint8_t *result, int32_t resultLength)
Get a sort key for a string from a UCollator.
ucol_getContractions
int32_t ucol_getContractions(const UCollator *coll, USet *conts, UErrorCode *status)
Get a set containing the contractions defined by the collator.
ucol_getTailoredSet
U_CAPI USet * ucol_getTailoredSet(const UCollator *coll, UErrorCode *status)
Get a Unicode set that contains all the characters and sequences tailored in this collator.
ucol_strcoll
U_CAPI UCollationResult ucol_strcoll(const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
Compare two strings.
UCollationStrength
UColAttributeValue UCollationStrength
Base letter represents a primary difference.
Definition ucol.h:239
ucol_getBound
U_CAPI int32_t ucol_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.
ucol_strcollIter
U_CAPI UCollationResult ucol_strcollIter(const UCollator *coll, UCharIterator *sIter, UCharIterator *tIter, UErrorCode *status)
Compare two UTF-8 encoded strings.
ucol_getRules
U_CAPI const UChar * ucol_getRules(const UCollator *coll, int32_t *length)
Get the collation tailoring rules from a UCollator.
ucol_getShortDefinitionString
int32_t ucol_getShortDefinitionString(const UCollator *coll, const char *locale, char *buffer, int32_t capacity, UErrorCode *status)
Get the short definition string for a collator.
ucol_equal
U_CAPI UBool ucol_equal(const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
Compare two strings for equality.
ucol_getAvailable
U_CAPI const char * ucol_getAvailable(int32_t localeIndex)
Get a locale for which collation rules are available.
ucol_getKeywords
U_CAPI UEnumeration * ucol_getKeywords(UErrorCode *status)
Create a string enumerator of all possible keywords that are relevant to collation.
ucol_openFromShortString
UCollator * ucol_openFromShortString(const char *definition, UBool forceDefaults, UParseError *parseError, UErrorCode *status)
Open a collator defined by a short form string.
ucol_getLocale
const char * ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status)
gets the locale name of the collator.
ucol_cloneBinary
U_CAPI int32_t ucol_cloneBinary(const UCollator *coll, uint8_t *buffer, int32_t capacity, UErrorCode *status)
Creates a binary image of a collator.
ucol_strcollUTF8
U_CAPI UCollationResult ucol_strcollUTF8(const UCollator *coll, const char *source, int32_t sourceLength, const char *target, int32_t targetLength, UErrorCode *status)
Compare two strings in UTF-8.
ucol_prepareShortStringOpen
U_CAPI void ucol_prepareShortStringOpen(const char *definition, UBool forceDefaults, UParseError *parseError, UErrorCode *status)
Touches all resources needed for instantiating a collator from a short string definition,...
ucol_greater
U_CAPI UBool ucol_greater(const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
Determine if one string is greater than another.
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
ucol_safeClone
UCollator * ucol_safeClone(const UCollator *coll, void *stackBuffer, int32_t *pBufferSize, UErrorCode *status)
Thread safe cloning operation.
ucol_nextSortKeyPart
U_CAPI int32_t ucol_nextSortKeyPart(const UCollator *coll, UCharIterator *iter, uint32_t state[2], uint8_t *dest, int32_t count, UErrorCode *status)
Gets the next count bytes of a sort key.
UColBoundMode
UColBoundMode
enum that is taken by ucol_getBound API See below for explanation do not change the values assigned...
Definition ucol.h:1071
UCOL_BOUND_LOWER
@ UCOL_BOUND_LOWER
lower bound
Definition ucol.h:1073
UCOL_BOUND_UPPER
@ UCOL_BOUND_UPPER
upper bound that will match strings of exact size
Definition ucol.h:1075
UCOL_BOUND_VALUE_COUNT
@ UCOL_BOUND_VALUE_COUNT
One more than the highest normal UColBoundMode value.
Definition ucol.h:1083
UCOL_BOUND_UPPER_LONG
@ UCOL_BOUND_UPPER_LONG
upper bound that will match all the strings that have the same initial substring as the given string
Definition ucol.h:1077
ucol_countAvailable
U_CAPI int32_t ucol_countAvailable(void)
Determine how many locales have collation rules available.
ucol_clone
U_CAPI UCollator * ucol_clone(const UCollator *coll, UErrorCode *status)
Thread safe cloning operation.
ucol_greaterOrEqual
U_CAPI UBool ucol_greaterOrEqual(const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
Determine if one string is greater than or equal to another.
ucol_getEquivalentReorderCodes
U_CAPI int32_t ucol_getEquivalentReorderCodes(int32_t reorderCode, int32_t *dest, int32_t destCapacity, UErrorCode *pErrorCode)
Retrieves the reorder codes that are grouped with the given reorder code.
ucol_close
U_CAPI void ucol_close(UCollator *coll)
Close a UCollator.
ucol_getFunctionalEquivalent
U_CAPI int32_t ucol_getFunctionalEquivalent(char *result, int32_t resultCapacity, const char *keyword, const char *locale, UBool *isAvailable, UErrorCode *status)
Return the functionally equivalent locale for the specified input locale, with respect to given keywo...
ucol_openRules
U_CAPI UCollator * ucol_openRules(const UChar *rules, int32_t rulesLength, UColAttributeValue normalizationMode, UCollationStrength strength, UParseError *parseError, UErrorCode *status)
Produce a UCollator instance according to the rules supplied.
ucol_getUCAVersion
U_CAPI void ucol_getUCAVersion(const UCollator *coll, UVersionInfo info)
Gets the UCA version information for a Collator.
ucol_getDisplayName
U_CAPI int32_t ucol_getDisplayName(const char *objLoc, const char *dispLoc, UChar *result, int32_t resultLength, UErrorCode *status)
Get the display name for a UCollator.
UColAttributeValue
UColAttributeValue
Enum containing attribute values for controlling collation behavior.
Definition ucol.h:92
UCOL_UPPER_FIRST
@ UCOL_UPPER_FIRST
upper case sorts before lower case
Definition ucol.h:129
UCOL_TERTIARY
@ UCOL_TERTIARY
Tertiary collation strength.
Definition ucol.h:101
UCOL_DEFAULT
@ UCOL_DEFAULT
accepted by most attributes
Definition ucol.h:94
UCOL_IDENTICAL
@ UCOL_IDENTICAL
Identical collation strength.
Definition ucol.h:108
UCOL_OFF
@ UCOL_OFF
Turn the feature off - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MOD...
Definition ucol.h:114
UCOL_QUATERNARY
@ UCOL_QUATERNARY
Quaternary collation strength.
Definition ucol.h:106
UCOL_SHIFTED
@ UCOL_SHIFTED
Valid for UCOL_ALTERNATE_HANDLING.
Definition ucol.h:121
UCOL_PRIMARY
@ UCOL_PRIMARY
Primary collation strength.
Definition ucol.h:97
UCOL_LOWER_FIRST
@ UCOL_LOWER_FIRST
Valid for UCOL_CASE_FIRST - lower case sorts before upper case.
Definition ucol.h:127
UCOL_ATTRIBUTE_VALUE_COUNT
@ UCOL_ATTRIBUTE_VALUE_COUNT
One more than the highest normal UColAttributeValue value.
Definition ucol.h:136
UCOL_SECONDARY
@ UCOL_SECONDARY
Secondary collation strength.
Definition ucol.h:99
UCOL_NON_IGNORABLE
@ UCOL_NON_IGNORABLE
Valid for UCOL_ALTERNATE_HANDLING.
Definition ucol.h:123
UCOL_ON
@ UCOL_ON
Turn the feature on - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MODE...
Definition ucol.h:118
UCOL_DEFAULT_STRENGTH
@ UCOL_DEFAULT_STRENGTH
Default collation strength.
Definition ucol.h:103
ucol_restoreVariableTop
void ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status)
Sets the variable top to the specified primary weight.
ucol_getStrength
U_CAPI UCollationStrength ucol_getStrength(const UCollator *coll)
Get the collation strength used in a UCollator.
ucol_getReorderCodes
U_CAPI int32_t ucol_getReorderCodes(const UCollator *coll, int32_t *dest, int32_t destCapacity, UErrorCode *pErrorCode)
Retrieves the reordering codes for this collator.
ucol_setReorderCodes
U_CAPI void ucol_setReorderCodes(UCollator *coll, const int32_t *reorderCodes, int32_t reorderCodesLength, UErrorCode *pErrorCode)
Sets the reordering codes for this collator.
UColReorderCode
UColReorderCode
Enum containing the codes for reordering segments of the collation table that are not script codes.
Definition ucol.h:149
UCOL_REORDER_CODE_OTHERS
@ UCOL_REORDER_CODE_OTHERS
A special reordering code that is used to specify all other codes used for reordering except for the ...
Definition ucol.h:167
UCOL_REORDER_CODE_NONE
@ UCOL_REORDER_CODE_NONE
A special reordering code that is used to specify no reordering codes.
Definition ucol.h:160
UCOL_REORDER_CODE_DEFAULT
@ UCOL_REORDER_CODE_DEFAULT
A special reordering code that is used to specify the default reordering codes for a locale.
Definition ucol.h:155
UCOL_REORDER_CODE_LIMIT
@ UCOL_REORDER_CODE_LIMIT
One more than the highest normal UColReorderCode value.
Definition ucol.h:209
UCOL_REORDER_CODE_SYMBOL
@ UCOL_REORDER_CODE_SYMBOL
Characters with the symbol property.
Definition ucol.h:191
UCOL_REORDER_CODE_DIGIT
@ UCOL_REORDER_CODE_DIGIT
Characters with the digit property.
Definition ucol.h:203
UCOL_REORDER_CODE_PUNCTUATION
@ UCOL_REORDER_CODE_PUNCTUATION
Characters with the punctuation property.
Definition ucol.h:185
UCOL_REORDER_CODE_SPACE
@ UCOL_REORDER_CODE_SPACE
Characters with the space property.
Definition ucol.h:173
UCOL_REORDER_CODE_FIRST
@ UCOL_REORDER_CODE_FIRST
The first entry in the enumeration of reordering groups.
Definition ucol.h:179
UCOL_REORDER_CODE_CURRENCY
@ UCOL_REORDER_CODE_CURRENCY
Characters with the currency property.
Definition ucol.h:197
ucol_getKeywordValues
U_CAPI UEnumeration * ucol_getKeywordValues(const char *keyword, UErrorCode *status)
Given a keyword, create a string enumeration of all values for that keyword that are currently in use...
ucol_getKeywordValuesForLocale
U_CAPI UEnumeration * ucol_getKeywordValuesForLocale(const char *key, const char *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...
ucol_mergeSortkeys
U_CAPI int32_t ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length, const uint8_t *src2, int32_t src2Length, uint8_t *dest, int32_t destCapacity)
Merges two sort keys.
UEnumeration
struct UEnumeration UEnumeration
structure representing an enumeration object instance
Definition uenum.h:44
uloc.h
C API: Locale ID functionality similar to C++ class Locale.
ULocDataLocaleType
ULocDataLocaleType
Constants for *_getLocale() Allow user to select whether she wants information on requested,...
Definition uloc.h:338
UChar
char16_t UChar
The base type for UTF-16 code units and pointers.
Definition umachine.h:378
U_DEPRECATED
#define U_DEPRECATED
This is used to declare a function as a deprecated public ICU C API
Definition umachine.h:116
UBool
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition umachine.h:247
U_CAPI
#define U_CAPI
This is used to declare a function as a public ICU C API.
Definition umachine.h:110
unistr.h
C++ API: Unicode String.
unorm.h
C API: Unicode Normalization.
uscript.h
C API: Unicode Script Information.
USCRIPT_UNKNOWN
@ USCRIPT_UNKNOWN
Definition uscript.h:287
uset.h
C API: Unicode Set.
USet
struct USet USet
USet is the C API type corresponding to C++ class UnicodeSet.
Definition uset.h:53
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:430
U_ZERO_ERROR
@ U_ZERO_ERROR
No error, no warning.
Definition utypes.h:465
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