icu::Collator Class Reference

The Collator class performs locale-sensitive string comparison. More...

#include <coll.h>

Inheritance diagram for icu::Collator:

Public Types
enum	ECollationStrength { PRIMARY = UCOL_PRIMARY, SECONDARY = UCOL_SECONDARY, TERTIARY = UCOL_TERTIARY, QUATERNARY = UCOL_QUATERNARY, IDENTICAL = UCOL_IDENTICAL }
	Base letter represents a primary difference. More...
enum	EComparisonResult { LESS = UCOL_LESS, EQUAL = UCOL_EQUAL, GREATER = UCOL_GREATER }
	LESS is returned if source string is compared to be less than target string in the compare() method. More...
Public Member Functions
virtual	~Collator ()
	Destructor.
virtual UBool	operator== (const Collator &other) const
	Returns TRUE if "other" is the same as "this".
virtual UBool	operator!= (const Collator &other) const
	Returns true if "other" is not the same as "this".
virtual Collator *	clone (void) const =0
	Makes a copy of this object.
virtual EComparisonResult	compare (const UnicodeString &source, const UnicodeString &target) const
	The comparison function compares the character data stored in two different strings.
virtual UCollationResult	compare (const UnicodeString &source, const UnicodeString &target, UErrorCode &status) const =0
	The comparison function compares the character data stored in two different strings.
virtual EComparisonResult	compare (const UnicodeString &source, const UnicodeString &target, int32_t length) const
	Does the same thing as compare but limits the comparison to a specified length.
virtual UCollationResult	compare (const UnicodeString &source, const UnicodeString &target, int32_t length, UErrorCode &status) const =0
	Does the same thing as compare but limits the comparison to a specified length.
virtual EComparisonResult	compare (const char16_t source, int32_t sourceLength, const char16_t target, int32_t targetLength) const
	The comparison function compares the character data stored in two different string arrays.
virtual UCollationResult	compare (const char16_t source, int32_t sourceLength, const char16_t target, int32_t targetLength, UErrorCode &status) const =0
	The comparison function compares the character data stored in two different string arrays.
virtual UCollationResult	compare (UCharIterator &sIter, UCharIterator &tIter, UErrorCode &status) const
	Compares two strings using the Collator.
virtual UCollationResult	compareUTF8 (const StringPiece &source, const StringPiece &target, UErrorCode &status) const
	Compares two UTF-8 strings using the Collator.
virtual CollationKey &	getCollationKey (const UnicodeString &source, CollationKey &key, UErrorCode &status) const =0
	Transforms the string into a series of characters that can be compared with CollationKey::compareTo.
virtual CollationKey &	getCollationKey (const char16_t *source, int32_t sourceLength, CollationKey &key, UErrorCode &status) const =0
	Transforms the string into a series of characters that can be compared with CollationKey::compareTo.
virtual int32_t	hashCode (void) const =0
	Generates the hash code for the collation object.
virtual Locale	getLocale (ULocDataLocaleType type, UErrorCode &status) const =0
	Gets the locale of the Collator.
UBool	greater (const UnicodeString &source, const UnicodeString &target) const
	Convenience method for comparing two strings based on the collation rules.
UBool	greaterOrEqual (const UnicodeString &source, const UnicodeString &target) const
	Convenience method for comparing two strings based on the collation rules.
UBool	equals (const UnicodeString &source, const UnicodeString &target) const
	Convenience method for comparing two strings based on the collation rules.
virtual ECollationStrength	getStrength (void) const
	Determines the minimum strength that will be used in comparison or transformation.
virtual void	setStrength (ECollationStrength newStrength)
	Sets the minimum strength to be used in comparison or transformation.
virtual int32_t	getReorderCodes (int32_t *dest, int32_t destCapacity, UErrorCode &status) const
	Retrieves the reordering codes for this collator.
virtual void	setReorderCodes (const int32_t *reorderCodes, int32_t reorderCodesLength, UErrorCode &status)
	Sets the ordering of scripts for this collator.
virtual void	getVersion (UVersionInfo info) const =0
	Gets the version information for a Collator.
virtual UClassID	getDynamicClassID (void) const =0
	Returns a unique class ID POLYMORPHICALLY.
virtual void	setAttribute (UColAttribute attr, UColAttributeValue value, UErrorCode &status)=0
	Universal attribute setter.
virtual UColAttributeValue	getAttribute (UColAttribute attr, UErrorCode &status) const =0
	Universal attribute getter.
virtual Collator &	setMaxVariable (UColReorderCode group, UErrorCode &errorCode)
	Sets the variable top to the top of the specified reordering group.
virtual UColReorderCode	getMaxVariable () const
	Returns the maximum reordering group whose characters are affected by UCOL_ALTERNATE_HANDLING.
virtual uint32_t	setVariableTop (const char16_t *varTop, int32_t len, UErrorCode &status)=0
	Sets the variable top to the primary weight of the specified string.
virtual uint32_t	setVariableTop (const UnicodeString &varTop, UErrorCode &status)=0
	Sets the variable top to the primary weight of the specified string.
virtual void	setVariableTop (uint32_t varTop, UErrorCode &status)=0
	Sets the variable top to the specified primary weight.
virtual uint32_t	getVariableTop (UErrorCode &status) const =0
	Gets the variable top value of a Collator.
virtual UnicodeSet *	getTailoredSet (UErrorCode &status) const
	Get a UnicodeSet that contains all the characters and sequences tailored in this collator.
virtual Collator *	safeClone (void) const
	Same as clone().
virtual int32_t	getSortKey (const UnicodeString &source, uint8_t *result, int32_t resultLength) const =0
	Get the sort key as an array of bytes from a UnicodeString.
virtual int32_t	getSortKey (const char16_t source, int32_t sourceLength, uint8_t result, int32_t resultLength) const =0
	Get the sort key as an array of bytes from a char16_t buffer.
virtual void	setLocales (const Locale &requestedLocale, const Locale &validLocale, const Locale &actualLocale)
	Used internally by registration to define the requested and valid locales.
virtual int32_t	internalGetShortDefinitionString (const char locale, char buffer, int32_t capacity, UErrorCode &status) const
	Get the short definition string for a collator.
virtual UCollationResult	internalCompareUTF8 (const char left, int32_t leftLength, const char right, int32_t rightLength, UErrorCode &errorCode) const
	Implements ucol_strcollUTF8().
virtual int32_t	internalNextSortKeyPart (UCharIterator iter, uint32_t state[2], uint8_t dest, int32_t count, UErrorCode &errorCode) const
	Implements ucol_nextSortKeyPart().
UCollator *	toUCollator ()
const UCollator *	toUCollator () const
Static Public Member Functions
static Collator *	createInstance (UErrorCode &err)
	Creates the Collator object for the current default locale.
static Collator *	createInstance (const Locale &loc, UErrorCode &err)
	Gets the collation object for the desired locale.
static int32_t	getEquivalentReorderCodes (int32_t reorderCode, int32_t *dest, int32_t destCapacity, UErrorCode &status)
	Retrieves the reorder codes that are grouped with the given reorder code.
static UnicodeString &	getDisplayName (const Locale &objectLocale, const Locale &displayLocale, UnicodeString &name)
	Get name of the object for the desired Locale, in the desired language.
static UnicodeString &	getDisplayName (const Locale &objectLocale, UnicodeString &name)
	Get name of the object for the desired Locale, in the language of the default locale.
static const Locale *	getAvailableLocales (int32_t &count)
	Get the set of Locales for which Collations are installed.
static StringEnumeration *	getAvailableLocales (void)
	Return a StringEnumeration over the locales available at the time of the call, including registered locales.
static StringEnumeration *	getKeywords (UErrorCode &status)
	Create a string enumerator of all possible keywords that are relevant to collation.
static StringEnumeration *	getKeywordValues (const char *keyword, UErrorCode &status)
	Given a keyword, create a string enumeration of all values for that keyword that are currently in use.
static StringEnumeration *	getKeywordValuesForLocale (const char *keyword, const Locale &locale, UBool commonlyUsed, UErrorCode &status)
	Given a key and a locale, returns an array of string values in a preferred order that would make a difference.
static Locale	getFunctionalEquivalent (const char *keyword, const Locale &locale, UBool &isAvailable, UErrorCode &status)
	Return the functionally equivalent locale for the given requested locale, with respect to given keyword, for the collation service.
static URegistryKey	registerInstance (Collator *toAdopt, const Locale &locale, UErrorCode &status)
	Register a new Collator.
static URegistryKey	registerFactory (CollatorFactory *toAdopt, UErrorCode &status)
	Register a new CollatorFactory.
static UBool	unregister (URegistryKey key, UErrorCode &status)
	Unregister a previously-registered Collator or CollatorFactory using the key returned from the register call.
static int32_t	getBound (const uint8_t source, int32_t sourceLength, UColBoundMode boundType, uint32_t noOfLevels, uint8_t result, int32_t resultLength, UErrorCode &status)
	Produce a bound for a given sortkey and a number of levels.
static Collator *	fromUCollator (UCollator *uc)
static const Collator *	fromUCollator (const UCollator *uc)
Protected Member Functions
	Collator ()
	Default constructor.
	Collator (UCollationStrength collationStrength, UNormalizationMode decompositionMode)
	Constructor.
	Collator (const Collator &other)
	Copy constructor.
Friends
class	CFactory
class	SimpleCFactory
class	ICUCollatorFactory
class	ICUCollatorService

Detailed Description

The Collator class performs locale-sensitive string comparison.

You use this class to build searching and sorting routines for natural language text.

Collator is an abstract base class. Subclasses implement specific collation strategies. One subclass, RuleBasedCollator, is currently provided and is applicable to a wide set of languages. Other subclasses may be created to handle more specialized needs.

Like other locale-sensitive classes, you can use the static factory method, createInstance, to obtain the appropriate Collator object for a given locale. You will only need to look at the subclasses of Collator if you need to understand the details of a particular collation strategy or if you need to modify that strategy.

The following example shows how to compare two strings using the Collator for the default locale.

  // Compare two strings in the default locale
 UErrorCode success = U_ZERO_ERROR;
 Collator* myCollator = Collator::createInstance(success);
 if (myCollator->compare("abc", "ABC") < 0)
   cout << "abc is less than ABC" << endl;
 else
   cout << "abc is greater than or equal to ABC" << endl;

You can set a Collator's strength attribute to determine the level of difference considered significant in comparisons. Five strengths are provided: PRIMARY, SECONDARY, TERTIARY, QUATERNARY and IDENTICAL. The exact assignment of strengths to language features is locale dependent. For example, in Czech, "e" and "f" are considered primary differences, while "e" and "\u00EA" are secondary differences, "e" and "E" are tertiary differences and "e" and "e" are identical. The following shows how both case and accents could be ignored for US English.

  //Get the Collator for US English and set its strength to PRIMARY
 UErrorCode success = U_ZERO_ERROR;
 Collator* usCollator = Collator::createInstance(Locale::getUS(), success);
 usCollator->setStrength(Collator::PRIMARY);
 if (usCollator->compare("abc", "ABC") == 0)
     cout << "'abc' and 'ABC' strings are equivalent with strength PRIMARY" << endl;

The getSortKey methods convert a string to a series of bytes that can be compared bitwise against other sort keys using strcmp(). Sort keys are written as zero-terminated byte strings.

Another set of APIs returns a CollationKey object that wraps the sort key bytes instead of returning the bytes themselves.

Note: Collators with different Locale, and CollationStrength settings will return different sort orders for the same set of strings. Locales have specific collation rules, and the way in which secondary and tertiary differences are taken into account, for example, will result in a different sorting order for same strings.

See also:: RuleBasedCollator; CollationKey; CollationElementIterator; Locale; Normalizer2

Version:: 2.0 11/15/01

Definition at line 165 of file coll.h.

Member Enumeration Documentation

enum icu::Collator::ECollationStrength

Base letter represents a primary difference.

Set comparison level to 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 SECONDARY to ignore tertiary differences. Use this to set the strength of a Collator object.
Example of secondary difference, "ä" >> "a".

Uppercase and lowercase versions of the same character represents a tertiary difference. Set comparison level to 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.
For example, "ä" == "ä".

UCollationStrength is also used to determine the strength of sort keys generated from Collator objects.

Stable:: ICU 2.0

Definition at line 195 of file coll.h.

enum icu::Collator::EComparisonResult

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

EQUAL is returned if source string is compared to be equal to target string in the compare() method. GREATER is returned if source string is compared to be greater than target string in the compare() method.

See also:: Collator::compare

Deprecated:: ICU 2.6. Use C enum UCollationResult defined in ucol.h

Definition at line 217 of file coll.h.

Constructor & Destructor Documentation

virtual icu::Collator::~Collator ( ) [virtual]

Destructor.

Stable:: ICU 2.0

icu::Collator::Collator ( ) [protected]

Default constructor.

Constructor is different from the old default Collator constructor. The task for determing the default collation strength and normalization mode is left to the child class.

Stable:: ICU 2.0

icu::Collator::Collator	(	UCollationStrength	collationStrength,
		UNormalizationMode	decompositionMode
	)			`[protected]`

Constructor.

Empty constructor, does not handle the arguments. This constructor is done for backward compatibility with 1.7 and 1.8. The task for handling the argument collation strength and normalization mode is left to the child class.

Parameters:

	collationStrength	collation strength
	decompositionMode

Deprecated:: ICU 2.4. Subclasses should use the default constructor instead and handle the strength and normalization mode themselves.

icu::Collator::Collator ( const Collator & other ) [protected]

Copy constructor.

Parameters:

other

Collator object to be copied from

Stable:: ICU 2.0

Member Function Documentation

virtual Collator* icu::Collator::clone ( void ) const [pure virtual]

Makes a copy of this object.

Returns:: a copy of this object, owned by the caller

Stable:: ICU 2.0

Implemented in icu::RuleBasedCollator.

virtual UCollationResult icu::Collator::compare	(	UCharIterator &	sIter,
		UCharIterator &	tIter,
		UErrorCode &	status
	)			const `[virtual]`

Compares two strings using the Collator.

Returns whether the first one compares less than/equal to/greater than the second one. This version takes UCharIterator input.

Parameters:

	sIter	the first ("source") string iterator
	tIter	the second ("target") string iterator
	status	ICU status

Returns:: UCOL_LESS, UCOL_EQUAL or UCOL_GREATER

Stable:: ICU 4.2

Reimplemented in icu::RuleBasedCollator.

virtual UCollationResult icu::Collator::compare	(	const char16_t *	source,
		int32_t	sourceLength,
		const char16_t *	target,
		int32_t	targetLength,
		UErrorCode &	status
	)			const `[pure virtual]`

The comparison function compares the character data stored in two different string arrays.

Returns information about whether a string array is less than, greater than or equal to another string array.

Parameters:

	source	the source string array to be compared with.
	sourceLength	the length of the source string array. If this value is equal to -1, the string array is null-terminated.
	target	the string that is to be compared with the source string.
	targetLength	the length of the target string array. If this value is equal to -1, the string array is null-terminated.
	status	possible error code

Returns:: Returns an enum value. UCOL_GREATER if source is greater than target; UCOL_EQUAL if source is equal to target; UCOL_LESS if source is less than target

Stable:: ICU 2.6

Implemented in icu::RuleBasedCollator.

virtual EComparisonResult icu::Collator::compare	(	const char16_t *	source,
		int32_t	sourceLength,
		const char16_t *	target,
		int32_t	targetLength
	)			const `[virtual]`

The comparison function compares the character data stored in two different string arrays.

Returns information about whether a string array is less than, greater than or equal to another string array.

Example of use:

 .       char16_t ABC[] = {0x41, 0x42, 0x43, 0};  // = "ABC"
 .       char16_t abc[] = {0x61, 0x62, 0x63, 0};  // = "abc"
 .       UErrorCode status = U_ZERO_ERROR;
 .       Collator *myCollation =
 .                         Collator::createInstance(Locale::getUS(), status);
 .       if (U_FAILURE(status)) return;
 .       myCollation->setStrength(Collator::PRIMARY);
 .       // result would be Collator::EQUAL ("abc" == "ABC")
 .       // (no primary difference between "abc" and "ABC")
 .       Collator::EComparisonResult result =
 .                             myCollation->compare(abc, 3, ABC, 3);
 .       myCollation->setStrength(Collator::TERTIARY);
 .       // result would be Collator::LESS ("abc" <<< "ABC")
 .       // (with tertiary difference between "abc" and "ABC")
 .       result = myCollation->compare(abc, 3, ABC, 3);

Parameters:

	source	the source string array to be compared with.
	sourceLength	the length of the source string array. If this value is equal to -1, the string array is null-terminated.
	target	the string that is to be compared with the source string.
	targetLength	the length of the target string array. If this value is equal to -1, the string array is null-terminated.

Returns:: Returns a byte value. GREATER if source is greater than target; EQUAL if source is equal to target; LESS if source is less than target

Deprecated:: ICU 2.6 use the overload with UErrorCode &

virtual UCollationResult icu::Collator::compare	(	const UnicodeString &	source,
		const UnicodeString &	target,
		int32_t	length,
		UErrorCode &	status
	)			const `[pure virtual]`

Does the same thing as compare but limits the comparison to a specified length.

Parameters:

	source	the source string to be compared with.
	target	the string that is to be compared with the source string.
	length	the length the comparison is limited to
	status	possible error code

Returns:: Returns an enum value. UCOL_GREATER if source (up to the specified length) is greater than target; UCOL_EQUAL if source (up to specified length) is equal to target; UCOL_LESS if source (up to the specified length) is less than target.

Stable:: ICU 2.6

Implemented in icu::RuleBasedCollator.

virtual EComparisonResult icu::Collator::compare	(	const UnicodeString &	source,
		const UnicodeString &	target,
		int32_t	length
	)			const `[virtual]`

Does the same thing as compare but limits the comparison to a specified length.

Parameters:

	source	the source string to be compared with.
	target	the string that is to be compared with the source string.
	length	the length the comparison is limited to

Returns:: Returns a byte value. GREATER if source (up to the specified length) is greater than target; EQUAL if source (up to specified length) is equal to target; LESS if source (up to the specified length) is less than target.

Deprecated:: ICU 2.6 use the overload with UErrorCode &

virtual UCollationResult icu::Collator::compare	(	const UnicodeString &	source,
		const UnicodeString &	target,
		UErrorCode &	status
	)			const `[pure virtual]`

The comparison function compares the character data stored in two different strings.

Returns information about whether a string is less than, greater than or equal to another string.

Parameters:

	source	the source string to be compared with.
	target	the string that is to be compared with the source string.
	status	possible error code

Returns:: Returns an enum value. UCOL_GREATER if source is greater than target; UCOL_EQUAL if source is equal to target; UCOL_LESS if source is less than target

Stable:: ICU 2.6

Implemented in icu::RuleBasedCollator.

virtual EComparisonResult icu::Collator::compare	(	const UnicodeString &	source,
		const UnicodeString &	target
	)			const `[virtual]`

The comparison function compares the character data stored in two different strings.

Returns information about whether a string is less than, greater than or equal to another string.

Parameters:

	source	the source string to be compared with.
	target	the string that is to be compared with the source string.

Returns:: Returns a byte value. GREATER if source is greater than target; EQUAL if source is equal to target; LESS if source is less than target

Deprecated:: ICU 2.6 use the overload with UErrorCode &

virtual UCollationResult icu::Collator::compareUTF8	(	const StringPiece &	source,
		const StringPiece &	target,
		UErrorCode &	status
	)			const `[virtual]`

Compares two UTF-8 strings using the Collator.

Returns whether the first one compares less than/equal to/greater than the second one. This version takes UTF-8 input. Note that a StringPiece can be implicitly constructed from a std::string or a NUL-terminated const char * string.

Parameters:

	source	the first UTF-8 string
	target	the second UTF-8 string
	status	ICU status

Returns:: UCOL_LESS, UCOL_EQUAL or UCOL_GREATER

Stable:: ICU 4.2

Reimplemented in icu::RuleBasedCollator.

static Collator* icu::Collator::createInstance	(	const Locale &	loc,
		UErrorCode &	err
	)			`[static]`

Gets the collation object for the desired locale.

The resource of the desired locale will be loaded.

Locale::getRoot() is the base collation table and all other languages are built on top of it with additional language-specific modifications.

For some languages, multiple collation types are available; for example, "de@collation=phonebook". Starting with ICU 54, collation attributes can be specified via locale keywords as well, in the old locale extension syntax ("el@colCaseFirst=upper") or in language tag syntax ("el-u-kf-upper"). See User Guide: Collation API.

The UErrorCode& err parameter is used to return status information to the user. To check whether the construction succeeded or not, you should check the value of U_SUCCESS(err). If you wish more detailed information, you can check for informational error results which still indicate success. U_USING_FALLBACK_ERROR indicates that a fall back locale was used. For example, 'de_CH' was requested, but nothing was found there, so 'de' was used. U_USING_DEFAULT_ERROR indicates that the default locale data was used; neither the requested locale nor any of its fall back locales could be found.

The caller owns the returned object and is responsible for deleting it.

Parameters:

	loc	The locale ID for which to open a collator.
	err	the error code status.

Returns:: the created table-based collation object based on the desired locale.

See also:: Locale; ResourceLoader

Stable:: ICU 2.2

static Collator* icu::Collator::createInstance ( UErrorCode & err ) [static]

Creates the Collator object for the current default locale.

The default locale is determined by Locale::getDefault. The UErrorCode& err parameter is used to return status information to the user. To check whether the construction succeeded or not, you should check the value of U_SUCCESS(err). If you wish more detailed information, you can check for informational error results which still indicate success. U_USING_FALLBACK_ERROR indicates that a fall back locale was used. For example, 'de_CH' was requested, but nothing was found there, so 'de' was used. U_USING_DEFAULT_ERROR indicates that the default locale data was used; neither the requested locale nor any of its fall back locales could be found. The caller owns the returned object and is responsible for deleting it.

Parameters:

err

the error code status.

Returns:: the collation object of the default locale.(for example, en_US)

See also:: Locale::getDefault

Stable:: ICU 2.0

UBool icu::Collator::equals	(	const UnicodeString &	source,
		const UnicodeString &	target
	)			const

Convenience method for comparing two strings based on the collation rules.

Parameters:

	source	the source string to be compared with.
	target	the target string to be compared with.

Returns:: true if the strings are equal according to the collation rules. false, otherwise.

See also:: Collator::compare

Stable:: ICU 2.0

static const Collator* icu::Collator::fromUCollator ( const UCollator * uc ) [inline, static]

Internal:: Do not use. This API is for internal use only.

Definition at line 1170 of file coll.h.

static Collator* icu::Collator::fromUCollator ( UCollator * uc ) [inline, static]

Internal:: Do not use. This API is for internal use only.

Definition at line 1166 of file coll.h.

Referenced by icu::RuleBasedCollator::rbcFromUCollator().

virtual UColAttributeValue icu::Collator::getAttribute	(	UColAttribute	attr,
		UErrorCode &	status
	)			const `[pure virtual]`

Universal attribute getter.

Parameters:

	attr	attribute type
	status	to indicate whether the operation went on smoothly or there were errors

Returns:: attribute value

Stable:: ICU 2.2

Implemented in icu::RuleBasedCollator.

static StringEnumeration* icu::Collator::getAvailableLocales ( void ) [static]

Return a StringEnumeration over the locales available at the time of the call, including registered locales.

If a severe error occurs (such as out of memory condition) this will return null. If there is no locale data, an empty enumeration will be returned.

Returns:: a StringEnumeration over the locales available at the time of the call

Stable:: ICU 2.6

static const Locale* icu::Collator::getAvailableLocales ( int32_t & count ) [static]

Get the set of Locales for which Collations are installed.

Note this does not include locales supported by registered collators. If collators might have been registered, use the overload of getAvailableLocales that returns a StringEnumeration.

Parameters:

count

the output parameter of number of elements in the locale list

Returns:: the list of available locales for which collations are installed

Stable:: ICU 2.0

static int32_t icu::Collator::getBound	(	const uint8_t *	source,
		int32_t	sourceLength,
		UColBoundMode	boundType,
		uint32_t	noOfLevels,
		uint8_t *	result,
		int32_t	resultLength,
		UErrorCode &	status
	)			`[static]`

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:

	source	The source sortkey.
	sourceLength	The length of source, or -1 if null-terminated. (If an unmodified sortkey is passed, it is always null terminated).
	boundType	Type 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.
	noOfLevels	Number 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.
	result	A pointer to a buffer to receive the resulting sortkey.
	resultLength	The maximum size of result.
	status	Used 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

virtual CollationKey& icu::Collator::getCollationKey	(	const char16_t *	source,
		int32_t	sourceLength,
		CollationKey &	key,
		UErrorCode &	status
	)			const `[pure virtual]`

Transforms the string into a series of characters that can be compared with CollationKey::compareTo.

It is not possible to restore the original string from the chars in the sort key.

Use CollationKey::equals or CollationKey::compare to compare the generated sort keys.

If the source string is null, a null collation key will be returned.

Note that sort keys are often less efficient than simply doing comparison. For more details, see the ICU User Guide.

Parameters:

	source	the source string to be transformed into a sort key.
	sourceLength	length of the collation key
	key	the collation key to be filled in
	status	the error code status.

Returns:: the collation key of the string based on the collation rules.

See also:: CollationKey::compare

Stable:: ICU 2.0

Implemented in icu::RuleBasedCollator.

virtual CollationKey& icu::Collator::getCollationKey	(	const UnicodeString &	source,
		CollationKey &	key,
		UErrorCode &	status
	)			const `[pure virtual]`

Transforms the string into a series of characters that can be compared with CollationKey::compareTo.

It is not possible to restore the original string from the chars in the sort key.

Use CollationKey::equals or CollationKey::compare to compare the generated sort keys. If the source string is null, a null collation key will be returned.

Note that sort keys are often less efficient than simply doing comparison. For more details, see the ICU User Guide.

Parameters:

	source	the source string to be transformed into a sort key.
	key	the collation key to be filled in
	status	the error code status.

Returns:: the collation key of the string based on the collation rules.

See also:: CollationKey::compare

Stable:: ICU 2.0

Implemented in icu::RuleBasedCollator.

static UnicodeString& icu::Collator::getDisplayName	(	const Locale &	objectLocale,
		UnicodeString &	name
	)			`[static]`

Get name of the object for the desired Locale, in the language of the default locale.

Parameters:

	objectLocale	must be from getAvailableLocales
	name	the fill-in parameter of the return value

Returns:: name of the object for the desired locale in the default language

Stable:: ICU 2.0

static UnicodeString& icu::Collator::getDisplayName	(	const Locale &	objectLocale,
		const Locale &	displayLocale,
		UnicodeString &	name
	)			`[static]`

Get name of the object for the desired Locale, in the desired language.

Parameters:

	objectLocale	must be from getAvailableLocales
	displayLocale	specifies the desired locale for output
	name	the fill-in parameter of the return value

Returns:: display-able name of the object for the object locale in the desired language

Stable:: ICU 2.0

virtual UClassID icu::Collator::getDynamicClassID ( void ) const [pure virtual]

Returns a unique class ID POLYMORPHICALLY.

Pure virtual method. This method is to implement a simple version of RTTI, since not all C++ compilers support genuine RTTI. Polymorphic operator==() and clone() methods call this method.

Returns:: The class ID for this object. All objects of a given class have the same class ID. Objects of other classes have different class IDs.

Stable:: ICU 2.0

Reimplemented from icu::UObject.

Implemented in icu::RuleBasedCollator.

static int32_t icu::Collator::getEquivalentReorderCodes	(	int32_t	reorderCode,
		int32_t *	dest,
		int32_t	destCapacity,
		UErrorCode &	status
	)			`[static]`

Retrieves the reorder codes that are grouped with the given reorder code.

Some reorder codes will be grouped and must reorder together. Beginning with ICU 55, scripts only reorder together if they are primary-equal, for example Hiragana and Katakana.

Parameters:

	reorderCode	The reorder code to determine equivalence for.
	dest	The array to fill with the script equivalence reordering codes.
	destCapacity	The 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 codes (pre-flighting).
	status	A reference to an error code value, which must not indicate a failure before the function call.

Returns:: The length of the of the reordering code equivalence array.

See also:: ucol_setReorderCodes; Collator::getReorderCodes; Collator::setReorderCodes; UScriptCode; UColReorderCode

Stable:: ICU 4.8

static Locale icu::Collator::getFunctionalEquivalent	(	const char *	keyword,
		const Locale &	locale,
		UBool &	isAvailable,
		UErrorCode &	status
	)			`[static]`

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:

	keyword	a particular keyword as enumerated by ucol_getKeywords.
	locale	the requested locale
	isAvailable	reference 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.
	status	reference to input-output error code

Returns:: the functionally equivalent collation locale, or the root locale upon error.

Stable:: ICU 3.0

static StringEnumeration* icu::Collator::getKeywords ( UErrorCode & status ) [static]

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:

status

input-output error code

Returns:: a string enumeration over locale strings. The caller is responsible for closing the result.

Stable:: ICU 3.0

static StringEnumeration* icu::Collator::getKeywordValues	(	const char *	keyword,
		UErrorCode &	status
	)			`[static]`

Given a keyword, create a string enumeration of all values for that keyword that are currently in use.

Parameters:

	keyword	a particular keyword as enumerated by ucol_getKeywords. If any other keyword is passed in, status is set to U_ILLEGAL_ARGUMENT_ERROR.
	status	input-output error code

Returns:: a string enumeration over collation keyword values, or NULL upon error. The caller is responsible for deleting the result.

Stable:: ICU 3.0

static StringEnumeration* icu::Collator::getKeywordValuesForLocale	(	const char *	keyword,
		const Locale &	locale,
		UBool	commonlyUsed,
		UErrorCode &	status
	)			`[static]`

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:

	keyword	one of the keys supported by this service. For now, only "collation" is supported.
	locale	the locale
	commonlyUsed	if 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.
	status	ICU status

Returns:: a string enumeration over keyword values for the given key and the locale.

Stable:: ICU 4.2

virtual Locale icu::Collator::getLocale	(	ULocDataLocaleType	type,
		UErrorCode &	status
	)			const `[pure virtual]`

Gets the locale of the Collator.

Parameters:

	type	can be either requested, valid or actual locale. For more information see the definition of ULocDataLocaleType in uloc.h
	status	the error code status.

Returns:: locale where the collation data lives. If the collator was instantiated from rules, locale is empty.

Deprecated:: ICU 2.8 This API is under consideration for revision in ICU 3.0.

Implemented in icu::RuleBasedCollator.

virtual UColReorderCode icu::Collator::getMaxVariable ( ) const [virtual]

Returns the maximum reordering group whose characters are affected by UCOL_ALTERNATE_HANDLING.

The base class implementation returns UCOL_REORDER_CODE_PUNCTUATION.

Returns:: the maximum variable reordering group.

See also:: setMaxVariable

Stable:: ICU 53

Reimplemented in icu::RuleBasedCollator.

virtual int32_t icu::Collator::getReorderCodes	(	int32_t *	dest,
		int32_t	destCapacity,
		UErrorCode &	status
	)			const `[virtual]`

Retrieves the reordering codes for this collator.

Parameters:

	dest	The array to fill with the script ordering.
	destCapacity	The 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 codes (pre-flighting).
	status	A reference to an error code value, which must not indicate a failure before the function call.

Returns:: The length of the script ordering array.

See also:: ucol_setReorderCodes; Collator::getEquivalentReorderCodes; Collator::setReorderCodes; UScriptCode; UColReorderCode

Stable:: ICU 4.8

Reimplemented in icu::RuleBasedCollator.

virtual int32_t icu::Collator::getSortKey	(	const char16_t *	source,
		int32_t	sourceLength,
		uint8_t *	result,
		int32_t	resultLength
	)			const `[pure virtual]`

Get the sort key as an array of bytes from a char16_t buffer.

Sort key byte arrays are zero-terminated and can be compared using strcmp().

Note that sort keys are often less efficient than simply doing comparison. For more details, see the ICU User Guide.

Parameters:

	source	string to be processed.
	sourceLength	length of string to be processed. If -1, the string is 0 terminated and length will be decided by the function.
	result	buffer to store result in. If NULL, number of bytes needed will be returned.
	resultLength	length of the result buffer. If if not enough the buffer will be filled to capacity.

Returns:: Number of bytes needed for storing the sort key

Stable:: ICU 2.2

Implemented in icu::RuleBasedCollator.

virtual int32_t icu::Collator::getSortKey	(	const UnicodeString &	source,
		uint8_t *	result,
		int32_t	resultLength
	)			const `[pure virtual]`

Get the sort key as an array of bytes from a UnicodeString.

Sort key byte arrays are zero-terminated and can be compared using strcmp().

Note that sort keys are often less efficient than simply doing comparison. For more details, see the ICU User Guide.

Parameters:

	source	string to be processed.
	result	buffer to store result in. If NULL, number of bytes needed will be returned.
	resultLength	length of the result buffer. If if not enough the buffer will be filled to capacity.

Returns:: Number of bytes needed for storing the sort key

Stable:: ICU 2.2

Implemented in icu::RuleBasedCollator.

virtual ECollationStrength icu::Collator::getStrength ( void ) const [virtual]

Determines the minimum strength that will be used in comparison or transformation.

E.g. with strength == SECONDARY, the tertiary difference is ignored

E.g. with strength == PRIMARY, the secondary and tertiary difference are ignored.

Returns:: the current comparison level.

See also:: Collator::setStrength

Deprecated:: ICU 2.6 Use getAttribute(UCOL_STRENGTH...) instead

virtual UnicodeSet* icu::Collator::getTailoredSet ( UErrorCode & status ) const [virtual]

Get a UnicodeSet that contains all the characters and sequences tailored in this collator.

Parameters:

status

error code of the operation

Returns:: a pointer to a UnicodeSet object containing all the code points and sequences that may sort differently than in the root collator. The object must be disposed of by using delete

Stable:: ICU 2.4

Reimplemented in icu::RuleBasedCollator.

virtual uint32_t icu::Collator::getVariableTop ( UErrorCode & status ) const [pure virtual]

Gets the variable top value of a Collator.

Parameters:

status

error code (not changed by function). If error code is set, the return value is undefined.

Returns:: the variable top primary weight

See also:: getMaxVariable

Stable:: ICU 2.0

Implemented in icu::RuleBasedCollator.

virtual void icu::Collator::getVersion ( UVersionInfo info ) const [pure virtual]

Gets the version information for a Collator.

Parameters:

info

the version # information, the result will be filled in

Stable:: ICU 2.0

Implemented in icu::RuleBasedCollator.

UBool icu::Collator::greater	(	const UnicodeString &	source,
		const UnicodeString &	target
	)			const

Convenience method for comparing two strings based on the collation rules.

Parameters:

	source	the source string to be compared with.
	target	the target string to be compared with.

Returns:: true if the first string is greater than the second one, according to the collation rules. false, otherwise.

See also:: Collator::compare

Stable:: ICU 2.0

UBool icu::Collator::greaterOrEqual	(	const UnicodeString &	source,
		const UnicodeString &	target
	)			const

Convenience method for comparing two strings based on the collation rules.

Parameters:

	source	the source string to be compared with.
	target	the target string to be compared with.

Returns:: true if the first string is greater than or equal to the second one, according to the collation rules. false, otherwise.

See also:: Collator::compare

Stable:: ICU 2.0

virtual int32_t icu::Collator::hashCode ( void ) const [pure virtual]

Generates the hash code for the collation object.

Stable:: ICU 2.0

Implemented in icu::RuleBasedCollator.

virtual UCollationResult icu::Collator::internalCompareUTF8	(	const char *	left,
		int32_t	leftLength,
		const char *	right,
		int32_t	rightLength,
		UErrorCode &	errorCode
	)			const `[virtual]`

Implements ucol_strcollUTF8().

Internal:: Do not use. This API is for internal use only.

Reimplemented in icu::RuleBasedCollator.

virtual int32_t icu::Collator::internalGetShortDefinitionString	(	const char *	locale,
		char *	buffer,
		int32_t	capacity,
		UErrorCode &	status
	)			const `[virtual]`

Get the short definition string for a collator.

This internal 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 attributes 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://userguide.icu-project.org/collation/concepts#TOC-Collator-naming-scheme This function supports preflighting.

This is internal, and intended to be used with delegate converters.

Parameters:

	locale	a locale that will appear as a collators locale in the resulting short string definition. If NULL, the locale will be harvested from the collator.
	buffer	space to hold the resulting string
	capacity	capacity of the buffer
	status	for returning errors. All the preflighting errors are featured

Returns:: length of the resulting string

See also:: ucol_openFromShortString; ucol_normalizeShortDefinitionString; ucol_getShortDefinitionString

Internal:: Do not use. This API is for internal use only.

Reimplemented in icu::RuleBasedCollator.

virtual int32_t icu::Collator::internalNextSortKeyPart	(	UCharIterator *	iter,
		uint32_t	state[2],
		uint8_t *	dest,
		int32_t	count,
		UErrorCode &	errorCode
	)			const `[virtual]`

Implements ucol_nextSortKeyPart().

Internal:: Do not use. This API is for internal use only.

Reimplemented in icu::RuleBasedCollator.

virtual UBool icu::Collator::operator!= ( const Collator & other ) const [virtual]

Returns true if "other" is not the same as "this".

Calls ! operator==(const Collator&) const which works for all subclasses.

Parameters:

other

Collator object to be compared

Returns:: TRUE if other is not the same as this.

Stable:: ICU 2.0

virtual UBool icu::Collator::operator== ( const Collator & other ) const [virtual]

Returns TRUE if "other" is the same as "this".

The base class implementation returns TRUE if "other" has the same type/class as "this": typeid(*this) == typeid(other).

Subclass implementations should do something like the following:

   if (this == &other) { return TRUE; }
   if (!Collatoroperator==(other)) { return FALSE; }  // not the same class

   const MyCollator &o = (const MyCollator&)other;
   (compare this vs. o's subclass fields)

Parameters:

other

Collator object to be compared

Returns:: TRUE if other is the same as this.

Stable:: ICU 2.0

static URegistryKey icu::Collator::registerFactory	(	CollatorFactory *	toAdopt,
		UErrorCode &	status
	)			`[static]`

Register a new CollatorFactory.

The factory will be adopted. Because ICU may choose to cache collators internally, this must be called at application startup, prior to any calls to Collator::createInstance to avoid undefined behavior.

Parameters:

	toAdopt	the CollatorFactory instance to be adopted
	status	the in/out status code, no special meanings are assigned

Returns:: a registry key that can be used to unregister this collator

Stable:: ICU 2.6

static URegistryKey icu::Collator::registerInstance	(	Collator *	toAdopt,
		const Locale &	locale,
		UErrorCode &	status
	)			`[static]`

Register a new Collator.

The collator will be adopted. Because ICU may choose to cache collators internally, this must be called at application startup, prior to any calls to Collator::createInstance to avoid undefined behavior.

Parameters:

	toAdopt	the Collator instance to be adopted
	locale	the locale with which the collator will be associated
	status	the in/out status code, no special meanings are assigned

Returns:: a registry key that can be used to unregister this collator

Stable:: ICU 2.6

virtual Collator* icu::Collator::safeClone ( void ) const [virtual]

Same as clone().

The base class implementation simply calls clone().

Returns:: a copy of this object, owned by the caller

See also:: clone()

Deprecated:: ICU 50 no need to have two methods for cloning

virtual void icu::Collator::setAttribute	(	UColAttribute	attr,
		UColAttributeValue	value,
		UErrorCode &	status
	)			`[pure virtual]`

Universal attribute setter.

Parameters:

	attr	attribute type
	value	attribute value
	status	to indicate whether the operation went on smoothly or there were errors

Stable:: ICU 2.2

Implemented in icu::RuleBasedCollator.

virtual void icu::Collator::setLocales	(	const Locale &	requestedLocale,
		const Locale &	validLocale,
		const Locale &	actualLocale
	)			`[virtual]`

Used internally by registration to define the requested and valid locales.

Parameters:

	requestedLocale	the requested locale
	validLocale	the valid locale
	actualLocale	the actual locale

Internal:: Do not use. This API is for internal use only.

Reimplemented in icu::RuleBasedCollator.

virtual Collator& icu::Collator::setMaxVariable	(	UColReorderCode	group,
		UErrorCode &	errorCode
	)			`[virtual]`

Sets the variable top to the top of the specified reordering group.

The variable top determines the highest-sorting character which is affected by UCOL_ALTERNATE_HANDLING. If that attribute is set to UCOL_NON_IGNORABLE, then the variable top has no effect.

The base class implementation sets U_UNSUPPORTED_ERROR.

Parameters:

	group	one of UCOL_REORDER_CODE_SPACE, UCOL_REORDER_CODE_PUNCTUATION, UCOL_REORDER_CODE_SYMBOL, UCOL_REORDER_CODE_CURRENCY; or UCOL_REORDER_CODE_DEFAULT to restore the default max variable group
	errorCode	Standard ICU error code. Its input value must pass the U_SUCCESS() test, or else the function returns immediately. Check for U_FAILURE() on output or use with function chaining. (See User Guide for details.)

Returns:: *this

See also:: getMaxVariable

Stable:: ICU 53

Reimplemented in icu::RuleBasedCollator.

virtual void icu::Collator::setReorderCodes	(	const int32_t *	reorderCodes,
		int32_t	reorderCodesLength,
		UErrorCode &	status
	)			`[virtual]`

Sets the ordering of scripts for this collator.

The reordering codes are a combination of script codes and reorder codes.

Parameters:

	reorderCodes	An 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.
	reorderCodesLength	The length of reorderCodes.
	status	error code

See also:: ucol_setReorderCodes; Collator::getReorderCodes; Collator::getEquivalentReorderCodes; UScriptCode; UColReorderCode

Stable:: ICU 4.8

Reimplemented in icu::RuleBasedCollator.

virtual void icu::Collator::setStrength ( ECollationStrength newStrength ) [virtual]

Sets the minimum strength to be used in comparison or transformation.

Example of use:

    UErrorCode status = U_ZERO_ERROR;
  Collator*myCollation = Collator::createInstance(Locale::getUS(), status);
  if (U_FAILURE(status)) return;
  myCollation->setStrength(Collator::PRIMARY);
  // result will be "abc" == "ABC"
  // tertiary differences will be ignored
  Collator::ComparisonResult result = myCollation->compare("abc", "ABC");

See also:: Collator::getStrength

Parameters:

newStrength

the new comparison level.

Deprecated:: ICU 2.6 Use setAttribute(UCOL_STRENGTH...) instead

virtual void icu::Collator::setVariableTop	(	uint32_t	varTop,
		UErrorCode &	status
	)			`[pure virtual]`

Sets the variable top to the specified primary weight.

Beginning with ICU 53, the variable top is pinned to the top of one of the supported reordering groups, and it must not be beyond the last of those groups. See setMaxVariable().

Parameters:

	varTop	primary weight, as returned by setVariableTop or ucol_getVariableTop
	status	error code

Deprecated:: ICU 53 Call setMaxVariable() instead.

Implemented in icu::RuleBasedCollator.

virtual uint32_t icu::Collator::setVariableTop	(	const UnicodeString &	varTop,
		UErrorCode &	status
	)			`[pure virtual]`

Sets the variable top to the primary weight of the specified string.

Beginning with ICU 53, the variable top is pinned to the top of one of the supported reordering groups, and it must not be beyond the last of those groups. See setMaxVariable().

Parameters:

	varTop	a UnicodeString size 1 or more (if contraction) of char16_ts to which the variable top should be set
	status	error 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 contraction U_ILLEGAL_ARGUMENT_ERROR if the variable top is beyond the last reordering group supported by setMaxVariable()

Returns:: variable top primary weight

Deprecated:: ICU 53 Call setMaxVariable() instead.

Implemented in icu::RuleBasedCollator.

virtual uint32_t icu::Collator::setVariableTop	(	const char16_t *	varTop,
		int32_t	len,
		UErrorCode &	status
	)			`[pure virtual]`

Sets the variable top to the primary weight of the specified string.

Beginning with ICU 53, the variable top is pinned to the top of one of the supported reordering groups, and it must not be beyond the last of those groups. See setMaxVariable().

Parameters:

	varTop	one or more (if contraction) char16_ts to which the variable top should be set
	len	length of variable top string. If -1 it is considered to be zero terminated.
	status	error 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 contraction U_ILLEGAL_ARGUMENT_ERROR if the variable top is beyond the last reordering group supported by setMaxVariable()

Returns:: variable top primary weight

Deprecated:: ICU 53 Call setMaxVariable() instead.

Implemented in icu::RuleBasedCollator.

const UCollator* icu::Collator::toUCollator ( ) const [inline]

Internal:: Do not use. This API is for internal use only.

Definition at line 1178 of file coll.h.

UCollator* icu::Collator::toUCollator ( ) [inline]

Internal:: Do not use. This API is for internal use only.

Definition at line 1174 of file coll.h.

static UBool icu::Collator::unregister	(	URegistryKey	key,
		UErrorCode &	status
	)			`[static]`

Unregister a previously-registered Collator or CollatorFactory using the key returned from the register call.

Key becomes invalid after a successful call and should not be used again. The object corresponding to the key will be deleted. Because ICU may choose to cache collators internally, this should be called during application shutdown, after all calls to Collator::createInstance to avoid undefined behavior.

Parameters:

	key	the registry key returned by a previous call to registerInstance
	status	the in/out status code, no special meanings are assigned

Returns:: TRUE if the collator for the key was successfully unregistered

Stable:: ICU 2.6

The documentation for this class was generated from the following file:

coll.h

icu::Collator Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation