ICU 4.8.1.1  4.8.1.1
Defines | Typedefs | Enumerations | Functions
ucol.h File Reference

C API: Collator. More...

#include "unicode/utypes.h"
#include "unicode/unorm.h"
#include "unicode/localpointer.h"
#include "unicode/parseerr.h"
#include "unicode/uloc.h"
#include "unicode/uset.h"
#include "unicode/uscript.h"

Go to the source code of this file.

Defines

#define U_COL_SAFECLONE_BUFFERSIZE   512
 default memory size for the new clone.

Typedefs

typedef struct UCollator UCollator
 structure representing a collator object instance
typedef UColAttributeValue UCollationStrength
 Base letter represents a primary difference.

Enumerations

enum  UCollationResult { UCOL_EQUAL = 0, UCOL_GREATER = 1, UCOL_LESS = -1 }
 UCOL_LESS is returned if source string is compared to be less than target string in the u_strcoll() method. More...
enum  UColAttributeValue {
  UCOL_DEFAULT = -1, UCOL_PRIMARY = 0, UCOL_SECONDARY = 1, UCOL_TERTIARY = 2,
  UCOL_DEFAULT_STRENGTH = UCOL_TERTIARY, UCOL_CE_STRENGTH_LIMIT, UCOL_QUATERNARY = 3, UCOL_IDENTICAL = 15,
  UCOL_STRENGTH_LIMIT, UCOL_OFF = 16, UCOL_ON = 17, UCOL_SHIFTED = 20,
  UCOL_NON_IGNORABLE = 21, UCOL_LOWER_FIRST = 24, UCOL_UPPER_FIRST = 25, UCOL_ATTRIBUTE_VALUE_COUNT
}
 Enum containing attribute values for controling collation behavior. More...
enum  UColReorderCode {
  UCOL_REORDER_CODE_DEFAULT = -1, UCOL_REORDER_CODE_NONE = USCRIPT_UNKNOWN, UCOL_REORDER_CODE_OTHERS = USCRIPT_UNKNOWN, UCOL_REORDER_CODE_SPACE = 0x1000,
  UCOL_REORDER_CODE_FIRST = UCOL_REORDER_CODE_SPACE, UCOL_REORDER_CODE_PUNCTUATION = 0x1001, UCOL_REORDER_CODE_SYMBOL = 0x1002, UCOL_REORDER_CODE_CURRENCY = 0x1003,
  UCOL_REORDER_CODE_DIGIT = 0x1004, UCOL_REORDER_CODE_LIMIT = 0x1005
}
 Enum containing the codes for reordering segments of the collation table that are not script codes. More...
enum  UColAttribute {
  UCOL_FRENCH_COLLATION, UCOL_ALTERNATE_HANDLING, UCOL_CASE_FIRST, UCOL_CASE_LEVEL,
  UCOL_NORMALIZATION_MODE, UCOL_DECOMPOSITION_MODE = UCOL_NORMALIZATION_MODE, UCOL_STRENGTH, UCOL_HIRAGANA_QUATERNARY_MODE,
  UCOL_NUMERIC_COLLATION, UCOL_ATTRIBUTE_COUNT
}
 Attributes that collation service understands. More...
enum  UColRuleOption { UCOL_TAILORING_ONLY, UCOL_FULL_RULES }
 Options for retrieving the rule string. More...
enum  UColBoundMode { UCOL_BOUND_LOWER = 0, UCOL_BOUND_UPPER = 1, UCOL_BOUND_UPPER_LONG = 2, UCOL_BOUND_VALUE_COUNT }
 enum that is taken by ucol_getBound API See below for explanation do not change the values assigned to the members of this enum. More...

Functions

UCollatorucol_open (const char *loc, UErrorCode *status)
 Open a UCollator for comparing strings.
UCollatorucol_openRules (const UChar *rules, int32_t rulesLength, UColAttributeValue normalizationMode, UCollationStrength strength, UParseError *parseError, UErrorCode *status)
 Produce an UCollator instance according to the rules supplied.
UCollatorucol_openFromShortString (const char *definition, UBool forceDefaults, UParseError *parseError, UErrorCode *status)
 Open a collator defined by a short form string.
int32_t ucol_getContractions (const UCollator *coll, USet *conts, UErrorCode *status)
 Get a set containing the contractions defined by the collator.
void ucol_getContractionsAndExpansions (const UCollator *coll, USet *contractions, USet *expansions, UBool addPrefixes, UErrorCode *status)
 Get a set containing the expansions defined by the collator.
void ucol_close (UCollator *coll)
 Close a UCollator.
UCollationResult ucol_strcoll (const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
 Compare two strings.
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.
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.
UBool ucol_equal (const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength)
 Compare two strings for equality.
UCollationResult ucol_strcollIter (const UCollator *coll, UCharIterator *sIter, UCharIterator *tIter, UErrorCode *status)
 Compare two UTF-8 encoded trings.
UCollationStrength ucol_getStrength (const UCollator *coll)
 Get the collation strength used in a UCollator.
void ucol_setStrength (UCollator *coll, UCollationStrength strength)
 Set the collation strength used in a UCollator.
int32_t ucol_getReorderCodes (const UCollator *coll, int32_t *dest, int32_t destCapacity, UErrorCode *pErrorCode)
 Retrieves the reordering codes for this collator.
void ucol_setReorderCodes (UCollator *coll, const int32_t *reorderCodes, int32_t reorderCodesLength, UErrorCode *pErrorCode)
 Sets the reordering codes for this collator.
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.
int32_t ucol_getDisplayName (const char *objLoc, const char *dispLoc, UChar *result, int32_t resultLength, UErrorCode *status)
 Get the display name for a UCollator.
const char * ucol_getAvailable (int32_t localeIndex)
 Get a locale for which collation rules are available.
int32_t ucol_countAvailable (void)
 Determine how many locales have collation rules available.
UEnumerationucol_openAvailableLocales (UErrorCode *status)
 Create a string enumerator of all locales for which a valid collator may be opened.
UEnumerationucol_getKeywords (UErrorCode *status)
 Create a string enumerator of all possible keywords that are relevant to collation.
UEnumerationucol_getKeywordValues (const char *keyword, UErrorCode *status)
 Given a keyword, create a string enumeration of all values for that keyword that are currently in use.
UEnumerationucol_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 difference.
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 keyword, for the collation service.
const UCharucol_getRules (const UCollator *coll, int32_t *length)
 Get the collation rules from a UCollator.
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.
int32_t ucol_normalizeShortDefinitionString (const char *source, char *destination, int32_t capacity, UParseError *parseError, UErrorCode *status)
 Verifies and normalizes short definition string.
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.
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.
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.
void ucol_getVersion (const UCollator *coll, UVersionInfo info)
 Gets the version information for a Collator.
void ucol_getUCAVersion (const UCollator *coll, UVersionInfo info)
 Gets the UCA version information for a Collator.
int32_t ucol_mergeSortkeys (const uint8_t *src1, int32_t src1Length, const uint8_t *src2, int32_t src2Length, uint8_t *dest, int32_t destCapacity)
 Merge two sort keys.
void ucol_setAttribute (UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status)
 Universal attribute setter.
UColAttributeValue ucol_getAttribute (const UCollator *coll, UColAttribute attr, UErrorCode *status)
 Universal attribute getter.
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 less or equal than the variable top to be shifted when alternate handling is set to UCOL_SHIFTED.
uint32_t ucol_getVariableTop (const UCollator *coll, UErrorCode *status)
 Gets the variable top value of a Collator.
void ucol_restoreVariableTop (UCollator *coll, const uint32_t varTop, UErrorCode *status)
 Sets the variable top to a collation element value supplied.
UCollatorucol_safeClone (const UCollator *coll, void *stackBuffer, int32_t *pBufferSize, UErrorCode *status)
 Thread safe cloning operation.
int32_t ucol_getRulesEx (const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen)
 Returns current rules.
const char * ucol_getLocale (const UCollator *coll, ULocDataLocaleType type, UErrorCode *status)
 gets the locale name of the collator.
const char * ucol_getLocaleByType (const UCollator *coll, ULocDataLocaleType type, UErrorCode *status)
 gets the locale name of the collator.
USetucol_getTailoredSet (const UCollator *coll, UErrorCode *status)
 Get an Unicode set that contains all the characters and sequences tailored in this collator.
UColAttributeValue ucol_getAttributeOrDefault (const UCollator *coll, UColAttribute attr, UErrorCode *status)
 Universal attribute getter that returns UCOL_DEFAULT if the value is default.
UBool ucol_equals (const UCollator *source, const UCollator *target)
 Check whether two collators are equal.
int32_t ucol_getUnsafeSet (const UCollator *coll, USet *unsafe, UErrorCode *status)
 Calculates the set of unsafe code points, given a collator.
void ucol_forgetUCA (void)
 Reset UCA's static pointers.
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.
int32_t ucol_cloneBinary (const UCollator *coll, uint8_t *buffer, int32_t capacity, UErrorCode *status)
 Creates a binary image of a collator.
UCollatorucol_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.

Detailed Description

C API: Collator.

Collator C API

The C API for Collator performs locale-sensitive string comparison. You use this service to build searching and sorting routines for natural language text. Important: The ICU collation service has been reimplemented in order to achieve better performance and UCA compliance. For details, see the collation design document.

For more information about the collation service see the users guide.

Collation service provides correct sorting orders for most locales supported in ICU. If specific data for a locale is not available, the orders eventually falls back to the UCA sort order.

Sort ordering may be customized by providing your own set of rules. For more on this subject see the Collation customization section of the users guide.

See also:
UCollationResult
UNormalizationMode
UCollationStrength
UCollationElements

Definition in file ucol.h.


Define Documentation

#define U_COL_SAFECLONE_BUFFERSIZE   512

default memory size for the new clone.

It needs to be this large for os/400 large pointers

Stable:
ICU 2.0

Definition at line 1147 of file ucol.h.


Typedef Documentation

Base letter represents a primary difference.

Set comparison level to UCOL_PRIMARY to ignore secondary and tertiary differences. Use this to set the strength of a Collator object. Example of primary difference, "abc" < "abd"

Diacritical differences on the same base letter represent a secondary difference. Set comparison level to UCOL_SECONDARY to ignore tertiary differences. Use this to set the strength of a Collator object. Example of secondary difference, "&auml;" >> "a".

Uppercase and lowercase versions of the same character represents a tertiary difference. Set comparison level to UCOL_TERTIARY to include all comparison differences. Use this to set the strength of a Collator object. Example of tertiary difference, "abc" <<< "ABC".

Two characters are considered "identical" when they have the same unicode spellings. UCOL_IDENTICAL. For example, "&auml;" == "&auml;".

UCollationStrength is also used to determine the strength of sort keys generated from UCollator objects These values can be now found in the UColAttributeValue enum.

Stable:
ICU 2.0

Definition at line 226 of file ucol.h.

typedef struct UCollator UCollator

structure representing a collator object instance

Stable:
ICU 2.0

Definition at line 62 of file ucol.h.


Enumeration Type Documentation

Attributes that collation service understands.

All the attributes can take UCOL_DEFAULT value, as well as the values specific to each one.

Stable:
ICU 2.0
Enumerator:
UCOL_FRENCH_COLLATION 

Attribute for direction of secondary weights - used in French.

Acceptable values are UCOL_ON, which results in secondary weights being considered backwards and UCOL_OFF which treats secondary weights in the order they appear.

UCOL_ALTERNATE_HANDLING 

Attribute for handling variable elements.

Acceptable values are UCOL_NON_IGNORABLE (default) which treats all the codepoints with non-ignorable primary weights in the same way, and UCOL_SHIFTED which causes codepoints with primary weights that are equal or below the variable top value to be ignored on primary level and moved to the quaternary level.

UCOL_CASE_FIRST 

Controls the ordering of upper and lower case letters.

Acceptable values are UCOL_OFF (default), which orders upper and lower case letters in accordance to their tertiary weights, UCOL_UPPER_FIRST which forces upper case letters to sort before lower case letters, and UCOL_LOWER_FIRST which does the opposite.

UCOL_CASE_LEVEL 

Controls whether an extra case level (positioned before the third level) is generated or not.

Acceptable values are UCOL_OFF (default), when case level is not generated, and UCOL_ON which causes the case level to be generated. Contents of the case level are affected by the value of UCOL_CASE_FIRST attribute. A simple way to ignore accent differences in a string is to set the strength to UCOL_PRIMARY and enable case level.

UCOL_NORMALIZATION_MODE 

Controls whether the normalization check and necessary normalizations are performed.

When set to UCOL_OFF (default) no normalization check is performed. The correctness of the result is guaranteed only if the input data is in so-called FCD form (see users manual for more info). When set to UCOL_ON, an incremental check is performed to see whether the input data is in the FCD form. If the data is not in the FCD form, incremental NFD normalization is performed.

UCOL_DECOMPOSITION_MODE 

An alias for UCOL_NORMALIZATION_MODE attribute.

UCOL_STRENGTH 

The strength attribute.

Can be either UCOL_PRIMARY, UCOL_SECONDARY, UCOL_TERTIARY, UCOL_QUATERNARY or UCOL_IDENTICAL. The usual strength for most locales (except Japanese) is tertiary. Quaternary strength is useful when combined with shifted setting for alternate handling attribute and for JIS x 4061 collation, when it is used to distinguish between Katakana and Hiragana (this is achieved by setting the UCOL_HIRAGANA_QUATERNARY mode to on. Otherwise, quaternary level is affected only by the number of non ignorable code points in the string. Identical strength is rarely useful, as it amounts to codepoints of the NFD form of the string.

UCOL_HIRAGANA_QUATERNARY_MODE 

When turned on, this attribute positions Hiragana before all non-ignorables on quaternary level This is a sneaky way to produce JIS sort order.

UCOL_NUMERIC_COLLATION 

When turned on, this attribute generates a collation key for the numeric value of substrings of digits.

This is a way to get '100' to sort AFTER '2'. Note that the longest digit substring that can be treated as a single collation element is 254 digits (not counting leading zeros). If a digit substring is longer than that, the digits beyond the limit will be treated as a separate digit substring associated with a separate collation element.

Definition at line 232 of file ucol.h.

Enum containing attribute values for controling collation behavior.

Here are all the allowable values. Not every attribute can take every value. The only universal value is UCOL_DEFAULT, which resets the attribute value to the predefined value for that locale

Stable:
ICU 2.0
Enumerator:
UCOL_DEFAULT 

accepted by most attributes

UCOL_PRIMARY 

Primary collation strength.

UCOL_SECONDARY 

Secondary collation strength.

UCOL_TERTIARY 

Tertiary collation strength.

UCOL_DEFAULT_STRENGTH 

Default collation strength.

UCOL_QUATERNARY 

Quaternary collation strength.

UCOL_IDENTICAL 

Identical collation strength.

UCOL_OFF 

Turn the feature off - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MODE & UCOL_DECOMPOSITION_MODE.

UCOL_ON 

Turn the feature on - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, UCOL_HIRAGANA_QUATERNARY_MODE & UCOL_DECOMPOSITION_MODE.

UCOL_SHIFTED 

Valid for UCOL_ALTERNATE_HANDLING.

Alternate handling will be shifted

UCOL_NON_IGNORABLE 

Valid for UCOL_ALTERNATE_HANDLING.

Alternate handling will be non ignorable

UCOL_LOWER_FIRST 

Valid for UCOL_CASE_FIRST - lower case sorts before upper case.

UCOL_UPPER_FIRST 

upper case sorts before lower case

Definition at line 93 of file ucol.h.

enum that is taken by ucol_getBound API See below for explanation do not change the values assigned to the members of this enum.

Underlying code depends on them having these numbers

Stable:
ICU 2.0
Enumerator:
UCOL_BOUND_LOWER 

lower bound

UCOL_BOUND_UPPER 

upper bound that will match strings of exact size

UCOL_BOUND_UPPER_LONG 

upper bound that will match all the strings that have the same initial substring as the given string

Definition at line 933 of file ucol.h.

UCOL_LESS is returned if source string is compared to be less than target string in the u_strcoll() method.

UCOL_EQUAL is returned if source string is compared to be equal to target string in the u_strcoll() method. UCOL_GREATER is returned if source string is compared to be greater than target string in the u_strcoll() method.

See also:
u_strcoll()

Possible values for a comparison result

Stable:
ICU 2.0
Enumerator:
UCOL_EQUAL 

string a == string b

UCOL_GREATER 

string a > string b

UCOL_LESS 

string a < string b

Definition at line 77 of file ucol.h.

Enum containing the codes for reordering segments of the collation table that are not script codes.

These reordering codes are to be used in conjunction with the script codes.

See also:
ucol_getReorderCodes
ucol_setReorderCodes
ucol_getEquivalentReorderCodes
Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
Enumerator:
UCOL_REORDER_CODE_DEFAULT 

A special reordering code that is used to specify the default reordering codes for a locale.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_NONE 

A special reordering code that is used to specify no reordering codes.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_OTHERS 

A special reordering code that is used to specify all other codes used for reordering except for the codes lised as UColReorderCode values and those listed explicitly in a reordering.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_SPACE 

Characters with the space property.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_FIRST 

The first entry in the enumeration of reordering groups.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_PUNCTUATION 

Characters with the punctuation property.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_SYMBOL 

Characters with the symbol property.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_CURRENCY 

Characters with the currency property.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_DIGIT 

Characters with the digit property.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
UCOL_REORDER_CODE_LIMIT 

The limit of the reorder codes.

Draft:
This API may be changed in the future versions and was introduced in ICU 4.8

Definition at line 144 of file ucol.h.

Options for retrieving the rule string.

Stable:
ICU 2.0
Enumerator:
UCOL_TAILORING_ONLY 

Retrieve tailoring only.

UCOL_FULL_RULES 

Retrieve UCA rules and tailoring.

Definition at line 301 of file ucol.h.


Function Documentation

int32_t ucol_cloneBinary ( const UCollator coll,
uint8_t buffer,
int32_t  capacity,
UErrorCode status 
)

Creates a binary image of a collator.

This binary image can be stored and later used to instantiate a collator using ucol_openBinary. This API supports preflighting.

Parameters:
collCollator
buffera fill-in buffer to receive the binary image
capacitycapacity of the destination buffer
statusfor catching errors
Returns:
size of the image
See also:
ucol_openBinary
Stable:
ICU 3.2
void ucol_close ( UCollator coll)

Close a UCollator.

Once closed, a UCollator should not be used. Every open collator should be closed. Otherwise, a memory leak will result.

Parameters:
collThe UCollator to close.
See also:
ucol_open
ucol_openRules
ucol_safeClone
Stable:
ICU 2.0

Determine how many locales have collation rules available.

This function is most useful as determining the loop ending condition for calls to ucol_getAvailable.

Returns:
The number of locales for which collation rules are available.
See also:
ucol_getAvailable
Stable:
ICU 2.0
UBool ucol_equal ( const UCollator coll,
const UChar source,
int32_t  sourceLength,
const UChar target,
int32_t  targetLength 
)

Compare two strings for equality.

This function is equivalent to ucol_strcoll == UCOL_EQUAL

Parameters:
collThe UCollator containing the comparison rules.
sourceThe source string.
sourceLengthThe length of source, or -1 if null-terminated.
targetThe target string.
targetLengthThe length of target, or -1 if null-terminated.
Returns:
TRUE if source is equal to target, FALSE otherwise
See also:
ucol_strcoll
ucol_greater
ucol_greaterOrEqual
Stable:
ICU 2.0
UBool ucol_equals ( const UCollator source,
const UCollator target 
)

Check whether two collators are equal.

Collators are considered equal if they will sort strings the same. This means that both the current attributes and the rules must be equivalent. Currently used for RuleBasedCollator::operator==.

Parameters:
sourcefirst collator
targetsecond collator
Returns:
TRUE or FALSE
Internal:
Do not use. This API is for internal use only. ICU 3.0
void ucol_forgetUCA ( void  )

Reset UCA's static pointers.

You don't want to use this, unless your static memory can go away.

Internal:
Do not use. This API is for internal use only. ICU 3.2.1
UColAttributeValue ucol_getAttribute ( const UCollator coll,
UColAttribute  attr,
UErrorCode status 
)

Universal attribute getter.

Parameters:
collcollator which attributes are to be changed
attrattribute type
Returns:
attribute value
Parameters:
statusto indicate whether the operation went on smoothly or there were errors
See also:
UColAttribute
UColAttributeValue
ucol_setAttribute
Stable:
ICU 2.0

Universal attribute getter that returns UCOL_DEFAULT if the value is default.

Parameters:
collcollator which attributes are to be changed
attrattribute type
Returns:
attribute value or UCOL_DEFAULT if the value is default
Parameters:
statusto indicate whether the operation went on smoothly or there were errors
See also:
UColAttribute
UColAttributeValue
ucol_setAttribute
Internal:
Do not use. This API is for internal use only. ICU 3.0
const char* ucol_getAvailable ( int32_t  localeIndex)

Get a locale for which collation rules are available.

A UCollator in a locale returned by this function will perform the correct collation for the locale.

Parameters:
localeIndexThe index of the desired locale.
Returns:
A locale for which collation rules are available, or 0 if none.
See also:
ucol_countAvailable
Stable:
ICU 2.0
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.

Return value is always the number of bytes needed, regardless of whether the result buffer was big enough or even valid.
Resulting bounds can be used to produce a range of strings that are between upper and lower bounds. For example, if bounds are produced for a sortkey of string "smith", strings between upper and lower bounds with one level would include "Smith", "SMITH", "sMiTh".
There are two upper bounds that can be produced. If UCOL_BOUND_UPPER is produced, strings matched would be as above. However, if bound produced using UCOL_BOUND_UPPER_LONG is used, the above example will also match "Smithsonian" and similar.
For more on usage, see example in cintltst/capitst.c in procedure TestBounds. Sort keys may be compared using strcmp.

Parameters:
sourceThe source sortkey.
sourceLengthThe length of source, or -1 if null-terminated. (If an unmodified sortkey is passed, it is always null terminated).
boundTypeType of bound required. It can be UCOL_BOUND_LOWER, which produces a lower inclusive bound, UCOL_BOUND_UPPER, that produces upper bound that matches strings of the same length or UCOL_BOUND_UPPER_LONG that matches strings that have the same starting substring as the source string.
noOfLevelsNumber of levels required in the resulting bound (for most uses, the recommended value is 1). See users guide for explanation on number of levels a sortkey can have.
resultA pointer to a buffer to receive the resulting sortkey.
resultLengthThe maximum size of result.
statusUsed for returning error code if something went wrong. If the number of levels requested is higher than the number of levels in the source key, a warning (U_SORT_KEY_TOO_SHORT_WARNING) is issued.
Returns:
The size needed to fully store the bound.
See also:
ucol_keyHashCode
Stable:
ICU 2.1
int32_t ucol_getContractions ( const UCollator coll,
USet conts,
UErrorCode status 
)

Get a set containing the contractions defined by the collator.

The set includes both the UCA contractions and the contractions defined by the collator. This set will contain only strings. If a tailoring explicitly suppresses contractions from the UCA (like Russian), removed contractions will not be in the resulting set.

Parameters:
collcollator
contsthe set to hold the result. It gets emptied before contractions are added.
statusto hold the error code
Returns:
the size of the contraction set
Deprecated:
ICU 3.4, use ucol_getContractionsAndExpansions instead
void ucol_getContractionsAndExpansions ( const UCollator coll,
USet contractions,
USet expansions,
UBool  addPrefixes,
UErrorCode status 
)

Get a set containing the expansions defined by the collator.

The set includes both the UCA expansions and the expansions defined by the tailoring

Parameters:
collcollator
contractionsif not NULL, the set to hold the contractions
expansionsif not NULL, the set to hold the expansions
addPrefixesadd the prefix contextual elements to contractions
statusto hold the error code
Stable:
ICU 3.4
int32_t ucol_getDisplayName ( const char *  objLoc,
const char *  dispLoc,
UChar result,
int32_t  resultLength,
UErrorCode status 
)

Get the display name for a UCollator.

The display name is suitable for presentation to a user.

Parameters:
objLocThe locale of the collator in question.
dispLocThe locale for display.
resultA pointer to a buffer to receive the attribute.
resultLengthThe maximum size of result.
statusA pointer to an UErrorCode to receive any errors
Returns:
The total buffer size needed; if greater than resultLength, the output was truncated.
Stable:
ICU 2.0
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.

Some reorder codes will be grouped and must reorder together.

Parameters:
reorderCodeThe reorder code to determine equivalence for.
destThe array to fill with the script ordering.
destCapacityThe length of dest. If it is 0, then dest may be NULL and the function will only return the length of the result without writing any of the result string (pre-flighting).
pErrorCodeMust be a valid pointer to an error code value, which must not indicate a failure before the function call.
Returns:
The number of reordering codes written to the dest array.
See also:
ucol_setReorderCodes
ucol_getReorderCodes
Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
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 keyword, for the collation service.

If two locales return the same result, then collators instantiated for these locales will behave equivalently. The converse is not always true; two collators may in fact be equivalent, but return different results, due to internal details. The return result has no other meaning than that stated above, and implies nothing as to the relationship between the two locales. This is intended for use by applications who wish to cache collators, or otherwise reuse collators when possible. The functional equivalent may change over time. For more information, please see the Locales and Services section of the ICU User Guide.

Parameters:
resultfillin for the functionally equivalent locale
resultCapacitycapacity of the fillin buffer
keyworda particular keyword as enumerated by ucol_getKeywords.
localethe requested locale
isAvailableif non-NULL, pointer to a fillin parameter that indicates whether the requested locale was 'available' to the collation service. A locale is defined as 'available' if it physically exists within the collation locale data.
statuspointer to input-output error code
Returns:
the actual buffer size needed for the locale. If greater than resultCapacity, the returned full name will be truncated and an error code will be returned.
Stable:
ICU 3.0

Create a string enumerator of all possible keywords that are relevant to collation.

At this point, the only recognized keyword for this service is "collation".

Parameters:
statusinput-output error code
Returns:
a string enumeration over locale strings. The caller is responsible for closing the result.
Stable:
ICU 3.0
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.

Parameters:
keyworda particular keyword as enumerated by ucol_getKeywords. If any other keyword is passed in, *status is set to U_ILLEGAL_ARGUMENT_ERROR.
statusinput-output error code
Returns:
a string enumeration over collation keyword values, or NULL upon error. The caller is responsible for closing the result.
Stable:
ICU 3.0
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 difference.

These are all and only those values where the open (creation) of the service with the locale formed from the input locale plus input keyword and that value has different behavior than creation with the input locale alone.

Parameters:
keyone of the keys supported by this service. For now, only "collation" is supported.
localethe locale
commonlyUsedif set to true it will return only commonly used values with the given locale in preferred order. Otherwise, it will return all the available values for the locale.
statuserror status
Returns:
a string enumeration over keyword values for the given key and the locale.
Stable:
ICU 4.2
const char* ucol_getLocale ( const UCollator coll,
ULocDataLocaleType  type,
UErrorCode status 
)

gets the locale name of the collator.

If the collator is instantiated from the rules, then this function returns NULL.

Parameters:
collThe UCollator for which the locale is needed
typeYou can choose between requested, valid and actual locale. For description see the definition of ULocDataLocaleType in uloc.h
statuserror code of the operation
Returns:
real locale name from which the collation data comes. If the collator was instantiated from rules, returns NULL.
Deprecated:
ICU 2.8 Use ucol_getLocaleByType instead
const char* ucol_getLocaleByType ( const UCollator coll,
ULocDataLocaleType  type,
UErrorCode status 
)

gets the locale name of the collator.

If the collator is instantiated from the rules, then this function returns NULL.

Parameters:
collThe UCollator for which the locale is needed
typeYou can choose between requested, valid and actual locale. For description see the definition of ULocDataLocaleType in uloc.h
statuserror code of the operation
Returns:
real locale name from which the collation data comes. If the collator was instantiated from rules, returns NULL.
Stable:
ICU 2.8
int32_t ucol_getReorderCodes ( const UCollator coll,
int32_t dest,
int32_t  destCapacity,
UErrorCode pErrorCode 
)

Retrieves the reordering codes for this collator.

These reordering codes are a combination of UScript codes and UColReorderCode entries.

Parameters:
collThe UCollator to query.
destThe array to fill with the script ordering.
destCapacityThe length of dest. If it is 0, then dest may be NULL and the function will only return the length of the result without writing any of the result string (pre-flighting).
pErrorCodeMust be a valid pointer to an error code value, which must not indicate a failure before the function call.
Returns:
The number of reordering codes written to the dest array.
See also:
ucol_setReorderCodes
ucol_getEquivalentReorderCodes
Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
const UChar* ucol_getRules ( const UCollator coll,
int32_t length 
)

Get the collation rules from a UCollator.

The rules will follow the rule syntax.

Parameters:
collThe UCollator to query.
length
Returns:
The collation rules.
Stable:
ICU 2.0
int32_t ucol_getRulesEx ( const UCollator coll,
UColRuleOption  delta,
UChar buffer,
int32_t  bufferLen 
)

Returns current rules.

Delta defines whether full rules are returned or just the tailoring. Returns number of UChars needed to store rules. If buffer is NULL or bufferLen is not enough to store rules, will store up to available space.

Parameters:
collcollator to get the rules from
deltaone of UCOL_TAILORING_ONLY, UCOL_FULL_RULES.
bufferbuffer to store the result in. If NULL, you'll get no rules.
bufferLenlenght of buffer to store rules in. If less then needed you'll get only the part that fits in.
Returns:
current rules
Stable:
ICU 2.0
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.

This API harvests the collator's locale and the attribute set and produces a string that can be used for opening a collator with the same properties using the ucol_openFromShortString API. This string will be normalized. The structure and the syntax of the string is defined in the "Naming collators" section of the users guide: http://icu-project.org/userguide/Collate_Concepts.html#Naming_Collators This API supports preflighting.

Parameters:
colla collator
localea locale that will appear as a collators locale in the resulting short string definition. If NULL, the locale will be harvested from the collator.
bufferspace to hold the resulting string
capacitycapacity of the buffer
statusfor returning errors. All the preflighting errors are featured
Returns:
length of the resulting string
See also:
ucol_openFromShortString
ucol_normalizeShortDefinitionString
Stable:
ICU 3.0
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.

Sort keys may be compared using strcmp.

Like ICU functions that write to an output buffer, the buffer contents is undefined if the buffer capacity (resultLength parameter) is too small. Unlike ICU functions that write a string to an output buffer, the terminating zero byte is counted in the sort key length.

Parameters:
collThe UCollator containing the collation rules.
sourceThe string to transform.
sourceLengthThe length of source, or -1 if null-terminated.
resultA pointer to a buffer to receive the attribute.
resultLengthThe maximum size of result.
Returns:
The size needed to fully store the sort key. If there was an internal error generating the sort key, a zero value is returned.
See also:
ucol_keyHashCode
Stable:
ICU 2.0

Get the collation strength used in a UCollator.

The strength influences how strings are compared.

Parameters:
collThe UCollator to query.
Returns:
The collation strength; one of UCOL_PRIMARY, UCOL_SECONDARY, UCOL_TERTIARY, UCOL_QUATERNARY, UCOL_IDENTICAL
See also:
ucol_setStrength
Stable:
ICU 2.0
USet* ucol_getTailoredSet ( const UCollator coll,
UErrorCode status 
)

Get an Unicode set that contains all the characters and sequences tailored in this collator.

The result must be disposed of by using uset_close.

Parameters:
collThe UCollator for which we want to get tailored chars
statuserror code of the operation
Returns:
a pointer to newly created USet. Must be be disposed by using uset_close
See also:
ucol_openRules
uset_close
Stable:
ICU 2.4
void ucol_getUCAVersion ( const UCollator coll,
UVersionInfo  info 
)

Gets the UCA version information for a Collator.

Version is the UCA version number (3.1.1, 4.0).

Parameters:
collThe UCollator to query.
infothe version # information, the result will be filled in
Stable:
ICU 2.8
int32_t ucol_getUnsafeSet ( const UCollator coll,
USet unsafe,
UErrorCode status 
)

Calculates the set of unsafe code points, given a collator.

A character is unsafe if you could append any character and cause the ordering to alter significantly. Collation sorts in normalized order, so anything that rearranges in normalization can cause this. Thus if you have a character like a_umlaut, and you add a lower_dot to it, then it normalizes to a_lower_dot + umlaut, and sorts differently.

Parameters:
collCollator
unsafea fill-in set to receive the unsafe points
statusfor catching errors
Returns:
number of elements in the set
Internal:
Do not use. This API is for internal use only. ICU 3.0
uint32_t ucol_getVariableTop ( const UCollator coll,
UErrorCode status 
)

Gets the variable top value of a Collator.

Lower 16 bits are undefined and should be ignored.

Parameters:
collcollator which variable top needs to be retrieved
statuserror code (not changed by function). If error code is set, the return value is undefined.
Returns:
the variable top value of a Collator.
See also:
ucol_setVariableTop
ucol_restoreVariableTop
Stable:
ICU 2.0
void ucol_getVersion ( const UCollator coll,
UVersionInfo  info 
)

Gets the version information for a Collator.

Version is currently an opaque 32-bit number which depends, among other things, on major versions of the collator tailoring and UCA.

Parameters:
collThe UCollator to query.
infothe version # information, the result will be filled in
Stable:
ICU 2.0
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.

This function is equivalent to ucol_strcoll == UCOL_GREATER

Parameters:
collThe UCollator containing the comparison rules.
sourceThe source string.
sourceLengthThe length of source, or -1 if null-terminated.
targetThe target string.
targetLengthThe length of target, or -1 if null-terminated.
Returns:
TRUE if source is greater than target, FALSE otherwise.
See also:
ucol_strcoll
ucol_greaterOrEqual
ucol_equal
Stable:
ICU 2.0
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.

This function is equivalent to ucol_strcoll != UCOL_LESS

Parameters:
collThe UCollator containing the comparison rules.
sourceThe source string.
sourceLengthThe length of source, or -1 if null-terminated.
targetThe target string.
targetLengthThe length of target, or -1 if null-terminated.
Returns:
TRUE if source is greater than or equal to target, FALSE otherwise.
See also:
ucol_strcoll
ucol_greater
ucol_equal
Stable:
ICU 2.0
int32_t ucol_mergeSortkeys ( const uint8_t src1,
int32_t  src1Length,
const uint8_t src2,
int32_t  src2Length,
uint8_t dest,
int32_t  destCapacity 
)

Merge two sort keys.

The levels are merged with their corresponding counterparts (primaries with primaries, secondaries with secondaries etc.). Between the values from the same level a separator is inserted. example (uncompressed): 191B1D 01 050505 01 910505 00 and 1F2123 01 050505 01 910505 00 will be merged as 191B1D 02 1F212301 050505 02 050505 01 910505 02 910505 00 This allows for concatenating of first and last names for sorting, among other things. If the destination buffer is not big enough, the results are undefined. If any of source lengths are zero or any of source pointers are NULL/undefined, result is of size zero.

Parameters:
src1pointer to the first sortkey
src1Lengthlength of the first sortkey
src2pointer to the second sortkey
src2Lengthlength of the second sortkey
destbuffer to hold the result
destCapacitysize of the buffer for the result
Returns:
size of the result. If the buffer is big enough size is always src1Length+src2Length-1
Stable:
ICU 2.0
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.

Caller needs to preserve state array between calls and to provide the same type of UCharIterator set with the same string. The destination buffer provided must be big enough to store the number of requested bytes. Generated sortkey is not compatible with sortkeys generated using ucol_getSortKey API, since we don't do any compression. If uncompressed sortkeys are required, this API can be used.

Parameters:
collThe UCollator containing the collation rules.
iterUCharIterator containing the string we need the sort key to be calculated for.
stateOpaque state of sortkey iteration.
destBuffer to hold the resulting sortkey part
countnumber of sort key bytes required.
statuserror code indicator.
Returns:
the actual number of bytes of a sortkey. It can be smaller than count if we have reached the end of the sort key.
Stable:
ICU 2.6
int32_t ucol_normalizeShortDefinitionString ( const char *  source,
char *  destination,
int32_t  capacity,
UParseError parseError,
UErrorCode status 
)

Verifies and normalizes short definition string.

Normalized short definition string has all the option sorted by the argument name, so that equivalent definition strings are the same. This API supports preflighting.

Parameters:
sourcedefinition string
destinationspace to hold the resulting string
capacitycapacity of the buffer
parseErrorif not NULL, structure that will get filled with error's pre and post context in case of error.
statusError code. This API will return an error if an invalid attribute or attribute/value combination is specified. All the preflighting errors are also featured
Returns:
length of the resulting normalized string.
See also:
ucol_openFromShortString
ucol_getShortDefinitionString
Stable:
ICU 3.0
UCollator* ucol_open ( const char *  loc,
UErrorCode status 
)

Open a UCollator for comparing strings.

The UCollator pointer is used in all the calls to the Collation service. After finished, collator must be disposed of by calling ucol_close.

Parameters:
locThe locale containing the required collation rules. Special values for locales can be passed in - if NULL is passed for the locale, the default locale collation rules will be used. If empty string ("") or "root" are passed, UCA rules will be used.
statusA pointer to an UErrorCode to receive any errors
Returns:
A pointer to a UCollator, or 0 if an error occurred.
See also:
ucol_openRules
ucol_safeClone
ucol_close
Stable:
ICU 2.0

Create a string enumerator of all locales for which a valid collator may be opened.

Parameters:
statusinput-output error code
Returns:
a string enumeration over locale strings. The caller is responsible for closing the result.
Stable:
ICU 3.0
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.

Binary image used in instantiation of the collator remains owned by the user and should stay around for the lifetime of the collator. The API also takes a base collator which usualy should be UCA.

Parameters:
binbinary image owned by the user and required through the lifetime of the collator
lengthsize of the image. If negative, the API will try to figure out the length of the image
basefallback collator, usually UCA. Base is required to be present through the lifetime of the collator. Currently it cannot be NULL.
statusfor catching errors
Returns:
newly created collator
See also:
ucol_cloneBinary
Stable:
ICU 3.2
UCollator* ucol_openFromShortString ( const char *  definition,
UBool  forceDefaults,
UParseError parseError,
UErrorCode status 
)

Open a collator defined by a short form string.

The structure and the syntax of the string is defined in the "Naming collators" section of the users guide: http://icu-project.org/userguide/Collate_Concepts.html#Naming_Collators Attributes are overriden by the subsequent attributes. So, for "S2_S3", final strength will be 3. 3066bis locale overrides individual locale parts. The call to this function is equivalent to a call to ucol_open, followed by a series of calls to ucol_setAttribute and ucol_setVariableTop.

Parameters:
definitionA short string containing a locale and a set of attributes. Attributes not explicitly mentioned are left at the default state for a locale.
parseErrorif not NULL, structure that will get filled with error's pre and post context in case of error.
forceDefaultsif FALSE, the settings that are the same as the collator default settings will not be applied (for example, setting French secondary on a French collator would not be executed). If TRUE, all the settings will be applied regardless of the collator default value. If the definition strings are to be cached, should be set to FALSE.
statusError code. Apart from regular error conditions connected to instantiating collators (like out of memory or similar), this API will return an error if an invalid attribute or attribute/value combination is specified.
Returns:
A pointer to a UCollator or 0 if an error occured (including an invalid attribute).
See also:
ucol_open
ucol_setAttribute
ucol_setVariableTop
ucol_getShortDefinitionString
ucol_normalizeShortDefinitionString
Stable:
ICU 3.0
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.

The rules are used to change the default ordering, defined in the UCA in a process called tailoring. The resulting UCollator pointer can be used in the same way as the one obtained by ucol_strcoll.

Parameters:
rulesA string describing the collation rules. For the syntax of the rules please see users guide.
rulesLengthThe length of rules, or -1 if null-terminated.
normalizationModeThe normalization mode: One of UCOL_OFF (expect the text to not need normalization), UCOL_ON (normalize), or UCOL_DEFAULT (set the mode according to the rules)
strengthThe default collation strength; one of UCOL_PRIMARY, UCOL_SECONDARY, UCOL_TERTIARY, UCOL_IDENTICAL,UCOL_DEFAULT_STRENGTH - can be also set in the rules.
parseErrorA pointer to UParseError to recieve information about errors occurred during parsing. This argument can currently be set to NULL, but at users own risk. Please provide a real structure.
statusA pointer to an UErrorCode to receive any errors
Returns:
A pointer to a UCollator. It is not guaranteed that NULL be returned in case of error - please use status argument to check for errors.
See also:
ucol_open
ucol_safeClone
ucol_close
Stable:
ICU 2.0
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.

Parameters:
definitionA short string containing a locale and a set of attributes. Attributes not explicitly mentioned are left at the default state for a locale.
parseErrorif not NULL, structure that will get filled with error's pre and post context in case of error.
forceDefaultsif FALSE, the settings that are the same as the collator default settings will not be applied (for example, setting French secondary on a French collator would not be executed). If TRUE, all the settings will be applied regardless of the collator default value. If the definition strings are to be cached, should be set to FALSE.
statusError code. Apart from regular error conditions connected to instantiating collators (like out of memory or similar), this API will return an error if an invalid attribute or attribute/value combination is specified.
See also:
ucol_openFromShortString
Internal:
Do not use. This API is for internal use only. ICU 3.2.1
void ucol_restoreVariableTop ( UCollator coll,
const uint32_t  varTop,
UErrorCode status 
)

Sets the variable top to a collation element value supplied.

Variable top is set to the upper 16 bits. Lower 16 bits are ignored.

Parameters:
collcollator which variable top needs to be changed
varTopCE value, as returned by ucol_setVariableTop or ucol)getVariableTop
statuserror code (not changed by function)
See also:
ucol_getVariableTop
ucol_setVariableTop
Stable:
ICU 2.0
UCollator* ucol_safeClone ( const UCollator coll,
void *  stackBuffer,
int32_t pBufferSize,
UErrorCode status 
)

Thread safe cloning operation.

The result is a clone of a given collator.

Parameters:
collcollator to be cloned
stackBufferuser allocated space for the new clone. If NULL new memory will be allocated. If buffer is not large enough, new memory will be allocated. Clients can use the U_COL_SAFECLONE_BUFFERSIZE. This will probably be enough to avoid memory allocations.
pBufferSizepointer to size of allocated space. If *pBufferSize == 0, a sufficient size for use in cloning will be returned ('pre-flighting') If *pBufferSize is not enough for a stack-based safe clone, new memory will be allocated.
statusto indicate whether the operation went on smoothly or there were errors An informational status value, U_SAFECLONE_ALLOCATED_ERROR, is used if any allocations were necessary.
Returns:
pointer to the new clone
See also:
ucol_open
ucol_openRules
ucol_close
Stable:
ICU 2.0
void ucol_setAttribute ( UCollator coll,
UColAttribute  attr,
UColAttributeValue  value,
UErrorCode status 
)

Universal attribute setter.

Parameters:
collcollator which attributes are to be changed
attrattribute type
valueattribute value
statusto indicate whether the operation went on smoothly or there were errors
See also:
UColAttribute
UColAttributeValue
ucol_getAttribute
Stable:
ICU 2.0
void ucol_setReorderCodes ( UCollator coll,
const int32_t reorderCodes,
int32_t  reorderCodesLength,
UErrorCode pErrorCode 
)

Sets the reordering codes for this collator.

Collation reordering allows scripts and some other defined blocks of characters to be moved relative to each other as a block. This reordering is done on top of the DUCET/CLDR standard collation order. Reordering can specify groups to be placed at the start and/or the end of the collation order. These groups are specified using UScript codes and UColReorderCode entries.

By default, reordering codes specified for the start of the order are placed in the order given after a group of "special" non-script blocks. These special groups of characters are space, punctuation, symbol, currency, and digit. These special groups are represented with UColReorderCode entries. Script groups can be intermingled with these special non-script blocks if those special blocks are explicitly specified in the reordering.

The special code OTHERS stands for any script that is not explicitly mentioned in the list of reordering codes given. Anything that is after OTHERS will go at the very end of the reordering in the order given.

The special reorder code DEFAULT will reset the reordering for this collator to the default for this collator. The default reordering may be the DUCET/CLDR order or may be a reordering that was specified when this collator was created from resource data or from rules. The DEFAULT code must be the sole code supplied when it used. If not that will result in an U_ILLEGAL_ARGUMENT_ERROR being set.

The special reorder code NONE will remove any reordering for this collator. The result of setting no reordering will be to have the DUCET/CLDR reordering used. The NONE code must be the sole code supplied when it used.

Parameters:
collThe UCollator to set.
reorderCodesAn array of script codes in the new order. This can be NULL if the length is also set to 0. An empty array will clear any reordering codes on the collator.
reorderCodesLengthThe length of reorderCodes.
pErrorCodeMust be a valid pointer to an error code value, which must not indicate a failure before the function call.
See also:
ucol_getReorderCodes
ucol_getEquivalentReorderCodes
Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
void ucol_setStrength ( UCollator coll,
UCollationStrength  strength 
)

Set the collation strength used in a UCollator.

The strength influences how strings are compared.

Parameters:
collThe UCollator to set.
strengthThe desired collation strength; one of UCOL_PRIMARY, UCOL_SECONDARY, UCOL_TERTIARY, UCOL_QUATERNARY, UCOL_IDENTICAL, UCOL_DEFAULT
See also:
ucol_getStrength
Stable:
ICU 2.0
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 less or equal than the variable top to be shifted when alternate handling is set to UCOL_SHIFTED.

Sets the variable top to a collation element value of a string supplied.

Parameters:
collcollator which variable top needs to be changed
varTopone or more (if contraction) UChars to which the variable top should be set
lenlength of variable top string. If -1 it is considered to be zero terminated.
statuserror code. If error code is set, the return value is undefined. Errors set by this function are:
U_CE_NOT_FOUND_ERROR if more than one character was passed and there is no such a contraction
U_PRIMARY_TOO_LONG_ERROR if the primary for the variable top has more than two bytes
Returns:
a 32 bit value containing the value of the variable top in upper 16 bits. Lower 16 bits are undefined
See also:
ucol_getVariableTop
ucol_restoreVariableTop
Stable:
ICU 2.0
UCollationResult ucol_strcoll ( const UCollator coll,
const UChar source,
int32_t  sourceLength,
const UChar target,
int32_t  targetLength 
)

Compare two strings.

The strings will be compared using the options already specified.

Parameters:
collThe UCollator containing the comparison rules.
sourceThe source string.
sourceLengthThe length of source, or -1 if null-terminated.
targetThe target string.
targetLengthThe length of target, or -1 if null-terminated.
Returns:
The result of comparing the strings; one of UCOL_EQUAL, UCOL_GREATER, UCOL_LESS
See also:
ucol_greater
ucol_greaterOrEqual
ucol_equal
Stable:
ICU 2.0
UCollationResult ucol_strcollIter ( const UCollator coll,
UCharIterator sIter,
UCharIterator tIter,
UErrorCode status 
)

Compare two UTF-8 encoded trings.

The strings will be compared using the options already specified.

Parameters:
collThe UCollator containing the comparison rules.
sIterThe source string iterator.
tIterThe target string iterator.
Returns:
The result of comparing the strings; one of UCOL_EQUAL, UCOL_GREATER, UCOL_LESS
Parameters:
statusA pointer to an UErrorCode to receive any errors
See also:
ucol_strcoll
Stable:
ICU 2.6
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Defines