ICU 59.1  59.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/localpointer.h"
19 #include "unicode/parseerr.h"
20 #include "unicode/uloc.h"
21 #include "unicode/uset.h"
22 #include "unicode/uscript.h"
23 
54 struct UCollator;
58 typedef struct UCollator UCollator;
59 
60 
73 typedef enum {
79  UCOL_LESS = -1
81 
82 
89 typedef enum {
92 
101  UCOL_CE_STRENGTH_LIMIT,
106  UCOL_STRENGTH_LIMIT,
107 
111  UCOL_OFF = 16,
115  UCOL_ON = 17,
116 
121 
127 
128 #ifndef U_HIDE_DEPRECATED_API
129 
134 #endif /* U_HIDE_DEPRECATED_API */
136 
146  typedef enum {
201 #ifndef U_HIDE_DEPRECATED_API
202 
207 #endif /* U_HIDE_DEPRECATED_API */
209 
237 
242 typedef enum {
311 #ifndef U_HIDE_DEPRECATED_API
312 
324 #endif /* U_HIDE_DEPRECATED_API */
325 
344 
345  /* Do not conditionalize the following with #ifndef U_HIDE_DEPRECATED_API,
346  * it is needed for layout of RuleBasedCollator object. */
352 } UColAttribute;
353 
357 typedef enum {
372 } UColRuleOption ;
373 
399 U_STABLE UCollator* U_EXPORT2
400 ucol_open(const char *loc, UErrorCode *status);
401 
427 U_STABLE UCollator* U_EXPORT2
428 ucol_openRules( const UChar *rules,
429  int32_t rulesLength,
430  UColAttributeValue normalizationMode,
431  UCollationStrength strength,
432  UParseError *parseError,
433  UErrorCode *status);
434 
435 #ifndef U_HIDE_DEPRECATED_API
436 
469 U_DEPRECATED UCollator* U_EXPORT2
470 ucol_openFromShortString( const char *definition,
471  UBool forceDefaults,
472  UParseError *parseError,
473  UErrorCode *status);
474 #endif /* U_HIDE_DEPRECATED_API */
475 
476 #ifndef U_HIDE_DEPRECATED_API
477 
490 U_DEPRECATED int32_t U_EXPORT2
491 ucol_getContractions( const UCollator *coll,
492  USet *conts,
493  UErrorCode *status);
494 #endif /* U_HIDE_DEPRECATED_API */
495 
507 U_STABLE void U_EXPORT2
509  USet *contractions, USet *expansions,
510  UBool addPrefixes, UErrorCode *status);
511 
522 U_STABLE void U_EXPORT2
523 ucol_close(UCollator *coll);
524 
525 #if U_SHOW_CPLUSPLUS_API
526 
528 
539 
541 
542 #endif
543 
559 U_STABLE UCollationResult U_EXPORT2
560 ucol_strcoll( const UCollator *coll,
561  const UChar *source,
562  int32_t sourceLength,
563  const UChar *target,
564  int32_t targetLength);
565 
584 U_STABLE UCollationResult U_EXPORT2
586  const UCollator *coll,
587  const char *source,
588  int32_t sourceLength,
589  const char *target,
590  int32_t targetLength,
591  UErrorCode *status);
592 
607 U_STABLE UBool U_EXPORT2
608 ucol_greater(const UCollator *coll,
609  const UChar *source, int32_t sourceLength,
610  const UChar *target, int32_t targetLength);
611 
626 U_STABLE UBool U_EXPORT2
627 ucol_greaterOrEqual(const UCollator *coll,
628  const UChar *source, int32_t sourceLength,
629  const UChar *target, int32_t targetLength);
630 
645 U_STABLE UBool U_EXPORT2
646 ucol_equal(const UCollator *coll,
647  const UChar *source, int32_t sourceLength,
648  const UChar *target, int32_t targetLength);
649 
662 U_STABLE UCollationResult U_EXPORT2
663 ucol_strcollIter( const UCollator *coll,
664  UCharIterator *sIter,
665  UCharIterator *tIter,
666  UErrorCode *status);
667 
677 U_STABLE UCollationStrength U_EXPORT2
678 ucol_getStrength(const UCollator *coll);
679 
689 U_STABLE void U_EXPORT2
691  UCollationStrength strength);
692 
709 U_STABLE int32_t U_EXPORT2
710 ucol_getReorderCodes(const UCollator* coll,
711  int32_t* dest,
712  int32_t destCapacity,
713  UErrorCode *pErrorCode);
754 U_STABLE void U_EXPORT2
756  const int32_t* reorderCodes,
757  int32_t reorderCodesLength,
758  UErrorCode *pErrorCode);
759 
779 U_STABLE int32_t U_EXPORT2
780 ucol_getEquivalentReorderCodes(int32_t reorderCode,
781  int32_t* dest,
782  int32_t destCapacity,
783  UErrorCode *pErrorCode);
784 
797 U_STABLE int32_t U_EXPORT2
798 ucol_getDisplayName( const char *objLoc,
799  const char *dispLoc,
800  UChar *result,
801  int32_t resultLength,
802  UErrorCode *status);
803 
813 U_STABLE const char* U_EXPORT2
814 ucol_getAvailable(int32_t localeIndex);
815 
824 U_STABLE int32_t U_EXPORT2
825 ucol_countAvailable(void);
826 
827 #if !UCONFIG_NO_SERVICE
828 
836 U_STABLE UEnumeration* U_EXPORT2
838 #endif
839 
849 U_STABLE UEnumeration* U_EXPORT2
851 
863 U_STABLE UEnumeration* U_EXPORT2
864 ucol_getKeywordValues(const char *keyword, UErrorCode *status);
865 
882 U_STABLE UEnumeration* U_EXPORT2
883 ucol_getKeywordValuesForLocale(const char* key,
884  const char* locale,
885  UBool commonlyUsed,
886  UErrorCode* status);
887 
919 U_STABLE int32_t U_EXPORT2
920 ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
921  const char* keyword, const char* locale,
922  UBool* isAvailable, UErrorCode* status);
923 
932 U_STABLE const UChar* U_EXPORT2
933 ucol_getRules( const UCollator *coll,
934  int32_t *length);
935 
936 #ifndef U_HIDE_DEPRECATED_API
937 
957 U_DEPRECATED int32_t U_EXPORT2
959  const char *locale,
960  char *buffer,
961  int32_t capacity,
962  UErrorCode *status);
963 
984 U_DEPRECATED int32_t U_EXPORT2
985 ucol_normalizeShortDefinitionString(const char *source,
986  char *destination,
987  int32_t capacity,
988  UParseError *parseError,
989  UErrorCode *status);
990 #endif /* U_HIDE_DEPRECATED_API */
991 
992 
1015 U_STABLE int32_t U_EXPORT2
1016 ucol_getSortKey(const UCollator *coll,
1017  const UChar *source,
1018  int32_t sourceLength,
1019  uint8_t *result,
1020  int32_t resultLength);
1021 
1022 
1043 U_STABLE int32_t U_EXPORT2
1044 ucol_nextSortKeyPart(const UCollator *coll,
1045  UCharIterator *iter,
1046  uint32_t state[2],
1047  uint8_t *dest, int32_t count,
1048  UErrorCode *status);
1049 
1057 typedef enum {
1064 #ifndef U_HIDE_DEPRECATED_API
1065 
1070 #endif /* U_HIDE_DEPRECATED_API */
1071 } UColBoundMode;
1072 
1110 U_STABLE int32_t U_EXPORT2
1111 ucol_getBound(const uint8_t *source,
1112  int32_t sourceLength,
1113  UColBoundMode boundType,
1114  uint32_t noOfLevels,
1115  uint8_t *result,
1116  int32_t resultLength,
1117  UErrorCode *status);
1118 
1127 U_STABLE void U_EXPORT2
1128 ucol_getVersion(const UCollator* coll, UVersionInfo info);
1129 
1137 U_STABLE void U_EXPORT2
1138 ucol_getUCAVersion(const UCollator* coll, UVersionInfo info);
1139 
1187 U_STABLE int32_t U_EXPORT2
1188 ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length,
1189  const uint8_t *src2, int32_t src2Length,
1190  uint8_t *dest, int32_t destCapacity);
1191 
1203 U_STABLE void U_EXPORT2
1205 
1217 U_STABLE UColAttributeValue U_EXPORT2
1218 ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status);
1219 
1236 U_STABLE void U_EXPORT2
1237 ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCode);
1238 
1246 U_STABLE UColReorderCode U_EXPORT2
1247 ucol_getMaxVariable(const UCollator *coll);
1248 
1249 #ifndef U_HIDE_DEPRECATED_API
1250 
1270 U_DEPRECATED uint32_t U_EXPORT2
1272  const UChar *varTop, int32_t len,
1273  UErrorCode *status);
1274 #endif /* U_HIDE_DEPRECATED_API */
1275 
1287 U_STABLE uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status);
1288 
1289 #ifndef U_HIDE_DEPRECATED_API
1290 
1303 U_DEPRECATED void U_EXPORT2
1304 ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status);
1305 #endif /* U_HIDE_DEPRECATED_API */
1306 
1330 U_STABLE UCollator* U_EXPORT2
1331 ucol_safeClone(const UCollator *coll,
1332  void *stackBuffer,
1333  int32_t *pBufferSize,
1334  UErrorCode *status);
1335 
1336 #ifndef U_HIDE_DEPRECATED_API
1337 
1341 #define U_COL_SAFECLONE_BUFFERSIZE 1
1342 
1343 #endif /* U_HIDE_DEPRECATED_API */
1344 
1360 U_STABLE int32_t U_EXPORT2
1361 ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen);
1362 
1363 #ifndef U_HIDE_DEPRECATED_API
1364 
1378 U_DEPRECATED const char * U_EXPORT2
1379 ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);
1380 #endif /* U_HIDE_DEPRECATED_API */
1381 
1396 U_STABLE const char * U_EXPORT2
1397 ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);
1398 
1409 U_STABLE USet * U_EXPORT2
1410 ucol_getTailoredSet(const UCollator *coll, UErrorCode *status);
1411 
1412 #ifndef U_HIDE_INTERNAL_API
1413 
1424 U_INTERNAL int32_t U_EXPORT2
1425 ucol_getUnsafeSet( const UCollator *coll,
1426  USet *unsafe,
1427  UErrorCode *status);
1428 
1449 U_INTERNAL void U_EXPORT2
1450 ucol_prepareShortStringOpen( const char *definition,
1451  UBool forceDefaults,
1452  UParseError *parseError,
1453  UErrorCode *status);
1454 #endif /* U_HIDE_INTERNAL_API */
1455 
1467 U_STABLE int32_t U_EXPORT2
1468 ucol_cloneBinary(const UCollator *coll,
1469  uint8_t *buffer, int32_t capacity,
1470  UErrorCode *status);
1471 
1489 U_STABLE UCollator* U_EXPORT2
1490 ucol_openBinary(const uint8_t *bin, int32_t length,
1491  const UCollator *base,
1492  UErrorCode *status);
1493 
1494 
1495 #endif /* #if !UCONFIG_NO_COLLATION */
1496 
1497 #endif
"Smart pointer" class, closes a UCollator via ucol_close().
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
const UChar * ucol_getRules(const UCollator *coll, int32_t *length)
Get the collation tailoring rules from a UCollator.
Characters with the currency property.
Definition: ucol.h:194
string a < string b
Definition: ucol.h:79
Turn the feature on - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MODE...
Definition: ucol.h:115
Characters with the symbol property.
Definition: ucol.h:188
void ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCode)
Sets the variable top to the top of the specified reordering group.
Retrieves the "UCA rules" concatenated with the tailoring rules.
Definition: ucol.h:371
UBool ucol_equal(const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
Compare two strings for equality.
A special reordering code that is used to specify all other codes used for reordering except for the ...
Definition: ucol.h:164
UColAttributeValue ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status)
Universal attribute getter.
void ucol_getUCAVersion(const UCollator *coll, UVersionInfo info)
Gets the UCA version information for a Collator.
UCollationResult ucol_strcoll(const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
Compare two strings.
upper bound that will match all the strings that have the same initial substring as the given string ...
Definition: ucol.h:1063
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.
One more than the highest normal UColAttributeValue value.
Definition: ucol.h:133
lower bound
Definition: ucol.h:1059
Controls the ordering of upper and lower case letters.
Definition: ucol.h:269
int32_t ucol_getReorderCodes(const UCollator *coll, int32_t *dest, int32_t destCapacity, UErrorCode *pErrorCode)
Retrieves the reordering codes for this collator.
UCollationResult
UCOL_LESS is returned if source string is compared to be less than target string in the ucol_strcoll(...
Definition: ucol.h:73
Retrieves the tailoring rules only.
Definition: ucol.h:363
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.
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.
Valid for UCOL_ALTERNATE_HANDLING.
Definition: ucol.h:120
Controls whether the normalization check and necessary normalizations are performed.
Definition: ucol.h:289
struct UEnumeration UEnumeration
structure representing an enumeration object instance
Definition: uenum.h:43
int32_t ucol_countAvailable(void)
Determine how many locales have collation rules available.
void ucol_getContractionsAndExpansions(const UCollator *coll, USet *contractions, USet *expansions, UBool addPrefixes, UErrorCode *status)
Get a set containing the expansions defined by the collator.
C API for code unit iteration.
Definition: uiter.h:341
USet * ucol_getTailoredSet(const UCollator *coll, UErrorCode *status)
Get a Unicode set that contains all the characters and sequences tailored in this collator...
accepted by most attributes
Definition: ucol.h:91
#define U_INTERNAL
This is used to declare a function as an internal ICU C API.
Definition: umachine.h:119
string a == string b
Definition: ucol.h:75
int32_t ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen)
Returns current rules.
UColAttributeValue UCollationStrength
Base letter represents a primary difference.
Definition: ucol.h:236
Characters with the digit property.
Definition: ucol.h:200
Default collation strength.
Definition: ucol.h:100
Valid for UCOL_CASE_FIRST - lower case sorts before upper case.
Definition: ucol.h:124
C API: Unicode Script Information.
C API: Unicode Set.
UColReorderCode
Enum containing the codes for reordering segments of the collation table that are not script codes...
Definition: ucol.h:146
void ucol_setReorderCodes(UCollator *coll, const int32_t *reorderCodes, int32_t reorderCodesLength, UErrorCode *pErrorCode)
Sets the reordering codes for this collator.
UColAttribute
Attributes that collation service understands.
Definition: ucol.h:242
Turn the feature off - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MOD...
Definition: ucol.h:111
#define U_DEPRECATED
This is used to declare a function as a deprecated public ICU C API.
Definition: umachine.h:115
uint32_t ucol_getVariableTop(const UCollator *coll, UErrorCode *status)
Gets the variable top value of a Collator.
UEnumeration * ucol_openAvailableLocales(UErrorCode *status)
Create a string enumerator of all locales for which a valid collator may be opened.
A special reordering code that is used to specify no reordering codes.
Definition: ucol.h:157
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:131
upper bound that will match strings of exact size
Definition: ucol.h:1061
Attribute for direction of secondary weights - used in Canadian French.
Definition: ucol.h:249
The strength attribute.
Definition: ucol.h:310
When turned on, this attribute makes substrings of digits sort according to their numeric values...
Definition: ucol.h:343
int32_t ucol_cloneBinary(const UCollator *coll, uint8_t *buffer, int32_t capacity, UErrorCode *status)
Creates a binary image of a collator.
Secondary collation strength.
Definition: ucol.h:96
#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction)
"Smart pointer" definition macro, deletes objects via the closeFunction.
Definition: localpointer.h:496
void ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status)
Sets the variable top to the specified primary weight.
When turned on, this attribute positions Hiragana before all non-ignorables on quaternary level This ...
Definition: ucol.h:323
Controls whether an extra case level (positioned before the third level) is generated or not...
Definition: ucol.h:279
C++ API: "Smart pointers" for use with and in ICU4C C++ code.
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.
C API: Unicode Normalization.
int32_t ucol_getContractions(const UCollator *coll, USet *conts, UErrorCode *status)
Get a set containing the contractions defined by the collator.
upper case sorts before lower case
Definition: ucol.h:126
The first entry in the enumeration of reordering groups.
Definition: ucol.h:176
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.
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.
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, thus filling up the cache.
const char * ucol_getAvailable(int32_t localeIndex)
Get a locale for which collation rules are available.
void ucol_close(UCollator *coll)
Close a UCollator.
Tertiary collation strength.
Definition: ucol.h:98
UCollationResult ucol_strcollIter(const UCollator *coll, UCharIterator *sIter, UCharIterator *tIter, UErrorCode *status)
Compare two UTF-8 encoded trings.
int32_t ucol_getDisplayName(const char *objLoc, const char *dispLoc, UChar *result, int32_t resultLength, UErrorCode *status)
Get the display name for a UCollator.
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...
A special reordering code that is used to specify the default reordering codes for a locale...
Definition: ucol.h:152
const char * ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status)
gets the locale name of the collator.
void ucol_getVersion(const UCollator *coll, UVersionInfo info)
Gets the version information for a Collator.
uint16_t UChar
The base type for UTF-16 code units and pointers.
Definition: umachine.h:349
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:132
struct USet USet
Definition: ucnv.h:69
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.
string a > string b
Definition: ucol.h:77
C API: Parse Error Information.
int32_t ucol_normalizeShortDefinitionString(const char *source, char *destination, int32_t capacity, UParseError *parseError, UErrorCode *status)
Verifies and normalizes short definition string.
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.
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.
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.
void ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status)
Universal attribute setter.
One more than the highest normal UColBoundMode value.
Definition: ucol.h:1069
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:396
ULocDataLocaleType
Constants for *_getLocale() Allow user to select whether she wants information on requested...
Definition: uloc.h:338
int32_t ucol_getUnsafeSet(const UCollator *coll, USet *unsafe, UErrorCode *status)
Calculates the set of unsafe code points, given a collator.
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...
const char * ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status)
gets the locale name of the collator.
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...
Characters with the punctuation property.
Definition: ucol.h:182
UColBoundMode
enum that is taken by ucol_getBound API See below for explanation do not change the values assigned t...
Definition: ucol.h:1057
void ucol_setStrength(UCollator *coll, UCollationStrength strength)
Set the collation strength used in a UCollator.
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.
struct UCollator UCollator
structure representing a collator object instance
Definition: ucol.h:58
UColReorderCode ucol_getMaxVariable(const UCollator *coll)
Returns the maximum reordering group whose characters are affected by UCOL_ALTERNATE_HANDLING.
Valid for UCOL_ALTERNATE_HANDLING.
Definition: ucol.h:118
A UParseError struct is used to returned detailed information about parsing errors.
Definition: parseerr.h:58
UCollator * ucol_safeClone(const UCollator *coll, void *stackBuffer, int32_t *pBufferSize, UErrorCode *status)
Thread safe cloning operation.
Basic definitions for ICU, for both C and C++ APIs.
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.
Identical collation strength.
Definition: ucol.h:105
UCollator * ucol_openFromShortString(const char *definition, UBool forceDefaults, UParseError *parseError, UErrorCode *status)
Open a collator defined by a short form string.
Quaternary collation strength.
Definition: ucol.h:103
Attribute for handling variable elements.
Definition: ucol.h:260
An alias for UCOL_NORMALIZATION_MODE attribute.
Definition: ucol.h:293
UColAttributeValue
Enum containing attribute values for controling collation behavior.
Definition: ucol.h:89
UEnumeration * ucol_getKeywords(UErrorCode *status)
Create a string enumerator of all possible keywords that are relevant to collation.
UCollator * ucol_open(const char *loc, UErrorCode *status)
Open a UCollator for comparing strings.
Characters with the space property.
Definition: ucol.h:170
UColRuleOption
Options for retrieving the rule string.
Definition: ucol.h:357
One more than the highest normal UColAttribute value.
Definition: ucol.h:351
UCollationStrength ucol_getStrength(const UCollator *coll)
Get the collation strength used in a UCollator.
Primary collation strength.
Definition: ucol.h:94
#define U_STABLE
This is used to declare a function as a stable public ICU C API.
Definition: umachine.h:111
int8_t UBool
The ICU boolean type.
Definition: umachine.h:236
One more than the highest normal UColReorderCode value.
Definition: ucol.h:206
C API: Locale.