ICU 50.1.2  50.1.2
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Friends
icu::Collator Class Referenceabstract

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

#include <coll.h>

Inheritance diagram for icu::Collator:
icu::UObject icu::UMemory icu::RuleBasedCollator

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. More...
 
virtual UBool operator== (const Collator &other) const
 Returns TRUE if "other" is the same as "this". More...
 
virtual UBool operator!= (const Collator &other) const
 Returns true if "other" is not the same as "this". More...
 
virtual Collatorclone (void) const =0
 Makes a copy of this object. More...
 
virtual EComparisonResult compare (const UnicodeString &source, const UnicodeString &target) const
 The comparison function compares the character data stored in two different strings. More...
 
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. More...
 
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. More...
 
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. More...
 
virtual EComparisonResult compare (const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength) const
 The comparison function compares the character data stored in two different string arrays. More...
 
virtual UCollationResult compare (const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength, UErrorCode &status) const =0
 The comparison function compares the character data stored in two different string arrays. More...
 
virtual UCollationResult compare (UCharIterator &sIter, UCharIterator &tIter, UErrorCode &status) const
 Compares two strings using the Collator. More...
 
virtual UCollationResult compareUTF8 (const StringPiece &source, const StringPiece &target, UErrorCode &status) const
 Compares two UTF-8 strings using the Collator. More...
 
virtual CollationKeygetCollationKey (const UnicodeString &source, CollationKey &key, UErrorCode &status) const =0
 Transforms the string into a series of characters that can be compared with CollationKey::compareTo. More...
 
