ICU 52.1  52.1
ucol.h
Go to the documentation of this file.
1 /*
2 *******************************************************************************
3 * Copyright (c) 1996-2013, International Business Machines Corporation and others.
4 * All Rights Reserved.
5 *******************************************************************************
6 */
7 
8 #ifndef UCOL_H
9 #define UCOL_H
10 
11 #include "unicode/utypes.h"
12 
13 #if !UCONFIG_NO_COLLATION
14 
15 #include "unicode/unorm.h"
16 #include "unicode/localpointer.h"
17 #include "unicode/parseerr.h"
18 #include "unicode/uloc.h"
19 #include "unicode/uset.h"
20 #include "unicode/uscript.h"
21 
58 struct UCollator;
62 typedef struct UCollator UCollator;
63 
64 
77 typedef enum {
83  UCOL_LESS = -1
85 
86 
93 typedef enum {
96 
105  UCOL_CE_STRENGTH_LIMIT,
110  UCOL_STRENGTH_LIMIT,
111 
115  UCOL_OFF = 16,
119  UCOL_ON = 17,
120 
125 
131 
132  UCOL_ATTRIBUTE_VALUE_COUNT
133 
135 
145  typedef enum {
207 
235 
240 typedef enum {
305 #ifndef U_HIDE_DEPRECATED_API
306 
317 #endif /* U_HIDE_DEPRECATED_API */
318 
333 } UColAttribute;
334 
338 typedef enum {
353 } UColRuleOption ;
354 
372 U_STABLE UCollator* U_EXPORT2
373 ucol_open(const char *loc, UErrorCode *status);
374 
400 U_STABLE UCollator* U_EXPORT2
401 ucol_openRules( const UChar *rules,
402  int32_t rulesLength,
403  UColAttributeValue normalizationMode,
404  UCollationStrength strength,
405  UParseError *parseError,
406  UErrorCode *status);
407 
442 U_STABLE UCollator* U_EXPORT2
443 ucol_openFromShortString( const char *definition,
444  UBool forceDefaults,
445  UParseError *parseError,
446  UErrorCode *status);
447 
448 #ifndef U_HIDE_DEPRECATED_API
449 
462 U_DEPRECATED int32_t U_EXPORT2
463 ucol_getContractions( const UCollator *coll,
464  USet *conts,
465  UErrorCode *status);
466 #endif /* U_HIDE_DEPRECATED_API */
467 
479 U_STABLE void U_EXPORT2
481  USet *contractions, USet *expansions,
482  UBool addPrefixes, UErrorCode *status);
483 
494 U_STABLE void U_EXPORT2
495 ucol_close(UCollator *coll);
496 
497 #if U_SHOW_CPLUSPLUS_API
498 
500 
511 
513 
514 #endif
515 
531 U_STABLE UCollationResult U_EXPORT2
532 ucol_strcoll( const UCollator *coll,
533  const UChar *source,
534  int32_t sourceLength,
535  const UChar *target,
536  int32_t targetLength);
537 
556 U_STABLE UCollationResult U_EXPORT2
558  const UCollator *coll,
559  const char *source,
560  int32_t sourceLength,
561  const char *target,
562  int32_t targetLength,
563  UErrorCode *status);
564 
579 U_STABLE UBool U_EXPORT2
580 ucol_greater(const UCollator *coll,
581  const UChar *source, int32_t sourceLength,
582  const UChar *target, int32_t targetLength);
583 
598 U_STABLE UBool U_EXPORT2
599 ucol_greaterOrEqual(const UCollator *coll,
600  const UChar *source, int32_t sourceLength,
601  const UChar *target, int32_t targetLength);
602 
617 U_STABLE UBool U_EXPORT2
618 ucol_equal(const UCollator *coll,
619  const UChar *source, int32_t sourceLength,
620  const UChar *target, int32_t targetLength);
621 
634 U_STABLE UCollationResult U_EXPORT2
635 ucol_strcollIter( const UCollator *coll,
636  UCharIterator *sIter,
637  UCharIterator *tIter,
638  UErrorCode *status);
639 
649 U_STABLE UCollationStrength U_EXPORT2
650 ucol_getStrength(const UCollator *coll);
651 
661 U_STABLE void U_EXPORT2
663  UCollationStrength strength);
664 
681 U_STABLE int32_t U_EXPORT2
682 ucol_getReorderCodes(const UCollator* coll,
683  int32_t* dest,
684  int32_t destCapacity,
685  UErrorCode *pErrorCode);
721 U_STABLE void U_EXPORT2
723  const int32_t* reorderCodes,
724  int32_t reorderCodesLength,
725  UErrorCode *pErrorCode);
726 
743 U_STABLE int32_t U_EXPORT2
744 ucol_getEquivalentReorderCodes(int32_t reorderCode,
745  int32_t* dest,
746  int32_t destCapacity,
747  UErrorCode *pErrorCode);
748 
761 U_STABLE int32_t U_EXPORT2
762 ucol_getDisplayName( const char *objLoc,
763  const char *dispLoc,
764  UChar *result,
765  int32_t resultLength,
766  UErrorCode *status);
767 
777 U_STABLE const char* U_EXPORT2
778 ucol_getAvailable(int32_t localeIndex);
779 
788 U_STABLE int32_t U_EXPORT2
789 ucol_countAvailable(void);
790 
791 #if !UCONFIG_NO_SERVICE
792 
800 U_STABLE UEnumeration* U_EXPORT2
802 #endif
803 
813 U_STABLE UEnumeration* U_EXPORT2
815 
827 U_STABLE UEnumeration* U_EXPORT2
828 ucol_getKeywordValues(const char *keyword, UErrorCode *status);
829 
846 U_STABLE UEnumeration* U_EXPORT2
847 ucol_getKeywordValuesForLocale(const char* key,
848  const char* locale,
849  UBool commonlyUsed,
850  UErrorCode* status);
851 
882 U_STABLE int32_t U_EXPORT2
883 ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
884  const char* keyword, const char* locale,
885  UBool* isAvailable, UErrorCode* status);
886 
895 U_STABLE const UChar* U_EXPORT2
896 ucol_getRules( const UCollator *coll,
897  int32_t *length);
898 
919 U_STABLE int32_t U_EXPORT2
921  const char *locale,
922  char *buffer,
923  int32_t capacity,
924  UErrorCode *status);
925 
946 U_STABLE int32_t U_EXPORT2
947 ucol_normalizeShortDefinitionString(const char *source,
948  char *destination,
949  int32_t capacity,
950  UParseError *parseError,
951  UErrorCode *status);
952 
953 
973 U_STABLE int32_t U_EXPORT2
974 ucol_getSortKey(const UCollator *coll,
975  const UChar *source,
976  int32_t sourceLength,
977  uint8_t *result,
978  int32_t resultLength);
979 
980 
1001 U_STABLE int32_t U_EXPORT2
1002 ucol_nextSortKeyPart(const UCollator *coll,
1003  UCharIterator *iter,
1004  uint32_t state[2],
1005  uint8_t *dest, int32_t count,
1006  UErrorCode *status);
1007 
1015 typedef enum {
1022  UCOL_BOUND_VALUE_COUNT
1023 } UColBoundMode;
1024 
1062 U_STABLE int32_t U_EXPORT2
1063 ucol_getBound(const uint8_t *source,
1064  int32_t sourceLength,
1065  UColBoundMode boundType,
1066  uint32_t noOfLevels,
1067  uint8_t *result,
1068  int32_t resultLength,
1069  UErrorCode *status);
1070 
1079 U_STABLE void U_EXPORT2
1080 ucol_getVersion(const UCollator* coll, UVersionInfo info);
1081 
1089 U_STABLE void U_EXPORT2
1090 ucol_getUCAVersion(const UCollator* coll, UVersionInfo info);
1091 
1128 U_STABLE int32_t U_EXPORT2
1129 ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length,
1130  const uint8_t *src2, int32_t src2Length,
1131  uint8_t *dest, int32_t destCapacity);
1132 
1144 U_STABLE void U_EXPORT2
1146 
1158 U_STABLE UColAttributeValue U_EXPORT2
1159 ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status);
1160 
1180 U_STABLE uint32_t U_EXPORT2
1182  const UChar *varTop, int32_t len,
1183  UErrorCode *status);
1184 
1196 U_STABLE uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status);
1197 
1209 U_STABLE void U_EXPORT2
1210 ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status);
1211 
1235 U_STABLE UCollator* U_EXPORT2
1236 ucol_safeClone(const UCollator *coll,
1237  void *stackBuffer,
1238  int32_t *pBufferSize,
1239  UErrorCode *status);
1240 
1241 #ifndef U_HIDE_DEPRECATED_API
1242 
1246 #define U_COL_SAFECLONE_BUFFERSIZE 1
1247 
1248 #endif /* U_HIDE_DEPRECATED_API */
1249 
1265 U_STABLE int32_t U_EXPORT2
1266 ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen);
1267 
1268 #ifndef U_HIDE_DEPRECATED_API
1269 
1283 U_DEPRECATED const char * U_EXPORT2
1284 ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);
1285 #endif /* U_HIDE_DEPRECATED_API */
1286 
1301 U_STABLE const char * U_EXPORT2
1302 ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);
1303 
1314 U_STABLE USet * U_EXPORT2
1315 ucol_getTailoredSet(const UCollator *coll, UErrorCode *status);
1316 
1317 #ifndef U_HIDE_INTERNAL_API
1318 
1330 ucol_getAttributeOrDefault(const UCollator *coll, UColAttribute attr, UErrorCode *status);
1331 
1340 U_INTERNAL UBool U_EXPORT2
1341 ucol_equals(const UCollator *source, const UCollator *target);
1342 
1354 U_INTERNAL int32_t U_EXPORT2
1355 ucol_getUnsafeSet( const UCollator *coll,
1356  USet *unsafe,
1357  UErrorCode *status);
1358 
1362 U_INTERNAL void U_EXPORT2
1363 ucol_forgetUCA(void);
1364 
1385 U_INTERNAL void U_EXPORT2
1386 ucol_prepareShortStringOpen( const char *definition,
1387  UBool forceDefaults,
1388  UParseError *parseError,
1389  UErrorCode *status);
1390 #endif /* U_HIDE_INTERNAL_API */
1391 
1403 U_STABLE int32_t U_EXPORT2
1404 ucol_cloneBinary(const UCollator *coll,
1405  uint8_t *buffer, int32_t capacity,
1406  UErrorCode *status);
1407 
1425 U_STABLE UCollator* U_EXPORT2
1426 ucol_openBinary(const uint8_t *bin, int32_t length,
1427  const UCollator *base,
1428  UErrorCode *status);
1429 
1430 
1431 #endif /* #if !UCONFIG_NO_COLLATION */
1432 
1433 #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:57
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:193
string a < string b
Definition: ucol.h:83
Turn the feature on - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MODE...
Definition: ucol.h:119
Characters with the symbol property.
Definition: ucol.h:187
Retrieves the "UCA rules" concatenated with the tailoring rules.
Definition: ucol.h:352
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:163
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:1021
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.
lower bound
Definition: ucol.h:1017
Controls the ordering of upper and lower case letters.
Definition: ucol.h:267
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:77
Retrieves the tailoring rules only.
Definition: ucol.h:344
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)
Variable top is a two byte primary value which causes all the codepoints with primary values that are...
Valid for UCOL_ALTERNATE_HANDLING.
Definition: ucol.h:124
Controls whether the normalization check and necessary normalizations are performed.
Definition: ucol.h:287
struct UEnumeration UEnumeration
structure representing an enumeration object instance
Definition: uenum.h:39
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:339
USet * ucol_getTailoredSet(const UCollator *coll, UErrorCode *status)
Get an Unicode set that contains all the characters and sequences tailored in this collator...
accepted by most attributes
Definition: ucol.h:95
#define U_INTERNAL
This is used to declare a function as an internal ICU C API.
Definition: umachine.h:117
string a == string b
Definition: ucol.h:79
int32_t ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen)
Returns current rules.
UColAttributeValue ucol_getAttributeOrDefault(const UCollator *coll, UColAttribute attr, UErrorCode *status)
Universal attribute getter that returns UCOL_DEFAULT if the value is default.
UColAttributeValue UCollationStrength
Base letter represents a primary difference.
Definition: ucol.h:234
Characters with the digit property.
Definition: ucol.h:199
Default collation strength.
Definition: ucol.h:104
Valid for UCOL_CASE_FIRST - lower case sorts before upper case.
Definition: ucol.h:128
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:145
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:240
Turn the feature off - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MOD...
Definition: ucol.h:115
#define U_DEPRECATED
This is used to declare a function as a deprecated public ICU C API.
Definition: umachine.h:113
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:156
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:129
UBool ucol_equals(const UCollator *source, const UCollator *target)
Check whether two collators are equal.
upper bound that will match strings of exact size
Definition: ucol.h:1019
Attribute for direction of secondary weights - used in Canadian French.
Definition: ucol.h:247
The strength attribute.
Definition: ucol.h:304
When turned on, this attribute generates a collation key for the numeric value of substrings of digit...
Definition: ucol.h:327
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:100
#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction)
"Smart pointer" definition macro, deletes objects via the closeFunction.
Definition: localpointer.h:290
void ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status)
Sets the variable top to a collation element value supplied.
When turned on, this attribute positions Hiragana before all non-ignorables on quaternary level This ...
Definition: ucol.h:316
Controls whether an extra case level (positioned before the third level) is generated or not...
Definition: ucol.h:277
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:130
The first entry in the enumeration of reordering groups.
Definition: ucol.h:175
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:102
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:151
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
Define UChar to be UCHAR_TYPE, if that is #defined (for example, to char16_t), or wchar_t if that is ...
Definition: umachine.h:278
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:130
struct USet USet
Definition: ucnv.h:67
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:81
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 an UCollator instance according to the rules supplied.
void ucol_forgetUCA(void)
Reset UCA's static pointers.
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.
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:476
ULocDataLocaleType
Constants for *_getLocale() Allow user to select whether she wants information on requested...
Definition: uloc.h:336
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 given requested locale, with respect to given keywo...
Characters with the punctuation property.
Definition: ucol.h:181
UColBoundMode
enum that is taken by ucol_getBound API See below for explanation do not change the values assigned t...
Definition: ucol.h:1015
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:62
Valid for UCOL_ALTERNATE_HANDLING.
Definition: ucol.h:122
A UParseError struct is used to returned detailed information about parsing errors.
Definition: parseerr.h:56
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:109
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:107
Attribute for handling variable elements.
Definition: ucol.h:258
An alias for UCOL_NORMALIZATION_MODE attribute.
Definition: ucol.h:291
UColAttributeValue
Enum containing attribute values for controling collation behavior.
Definition: ucol.h:93
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:169
UColRuleOption
Options for retrieving the rule string.
Definition: ucol.h:338
The number of UColAttribute constants.
Definition: ucol.h:332
UCollationStrength ucol_getStrength(const UCollator *coll)
Get the collation strength used in a UCollator.
Primary collation strength.
Definition: ucol.h:98
#define U_STABLE
This is used to declare a function as a stable public ICU C API.
Definition: umachine.h:109
int8_t UBool
The ICU boolean type.
Definition: umachine.h:200
The limit of the reorder codes.
Definition: ucol.h:205
C API: Locale.