virtual CollationKeygetCollationKey (const UChar *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. More...
 
virtual int32_t hashCode (void) const =0
 Generates the hash code for the collation object. More...
 
virtual Locale getLocale (ULocDataLocaleType type, UErrorCode &status) const =0
 Gets the locale of the Collator. More...
 
UBool greater (const UnicodeString &source, const UnicodeString &target) const
 Convenience method for comparing two strings based on the collation rules. More...
 
UBool greaterOrEqual (const UnicodeString &source, const UnicodeString &target) const
 Convenience method for comparing two strings based on the collation rules. More...
 
UBool equals (const UnicodeString &source, const UnicodeString &target) const
 Convenience method for comparing two strings based on the collation rules. More...
 
virtual ECollationStrength getStrength (void) const
 Determines the minimum strength that will be used in comparison or transformation. More...
 
virtual void setStrength (ECollationStrength newStrength)
 Sets the minimum strength to be used in comparison or transformation. More...
 
virtual int32_t getReorderCodes (int32_t *dest, int32_t destCapacity, UErrorCode &status) const
 Retrieves the reordering codes for this collator. More...
 
virtual void setReorderCodes (const int32_t *reorderCodes, int32_t reorderCodesLength, UErrorCode &status)
 Sets the ordering of scripts for this collator. More...
 
virtual void getVersion (UVersionInfo info) const =0
 Gets the version information for a Collator. More...
 
virtual UClassID getDynamicClassID (void) const =0
 Returns a unique class ID POLYMORPHICALLY. More...
 
virtual void setAttribute (UColAttribute attr, UColAttributeValue value, UErrorCode &status)=0
 Universal attribute setter. More...
 
virtual UColAttributeValue getAttribute (UColAttribute attr, UErrorCode &status) const =0
 Universal attribute getter. More...
 
virtual uint32_t setVariableTop (const UChar *varTop, int32_t len, UErrorCode &status)=0
 Sets the variable top to a collation element value of a string supplied. More...
 
virtual uint32_t setVariableTop (const UnicodeString &varTop, UErrorCode &status)=0
 Sets the variable top to a collation element value of a string supplied. More...
 
virtual void setVariableTop (uint32_t varTop, UErrorCode &status)=0
 Sets the variable top to a collation element value supplied. More...
 
virtual uint32_t getVariableTop (UErrorCode &status) const =0
 Gets the variable top value of a Collator. More...
 
virtual UnicodeSetgetTailoredSet (UErrorCode &status) const
 Get an UnicodeSet that contains all the characters and sequences tailored in this collator. More...
 
virtual CollatorsafeClone (void) const
 Same as clone(). More...
 
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 an UnicodeString. More...
 
virtual int32_t getSortKey (const UChar *source, int32_t sourceLength, uint8_t *result, int32_t resultLength) const =0
 Get the sort key as an array of bytes from an UChar buffer. More...
 
virtual int32_t internalGetShortDefinitionString (const char *locale, char *buffer, int32_t capacity, UErrorCode &status) const
 Get the short definition string for a collator. More...
 
- Public Member Functions inherited from icu::UObject
virtual ~UObject ()
 Destructor. More...
 

Static Public Member Functions

static CollatorcreateInstance (UErrorCode &err)
 Creates the Collator object for the current default locale. More...
 
static CollatorcreateInstance (const Locale &loc, UErrorCode &err)
 Gets the table-based collation object for the desired locale. More...
 
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. More...
 
static UnicodeStringgetDisplayName (const Locale &objectLocale, const Locale &displayLocale, UnicodeString &name)
 Get name of the object for the desired Locale, in the desired langauge. More...
 
static UnicodeStringgetDisplayName (const Locale &objectLocale, UnicodeString &name)
 Get name of the object for the desired Locale, in the langauge of the default locale. More...
 
static const LocalegetAvailableLocales (int32_t &count)
 Get the set of Locales for which Collations are installed. More...
 
static StringEnumerationgetAvailableLocales (void)
 Return a StringEnumeration over the locales available at the time of the call, including registered locales. More...
 
static StringEnumerationgetKeywords (UErrorCode &status)
 Create a string enumerator of all possible keywords that are relevant to collation. More...
 
static StringEnumerationgetKeywordValues (const char *keyword, UErrorCode &status)
 Given a keyword, create a string enumeration of all values for that keyword that are currently in use. More...
 
static StringEnumerationgetKeywordValuesForLocale (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. More...
 
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. More...
 
static URegistryKey registerInstance (Collator *toAdopt, const Locale &locale, UErrorCode &status)
 Register a new Collator. More...
 
static URegistryKey registerFactory (CollatorFactory *toAdopt, UErrorCode &status)
 Register a new CollatorFactory. More...
 
static UBool unregister (URegistryKey key, UErrorCode &status)
 Unregister a previously-registered Collator or CollatorFactory using the key returned from the register call. More...
 
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. More...
 
static UCollatorcreateUCollator (const char *loc, UErrorCode *status)
 used only by ucol_open, not for public use More...
 

Protected Member Functions

 Collator ()
 Default constructor. More...
 
 Collator (UCollationStrength collationStrength, UNormalizationMode decompositionMode)
 Constructor. More...
 
 Collator (const Collator &other)
 Copy constructor. More...
 
virtual void setLocales (const Locale &requestedLocale, const Locale &validLocale, const Locale &actualLocale)
 Used internally by registraton to define the requested and valid locales. More...
 

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.
Important: The ICU collation service has been reimplemented in order to achieve better performance and UCA compliance. For details, see the collation design document.

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
* 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 property 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 dependant. 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
* Collator* usCollator = Collator::createInstance(Locale::US, success);
* usCollator->setStrength(Collator::PRIMARY);
* if (usCollator->compare("abc", "ABC") == 0)
* cout << "'abc' and 'ABC' strings are equivalent with strength PRIMARY" << endl;
*

For comparing strings exactly once, the compare method provides the best performance. When sorting a list of strings however, it is generally necessary to compare each string multiple times. In this case, sort keys provide better performance. 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. They consist of several substrings, one for each collation strength level, that are delimited by 0x01 bytes. If the string code points are appended for UCOL_IDENTICAL, then they are processed for correct code point order comparison and may contain 0x01 bytes but not zero bytes.

An older set of APIs returns a CollationKey object that wraps the sort key bytes instead of returning the bytes themselves. Its use is deprecated, but it is still available for compatibility with Java.

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
Normalizer
Version
2.0 11/15/01

Definition at line 177 of file coll.h.

Member Enumeration Documentation

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, "&auml;" >> "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, "&auml;" == "&auml;".

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

Stable:
ICU 2.0

Definition at line 207 of file coll.h.

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 226 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
collationStrengthcollation 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
otherCollator 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 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
sourcethe source string to be compared with.
targetthe 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::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
sourcethe source string to be compared with.
targetthe string that is to be compared with the source string.
statuspossible 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,
int32_t  length 
) const
virtual

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

Parameters
sourcethe source string to be compared with.
targetthe string that is to be compared with the source string.
lengththe 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,
int32_t  length,
UErrorCode status 
) const
pure virtual

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

Parameters
sourcethe source string to be compared with.
targetthe string that is to be compared with the source string.
lengththe length the comparison is limited to
statuspossible 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 UChar source,
int32_t  sourceLength,
const UChar 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:

.       UChar ABC[] = {0x41, 0x42, 0x43, 0};  // = "ABC"
.       UChar abc[] = {0x61, 0x62, 0x63, 0};  // = "abc"
.       UErrorCode status = U_ZERO_ERROR;
.       Collator *myCollation =
.                         Collator::createInstance(Locale::US, 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
sourcethe source string array to be compared with.
sourceLengththe length of the source string array. If this value is equal to -1, the string array is null-terminated.
targetthe string that is to be compared with the source string.
targetLengththe 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 UChar source,
int32_t  sourceLength,
const UChar 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
sourcethe source string array to be compared with.
sourceLengththe length of the source string array. If this value is equal to -1, the string array is null-terminated.
targetthe string that is to be compared with the source string.
targetLengththe length of the target string array. If this value is equal to -1, the string array is null-terminated.
statuspossible 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 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
sIterthe first ("source") string iterator
tIterthe second ("target") string iterator
statusICU status
Returns
UCOL_LESS, UCOL_EQUAL or UCOL_GREATER
Stable:
ICU 4.2

Reimplemented in icu::RuleBasedCollator.

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
sourcethe first UTF-8 string
targetthe second UTF-8 string
statusICU status
Returns
UCOL_LESS, UCOL_EQUAL or UCOL_GREATER
Stable:
ICU 4.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
errthe error code status.
Returns
the collation object of the default locale.(for example, en_US)
See Also
Locale::getDefault
Stable:
ICU 2.0
static Collator* icu::Collator::createInstance ( const Locale loc,
UErrorCode err 
)
static

Gets the table-based collation object for the desired locale.

The resource of the desired locale will be loaded by ResourceLoader. Locale::ENGLISH is the base collation table and all other languages are built on top of it with additional language-specific modifications. 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
locThe locale ID for which to open a collator.
errthe error code status.
Returns
the created table-based collation object based on the desired locale.
See Also
Locale
ResourceLoader
Stable:
ICU 2.2
static UCollator* icu::Collator::createUCollator ( const char *  loc,
UErrorCode status 
)
static

used only by ucol_open, not for public use

Internal:
Do not use. This API is for internal use only.
UBool icu::Collator::equals ( const UnicodeString source,
const UnicodeString target 
) const

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

Parameters
sourcethe source string to be compared with.
targetthe 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
virtual UColAttributeValue icu::Collator::getAttribute ( UColAttribute  attr,
UErrorCode status 
) const
pure virtual

Universal attribute getter.

Parameters
attrattribute type
statusto indicate whether the operation went on smoothly or there were errors
Returns
attribute value
Stable:
ICU 2.2

Implemented in icu::RuleBasedCollator.

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
countthe 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 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 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
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
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. The generated sort key handles only a limited number of ignorable characters.

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.

Parameters
sourcethe source string to be transformed into a sort key.
keythe collation key to be filled in
statusthe 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 UChar 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. The generated sort key handles only a limited number of ignorable characters.

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.

Parameters
sourcethe source string to be transformed into a sort key.
sourceLengthlength of the collation key
keythe collation key to be filled in
statusthe 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,
const Locale displayLocale,
UnicodeString name 
)
static

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

Parameters
objectLocalemust be from getAvailableLocales
displayLocalespecifies the desired locale for output
namethe 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
static UnicodeString& icu::Collator::getDisplayName ( const Locale objectLocale,
UnicodeString name 
)
static

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

Parameters
objectLocalemust be from getAvailableLocales
namethe fill-in parameter of the return value
Returns
name of the object for the desired locale in the default 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

Implements 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.

Parameters
reorderCodeThe reorder code to determine equivalence for.
destThe array to fill with the script equivalene reordering codes.
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).
statusA 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
keyworda particular keyword as enumerated by ucol_getKeywords.
localethe requested locale
isAvailablereference 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.
statusreference 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
statusinput-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
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 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
keywordone 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.
statusICU 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
typecan be either requested, valid or actual locale. For more information see the definition of ULocDataLocaleType in uloc.h
statusthe 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 int32_t icu::Collator::getReorderCodes ( int32_t *  dest,
int32_t  destCapacity,
UErrorCode status 
) const
virtual

Retrieves the reordering codes for this collator.

Parameters
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).
statusA 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 UnicodeString source,
uint8_t *  result,
int32_t  resultLength 
) const
pure virtual

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

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

Parameters
sourcestring to be processed.
resultbuffer to store result in. If NULL, number of bytes needed will be returned.
resultLengthlength 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 UChar source,
int32_t  sourceLength,
uint8_t *  result,
int32_t  resultLength 
) const
pure virtual

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

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

Parameters
sourcestring to be processed.
sourceLengthlength of string to be processed. If -1, the string is 0 terminated and length will be decided by the function.
resultbuffer to store result in. If NULL, number of bytes needed will be returned.
resultLengthlength 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 an UnicodeSet that contains all the characters and sequences tailored in this collator.

Parameters
statuserror 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 UCA. 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.

Lower 16 bits are undefined and should be ignored.

Parameters
statuserror code (not changed by function). If error code is set, the return value is undefined.
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
infothe 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
sourcethe source string to be compared with.
targetthe 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
sourcethe source string to be compared with.
targetthe 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 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 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 function supports preflighting.

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

Parameters
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
ucol_getShortDefinitionString
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
otherCollator 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 (!Collator::operator==(other)) { return FALSE; }  // not the same class
  const MyCollator &o = (const MyCollator&)other;
  (compare this vs. o's subclass fields)
Parameters
otherCollator object to be compared
Returns
TRUE if other is the same as this.
Stable:
ICU 2.0

Reimplemented in icu::RuleBasedCollator.

static URegistryKey icu::Collator::registerFactory ( CollatorFactory toAdopt,
UErrorCode status 
)
static

Register a new CollatorFactory.

The factory will be adopted.

Parameters
toAdoptthe CollatorFactory instance to be adopted
statusthe 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.

Parameters
toAdoptthe Collator instance to be adopted
localethe locale with which the collator will be associated
statusthe 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
attrattribute type
valueattribute value
statusto 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 
)
protectedvirtual

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

Parameters
requestedLocalethe requested locale
validLocalethe valid locale
actualLocalethe actual locale
Internal:
Do not use. This API is for internal use only.

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
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.
statuserror code
See Also
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:

* Collator*myCollation = Collator::createInstance(Locale::US, 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
newStrengththe new comparison level.
Deprecated:
ICU 2.6 Use setAttribute(UCOL_STRENGTH...) instead
virtual uint32_t icu::Collator::setVariableTop ( const UChar varTop,
int32_t  len,
UErrorCode status 
)
pure virtual

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

Parameters
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
Stable:
ICU 2.0

Implemented in icu::RuleBasedCollator.

virtual uint32_t icu::Collator::setVariableTop ( const UnicodeString varTop,
UErrorCode status 
)
pure virtual

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

Parameters
varTopan UnicodeString size 1 or more (if contraction) of UChars to which the variable top should be set
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
Stable:
ICU 2.0

Implemented in icu::RuleBasedCollator.

virtual void icu::Collator::setVariableTop ( uint32_t  varTop,
UErrorCode status 
)
pure virtual

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
varTopCE value, as returned by setVariableTop or ucol)getVariableTop
statuserror code (not changed by function)
Stable:
ICU 2.0

Implemented in icu::RuleBasedCollator.

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.

Parameters
keythe registry key returned by a previous call to registerInstance
statusthe 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: